ralphctl 0.4.2 → 0.4.4

package/dist/{chunk-GL7MKLLS.mjs → chunk-ACRMBVEE.mjs}

@@ -2,27 +2,19 @@
 import {
   PromptCancelledError,
   addCheckScriptToRepository,
-  escapableSelect
-} from "./chunk-D2YGPLIV.mjs";
+  escapableSelect,
+  getAllConfigSchemaEntries,
+  getConfigDefaultValue,
+  parseConfigValue
+} from "./chunk-PYZEQ2VK.mjs";
 import {
   editorInput
-} from "./chunk-7JLZQICD.mjs";
+} from "./chunk-OGEXYSFS.mjs";
 import {
-  addProjectRepo,
-  getProject,
-  getProjectById,
-  getRepoById,
-  listProjects,
-  removeProject,
-  removeProjectRepo,
-  resolveRepoPath
-} from "./chunk-NUYQK5MN.mjs";
-import {
-  SignalParser,
   addTask,
   areAllTasksDone,
   branchExists,
-  buildTicketRefinePrompt,
+  createExecuteSprintPipeline,
   createIdeatePipeline,
   createPlanPipeline,
   createRefinePipeline,
@@ -40,19 +32,23 @@ import {
   isGlabAvailable,
   listTasks,
   parseRequirementsFile,
-  processLifecycleAdapter,
-  providerDisplayName,
   removeTask,
   renderParsedTasksTable,
   reorderByDependencies,
   reorderTask,
-  resolveProvider,
   runAiSession,
   saveTasks,
   updateTask,
   updateTaskStatus,
   validateImportTasks
-} from "./chunk-TKPTT2UG.mjs";
+} from "./chunk-OFILN7QL.mjs";
+import {
+  SignalParser,
+  buildTicketRefinePrompt,
+  processLifecycleAdapter,
+  providerDisplayName,
+  resolveProvider
+} from "./chunk-ZLWSPLWI.mjs";
 import {
   fetchIssueFromUrl,
   formatIssueContext,
@@ -63,7 +59,7 @@ import {
   removeTicket,
   truncate,
   updateTicket
-} from "./chunk-JOQO4HMM.mjs";
+} from "./chunk-GQ2WFKBN.mjs";
 import {
   EXIT_ERROR,
   exitWithCode
@@ -72,33 +68,33 @@ import {
   getPrompt,
   getSharedDeps
 } from "./chunk-747KW2RW.mjs";
+import {
+  addProjectRepo,
+  getProject,
+  getProjectById,
+  getRepoById,
+  listProjects,
+  removeProject,
+  removeProjectRepo,
+  resolveRepoPath
+} from "./chunk-BSB4EDGR.mjs";
 import {
   activateSprint,
   assertSprintStatus,
   closeSprint,
   createSprint,
   deleteSprint,
-  getAiProvider,
-  getConfig,
-  getCurrentSprint,
   getCurrentSprintOrThrow,
-  getEditor,
-  getEvaluationIterations,
   getProgress,
   getSprint,
   listSprints,
   logProgress,
   logSprintBaselines,
   resolveSprintId,
-  saveConfig,
   saveSprint,
-  setAiProvider,
-  setCurrentSprint,
-  setEditor,
-  setEvaluationIterations,
   summarizeProgressForContext,
   withFileLock
-} from "./chunk-YCDUVPRT.mjs";
+} from "./chunk-CBMFRQ4Y.mjs";
 import {
   DETAIL_LABEL_WIDTH,
   badge,
@@ -111,6 +107,11 @@ import {
   fieldMultiline,
   formatSprintStatus,
   formatTaskStatus,
+  getAiProvider,
+  getConfig,
+  getCurrentSprint,
+  getEditor,
+  getEvaluationIterations,
   getQuoteForContext,
   horizontalLine,
   icons,
@@ -123,6 +124,11 @@ import {
   progressBar,
   renderCard,
   renderTable,
+  saveConfig,
+  setAiProvider,
+  setCurrentSprint,
+  setEditor,
+  setEvaluationIterations,
   showEmpty,
   showError,
   showNextStep,
@@ -133,13 +139,14 @@ import {
   showWarning,
   success,
   terminalBell
-} from "./chunk-FKMKOWLA.mjs";
+} from "./chunk-XN2UIHBY.mjs";
 import {
   ensureError,
   unwrapOrThrow,
   wrapAsync
 } from "./chunk-IWXBJD2D.mjs";
 import {
+  CURRENT_ONBOARDING_VERSION,
   ImportTasksSchema,
   RequirementStatusSchema,
   SprintSchema,
@@ -162,22 +169,22 @@ import {
   getTasksFilePath,
   readValidatedJson,
   validateProjectPath
-} from "./chunk-CTP2A436.mjs";
+} from "./chunk-WDMLPXOD.mjs";
 import {
+  ExecutionAlreadyRunningError,
   NoCurrentSprintError,
   ProjectNotFoundError,
   SprintNotFoundError,
   SprintStatusError,
   StorageError,
   TaskNotFoundError,
-  TicketNotFoundError,
-  ValidationError
-} from "./chunk-57UWLHRH.mjs";
+  TicketNotFoundError
+} from "./chunk-VAZ3LJBI.mjs";
 
 // package.json
 var package_default = {
   name: "ralphctl",
-  version: "0.4.2",
+  version: "0.4.4",
   description: "Agent harness for long-running AI coding tasks \u2014 orchestrates Claude Code & GitHub Copilot across repositories",
   homepage: "https://github.com/lukas-grigis/ralphctl",
   type: "module",
@@ -245,8 +252,8 @@ var package_default = {
     "@types/node": "^25.6.0",
     "@types/react": "^19.2.14",
     "@types/tabtab": "^3.0.4",
-    "@vitest/coverage-v8": "^4.1.4",
-    eslint: "^10.2.0",
+    "@vitest/coverage-v8": "^4.1.5",
+    eslint: "^10.2.1",
     "eslint-config-prettier": "^10.1.8",
     globals: "^17.5.0",
     husky: "^9.1.7",
@@ -256,11 +263,11 @@ var package_default = {
     tsup: "^8.5.1",
     tsx: "^4.21.0",
     typescript: "^5.9.3",
-    "typescript-eslint": "^8.58.2",
-    vitest: "^4.1.4"
+    "typescript-eslint": "^8.59.0",
+    vitest: "^4.1.5"
   },
   "lint-staged": {
-    "*.ts": [
+    "*.{ts,tsx}": [
       "eslint --cache --fix",
       "prettier --write"
     ],
@@ -1236,6 +1243,153 @@ var InkPromptAdapter = class {
   }
 };
 
+// src/integration/ui/tui/runtime/event-bus.ts
+var FRAME_MS2 = 16;
+var InMemoryLogEventBus = class {
+  listeners = /* @__PURE__ */ new Set();
+  buffer = [];
+  flushTimer = null;
+  emit(event) {
+    this.buffer.push(event);
+    this.scheduleFlush();
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  dispose() {
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+    this.listeners.clear();
+    this.buffer.length = 0;
+  }
+  /** Force immediate drain. Primarily for tests. */
+  flush() {
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+    this.drain();
+  }
+  scheduleFlush() {
+    if (this.flushTimer !== null) return;
+    const timer = setTimeout(() => {
+      this.flushTimer = null;
+      this.drain();
+    }, FRAME_MS2);
+    timer.unref();
+    this.flushTimer = timer;
+  }
+  drain() {
+    if (this.buffer.length === 0) return;
+    const batch = this.buffer.splice(0, this.buffer.length);
+    for (const listener of this.listeners) {
+      try {
+        listener(batch);
+      } catch {
+      }
+    }
+  }
+};
+var logEventBus = new InMemoryLogEventBus();
+
+// src/integration/logging/ink-sink.ts
+var spinnerId = 0;
+var InkSink = class _InkSink {
+  constructor(context = {}, bus) {
+    this.context = context;
+    this.bus = bus ?? logEventBus;
+  }
+  context;
+  bus;
+  emit(event) {
+    this.bus.emit(event);
+  }
+  // -- Structured log levels --------------------------------------------------
+  debug(message, context) {
+    this.emit({ kind: "log", level: "debug", message, context: this.merge(context), timestamp: /* @__PURE__ */ new Date() });
+  }
+  info(message, context) {
+    this.emit({ kind: "log", level: "info", message, context: this.merge(context), timestamp: /* @__PURE__ */ new Date() });
+  }
+  warn(message, context) {
+    this.emit({ kind: "log", level: "warn", message, context: this.merge(context), timestamp: /* @__PURE__ */ new Date() });
+  }
+  error(message, context) {
+    this.emit({ kind: "log", level: "error", message, context: this.merge(context), timestamp: /* @__PURE__ */ new Date() });
+  }
+  // -- UI-level output --------------------------------------------------------
+  success(message) {
+    this.emit({ kind: "log", level: "success", message, context: this.context, timestamp: /* @__PURE__ */ new Date() });
+  }
+  warning(message) {
+    this.emit({ kind: "log", level: "warning", message, context: this.context, timestamp: /* @__PURE__ */ new Date() });
+  }
+  tip(message) {
+    this.emit({ kind: "log", level: "tip", message, context: this.context, timestamp: /* @__PURE__ */ new Date() });
+  }
+  // -- Layout -----------------------------------------------------------------
+  header(title, icon) {
+    this.emit({ kind: "header", title, icon, timestamp: /* @__PURE__ */ new Date() });
+  }
+  separator(width = 40) {
+    this.emit({ kind: "separator", width, timestamp: /* @__PURE__ */ new Date() });
+  }
+  field(label, value, _width) {
+    void _width;
+    this.emit({ kind: "field", label, value, timestamp: /* @__PURE__ */ new Date() });
+  }
+  card(title, lines) {
+    this.emit({ kind: "card", title, lines, timestamp: /* @__PURE__ */ new Date() });
+  }
+  newline() {
+    this.emit({ kind: "newline", timestamp: /* @__PURE__ */ new Date() });
+  }
+  dim(message) {
+    this.emit({ kind: "log", level: "dim", message, context: this.context, timestamp: /* @__PURE__ */ new Date() });
+  }
+  item(message) {
+    this.emit({ kind: "log", level: "item", message, context: this.context, timestamp: /* @__PURE__ */ new Date() });
+  }
+  // -- Interactive ------------------------------------------------------------
+  spinner(message) {
+    const id = ++spinnerId;
+    this.emit({ kind: "spinner-start", id, message, timestamp: /* @__PURE__ */ new Date() });
+    return {
+      succeed: (msg) => {
+        this.emit({ kind: "spinner-succeed", id, message: msg, timestamp: /* @__PURE__ */ new Date() });
+      },
+      fail: (msg) => {
+        this.emit({ kind: "spinner-fail", id, message: msg, timestamp: /* @__PURE__ */ new Date() });
+      },
+      stop: () => {
+        this.emit({ kind: "spinner-stop", id, timestamp: /* @__PURE__ */ new Date() });
+      }
+    };
+  }
+  // -- Scoped child -----------------------------------------------------------
+  child(context) {
+    return new _InkSink({ ...this.context, ...context }, this.bus);
+  }
+  // -- Timing -----------------------------------------------------------------
+  time(label) {
+    const start = Date.now();
+    return () => {
+      const ms = Date.now() - start;
+      this.debug(`${label}: ${String(ms)}ms`);
+    };
+  }
+  // -- Internals --------------------------------------------------------------
+  merge(extra) {
+    if (!extra) return this.context;
+    return { ...this.context, ...extra };
+  }
+};
+
 // src/integration/persistence/evaluation.ts
 async function writeEvaluation(sprintId, taskId, iteration, status, body) {
   const filePath = getEvaluationFilePath(sprintId, taskId);
@@ -1835,6 +1989,148 @@ var RateLimitCoordinator = class {
   }
 };
 
+// src/integration/runtime/execution-registry.ts
+import { randomUUID } from "crypto";
+
+// src/integration/runtime/execution-scope.ts
+function createExecutionScope(baseShared, args) {
+  const scopedLogger = baseShared.logger instanceof InkSink ? new InkSink({ executionId: args.executionId }, args.logEventBus) : baseShared.logger.child({ executionId: args.executionId });
+  return {
+    ...baseShared,
+    signalBus: args.signalBus,
+    logger: scopedLogger
+  };
+}
+
+// src/integration/runtime/execution-registry.ts
+var InMemoryExecutionRegistry = class {
+  baseShared;
+  runner;
+  generateId;
+  createAbortController;
+  entries = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Set();
+  constructor(options) {
+    this.baseShared = options.baseShared;
+    this.runner = options.runner;
+    this.generateId = options.generateId ?? (() => randomUUID());
+    this.createAbortController = options.createAbortController ?? (() => new AbortController());
+  }
+  async start(params) {
+    const sprint = await this.baseShared.persistence.getSprint(params.sprintId);
+    const project = await this.baseShared.persistence.getProjectById(sprint.projectId);
+    const existing = this.findRunningForProject(project.name);
+    if (existing) {
+      throw new ExecutionAlreadyRunningError(project.name, existing.id);
+    }
+    const executionId = this.generateId();
+    const signalBus = new InMemorySignalBus();
+    const logEventBus2 = new InMemoryLogEventBus();
+    const abortController = this.createAbortController();
+    const scopedShared = createExecutionScope(this.baseShared, {
+      executionId,
+      logEventBus: logEventBus2,
+      signalBus,
+      abortController
+    });
+    const execution = {
+      id: executionId,
+      projectName: project.name,
+      sprintId: sprint.id,
+      sprint,
+      status: "running",
+      startedAt: /* @__PURE__ */ new Date()
+    };
+    const entry = {
+      execution,
+      signalBus,
+      logEventBus: logEventBus2,
+      abortController,
+      // Lazy-initialised below; `runner` needs the entry to exist in the map
+      // before it starts emitting so listeners can observe early signals.
+      pipelinePromise: Promise.resolve()
+    };
+    this.entries.set(executionId, entry);
+    this.notify(execution);
+    entry.pipelinePromise = this.runPipeline(executionId, scopedShared, params, abortController.signal);
+    return execution;
+  }
+  async runPipeline(executionId, scopedShared, params, abortSignal) {
+    try {
+      const summary = await this.runner(scopedShared, {
+        sprintId: params.sprintId,
+        options: params.options,
+        abortSignal
+      });
+      if (abortSignal.aborted) {
+        this.transition(executionId, "cancelled", summary ?? void 0);
+      } else {
+        this.transition(executionId, "completed", summary ?? void 0);
+      }
+    } catch (err) {
+      void err;
+      if (abortSignal.aborted) {
+        this.transition(executionId, "cancelled");
+      } else {
+        this.transition(executionId, "failed");
+      }
+    }
+  }
+  get(id) {
+    return this.entries.get(id)?.execution ?? null;
+  }
+  list() {
+    return Array.from(this.entries.values(), (entry) => entry.execution);
+  }
+  cancel(id) {
+    const entry = this.entries.get(id);
+    if (!entry) return;
+    if (entry.execution.status !== "running") return;
+    entry.abortController.abort();
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  getSignalBus(id) {
+    return this.entries.get(id)?.signalBus ?? null;
+  }
+  getLogEventBus(id) {
+    return this.entries.get(id)?.logEventBus ?? null;
+  }
+  transition(executionId, status, summary) {
+    const entry = this.entries.get(executionId);
+    if (!entry) return;
+    if (entry.execution.status === status) return;
+    const next = {
+      ...entry.execution,
+      status,
+      endedAt: /* @__PURE__ */ new Date(),
+      summary: summary ?? entry.execution.summary
+    };
+    entry.execution = next;
+    this.notify(next);
+  }
+  findRunningForProject(projectName) {
+    for (const entry of this.entries.values()) {
+      if (entry.execution.projectName === projectName && entry.execution.status === "running") {
+        return entry.execution;
+      }
+    }
+    return null;
+  }
+  notify(execution) {
+    for (const listener of this.listeners) {
+      try {
+        listener(execution);
+      } catch {
+      }
+    }
+  }
+};
+
 // src/application/shared.ts
 function createSharedDeps(overrides = {}) {
   const persistence = overrides.persistence ?? new FilePersistenceAdapter();
@@ -1846,7 +2142,7 @@ function createSharedDeps(overrides = {}) {
   const signalBus = overrides.signalBus ?? new NoopSignalBus();
   const createRateLimitCoordinator = overrides.createRateLimitCoordinator ?? (() => new RateLimitCoordinator());
   const processLifecycle = overrides.processLifecycle ?? processLifecycleAdapter;
-  return {
+  const base = {
     persistence,
     filesystem,
     signalParser,
@@ -1857,6 +2153,17 @@ function createSharedDeps(overrides = {}) {
     createRateLimitCoordinator,
     processLifecycle
   };
+  const defaultRunner = async (scopedShared, { sprintId, options, abortSignal }) => {
+    const pipeline = createExecuteSprintPipeline(scopedShared, options);
+    const result = await executePipeline(pipeline, { sprintId, abortSignal });
+    if (!result.ok) {
+      throw result.error;
+    }
+    const summary = result.value.context.executionSummary;
+    return summary ?? null;
+  };
+  base.executionRegistry = overrides.executionRegistry ?? new InMemoryExecutionRegistry({ baseShared: base, runner: defaultRunner });
+  return base;
 }
 
 // src/integration/cli/commands/project/list.ts
@@ -1897,7 +2204,7 @@ async function selectProject(message = "Select project:") {
       default: true
     });
     if (create) {
-      const { projectAddCommand } = await import("./add-GX7P7XTT.mjs");
+      const { projectAddCommand } = await import("./add-YVXM34RP.mjs");
       await projectAddCommand({ interactive: true });
       const updated = await listProjects();
       if (updated.length === 0) return null;
@@ -1932,7 +2239,7 @@ async function selectSprint(message = "Select sprint:", filter) {
       default: true
     });
     if (create) {
-      const { sprintCreateCommand } = await import("./create-7WFSCMP4.mjs");
+      const { sprintCreateCommand } = await import("./create-Z635FQKO.mjs");
       await sprintCreateCommand({ interactive: true });
       const updated = await listSprints();
       const refiltered = filter ? updated.filter((s) => filter.includes(s.status)) : updated;
@@ -1967,7 +2274,7 @@ async function selectTicket(message = "Select ticket:", filter) {
         default: true
       });
       if (create) {
-        const { ticketAddCommand } = await import("./add-CIM72NE3.mjs");
+        const { ticketAddCommand } = await import("./add-DVPVHENV.mjs");
         await ticketAddCommand({ interactive: true });
         const updated = await listTickets();
         const refiltered = filter ? updated.filter(filter) : updated;
@@ -4615,136 +4922,6 @@ async function progressShowCommand() {
   console.log(content);
 }
 
-// src/integration/config/schema-provider.ts
-import { Result as Result6 } from "typescript-result";
-
-// src/domain/config-schema.ts
-var ConfigSchemaDefinition = {
-  currentSprint: {
-    key: "currentSprint",
-    label: "Current Sprint",
-    type: "string",
-    default: null,
-    description: "Currently active sprint ID (set by `sprint start`, cleared on `sprint close`)",
-    validation: (val) => val === null || typeof val === "string" && val.length > 0,
-    scope: "global"
-  },
-  aiProvider: {
-    key: "aiProvider",
-    label: "AI Provider",
-    type: "enum",
-    enum: ["claude", "copilot"],
-    default: null,
-    description: "AI provider for task execution (Claude Code or GitHub Copilot CLI)",
-    validation: (val) => val === null || typeof val === "string" && ["claude", "copilot"].includes(val),
-    scope: "global"
-  },
-  evaluationIterations: {
-    key: "evaluationIterations",
-    label: "Evaluation Iterations",
-    type: "integer",
-    min: 0,
-    max: 10,
-    default: 1,
-    description: "Number of fix-attempt iterations after initial evaluation; 0 = disabled. Higher values allow more refinement rounds.",
-    validation: (val) => typeof val === "number" && Number.isInteger(val) && val >= 0 && val <= 10,
-    scope: "sprint"
-  }
-  // Phase 2+ additions can be added here as single schema entries
-  // maxTaskTurns: { ... },
-  // checkScriptTimeout: { ... },
-};
-function getSchemaEntry(key) {
-  return ConfigSchemaDefinition[key];
-}
-function getAllSchemaEntries() {
-  return Object.values(ConfigSchemaDefinition);
-}
-function getDefaultValue(key) {
-  return ConfigSchemaDefinition[key].default;
-}
-
-// src/integration/config/schema-provider.ts
-function getAllConfigSchemaEntries() {
-  return getAllSchemaEntries();
-}
-function getConfigSchemaEntry(key) {
-  return getSchemaEntry(key);
-}
-function getConfigDefaultValue(key) {
-  return getDefaultValue(key);
-}
-function validateConfigValue(key, value) {
-  if (!(key in ConfigSchemaDefinition)) {
-    return Result6.error(new ValidationError(`Unknown config key: ${key}`, key));
-  }
-  const schemaKey = key;
-  const entry = getConfigSchemaEntry(schemaKey);
-  if (!entry.validation(value)) {
-    let errorMsg = `Invalid value for ${key}`;
-    if (entry.type === "enum" && entry.enum) {
-      errorMsg += `: must be one of ${entry.enum.join(", ")}`;
-    } else if (entry.type === "integer" || entry.type === "number") {
-      const constraints = [];
-      if (entry.min !== void 0) constraints.push(`min: ${String(entry.min)}`);
-      if (entry.max !== void 0) constraints.push(`max: ${String(entry.max)}`);
-      if (constraints.length > 0) errorMsg += ` (${constraints.join(", ")})`;
-    }
-    return Result6.error(new ValidationError(errorMsg, key));
-  }
-  return Result6.ok(value);
-}
-function parseConfigValue(key, stringValue) {
-  if (!(key in ConfigSchemaDefinition)) {
-    return Result6.error(new ValidationError(`Unknown config key: ${key}`, key));
-  }
-  const schemaKey = key;
-  const entry = getConfigSchemaEntry(schemaKey);
-  let parsedValue;
-  try {
-    switch (entry.type) {
-      case "string":
-        parsedValue = stringValue === "null" ? null : stringValue;
-        break;
-      case "integer":
-        parsedValue = stringValue === "null" ? null : Number.parseInt(stringValue, 10);
-        if (Number.isNaN(parsedValue)) {
-          return Result6.error(new ValidationError(`Expected integer for ${key}, got ${stringValue}`, key));
-        }
-        break;
-      case "number":
-        parsedValue = stringValue === "null" ? null : Number.parseFloat(stringValue);
-        if (Number.isNaN(parsedValue)) {
-          return Result6.error(new ValidationError(`Expected number for ${key}, got ${stringValue}`, key));
-        }
-        break;
-      case "boolean":
-        if (stringValue.toLowerCase() === "true" || stringValue === "1") {
-          parsedValue = true;
-        } else if (stringValue.toLowerCase() === "false" || stringValue === "0") {
-          parsedValue = false;
-        } else if (stringValue === "null") {
-          parsedValue = null;
-        } else {
-          return Result6.error(new ValidationError(`Expected boolean for ${key}, got ${stringValue}`, key));
-        }
-        break;
-      case "enum":
-        if (stringValue === "null") {
-          parsedValue = null;
-        } else {
-          parsedValue = stringValue;
-        }
-        break;
-    }
-  } catch (err) {
-    return Result6.error(
-      new ValidationError(`Failed to parse ${key}: ${err instanceof Error ? err.message : String(err)}`, key)
-    );
-  }
-  return validateConfigValue(key, parsedValue);
-}
-
 // src/integration/cli/commands/config/config.ts
 var KEY_ALIASES = {
   provider: "aiProvider"
@@ -4820,7 +4997,7 @@ async function configShowCommand() {
 }
 
 // src/integration/cli/commands/doctor/doctor.ts
-import { access as access2, constants } from "fs/promises";
+import { access as access2, constants, readFile as readFile4 } from "fs/promises";
 import { join as join5 } from "path";
 import { spawnSync as spawnSync2 } from "child_process";
 var REQUIRED_NODE_MAJOR = 24;
@@ -4935,6 +5112,90 @@ async function checkProjectPaths() {
   }
   return { name: "Project paths", status: "fail", detail: issues.join("; ") };
 }
+function providerInstructionsRelPath(provider) {
+  if (provider === "claude") return "CLAUDE.md";
+  return ".github/copilot-instructions.md";
+}
+async function checkRepoOnboarding() {
+  const projects = await listProjects();
+  const config = await getConfig();
+  const provider = config.aiProvider;
+  const results = [];
+  for (const project of projects) {
+    for (const repo of project.repositories) {
+      const name = `Onboarding \u2014 ${project.name}/${repo.name}`;
+      if (!provider) {
+        results.push({
+          name,
+          status: "skip",
+          detail: "configure an AI provider to use onboarding"
+        });
+        continue;
+      }
+      const relPath = providerInstructionsRelPath(provider);
+      const instructionsPath = join5(repo.path, relPath);
+      const hasInstructions = await fileExists(instructionsPath);
+      const ver = repo.onboardingVersion;
+      if (ver == null) {
+        if (hasInstructions) {
+          results.push({
+            name,
+            status: "pass",
+            detail: `authored ${relPath} (not harness-managed)`
+          });
+        } else {
+          results.push({
+            name,
+            status: "skip",
+            detail: `never onboarded \u2014 run \`ralphctl project onboard ${project.name} --repo ${repo.name}\``
+          });
+        }
+        continue;
+      }
+      if (!hasInstructions) {
+        results.push({
+          name,
+          status: "warn",
+          detail: `onboardingVersion set but ${relPath} missing \u2014 re-run \`ralphctl project onboard\``
+        });
+        continue;
+      }
+      if (ver < CURRENT_ONBOARDING_VERSION) {
+        results.push({
+          name,
+          status: "warn",
+          detail: `onboarding v${String(ver)} < v${String(CURRENT_ONBOARDING_VERSION)} \u2014 re-run to refresh`
+        });
+        continue;
+      }
+      if (ver > CURRENT_ONBOARDING_VERSION) {
+        results.push({
+          name,
+          status: "warn",
+          detail: `onboarding v${String(ver)} > v${String(CURRENT_ONBOARDING_VERSION)} \u2014 repo onboarded by a newer ralphctl version \u2014 upgrade the CLI to manage it cleanly`
+        });
+        continue;
+      }
+      let body;
+      try {
+        body = await readFile4(instructionsPath, "utf-8");
+      } catch {
+        results.push({ name, status: "warn", detail: `${relPath} unreadable \u2014 re-run \`ralphctl project onboard\`` });
+        continue;
+      }
+      if (body.includes("LOW-CONFIDENCE:")) {
+        results.push({
+          name,
+          status: "warn",
+          detail: "low-confidence sections detected \u2014 re-run interactively to review"
+        });
+        continue;
+      }
+      results.push({ name, status: "pass", detail: `onboarding v${String(ver)}` });
+    }
+  }
+  return results;
+}
 async function checkEvaluationConfig() {
   const config = await getConfig();
   if (config.evaluationIterations == null) {
@@ -4950,6 +5211,17 @@ async function checkEvaluationConfig() {
     detail: `evaluationIterations: ${String(config.evaluationIterations)}`
   };
 }
+async function checkAiCheckScriptDiscovery() {
+  const config = await getConfig();
+  if (config.aiCheckScriptDiscovery === false) {
+    return {
+      name: "AI check-script discovery",
+      status: "warn",
+      detail: "disabled \u2014 `project add` will skip the AI fallback for unrecognized ecosystems (re-enable: ralphctl config set aiCheckScriptDiscovery true)"
+    };
+  }
+  return null;
+}
 async function checkConfigSchemaValidation() {
   const config = await getConfig();
   const entries = getAllConfigSchemaEntries();
@@ -4999,9 +5271,14 @@ async function doctorCommand() {
     checkProjectPaths(),
     checkCurrentSprint(),
     checkEvaluationConfig(),
+    checkAiCheckScriptDiscovery(),
     checkConfigSchemaValidation()
   ]);
-  results.push(...asyncResults);
+  for (const r of asyncResults) {
+    if (r !== null) results.push(r);
+  }
+  const onboardingResults = await checkRepoOnboarding();
+  results.push(...onboardingResults);
   for (const result of results) {
     if (result.status === "pass") {
       log.success(`${result.name}${result.detail ? colors.muted(` \u2014 ${result.detail}`) : ""}`);
@@ -5225,9 +5502,6 @@ export {
   loadDashboardData,
   getNextAction,
   showDashboard,
-  getAllSchemaEntries,
-  validateConfigValue,
-  parseConfigValue,
   configSetCommand,
   configShowCommand,
   checkNodeVersion,
@@ -5237,6 +5511,7 @@ export {
   checkGlabInstalled,
   checkDataDirectory,
   checkProjectPaths,
+  checkRepoOnboarding,
   checkEvaluationConfig,
   checkConfigSchemaValidation,
   checkCurrentSprint,
@@ -5251,5 +5526,7 @@ export {
   PromptHost,
   registerExternalHost,
   InkPromptAdapter,
+  logEventBus,
+  InkSink,
   createSharedDeps
 };