@ouro.bot/cli 0.1.0-alpha.50 → 0.1.0-alpha.500

package/dist/heart/daemon/agent-discovery.js

@@ -33,12 +33,25 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.listAllBundleAgents = listAllBundleAgents;
 exports.listEnabledBundleAgents = listEnabledBundleAgents;
+exports.listBundleSyncRows = listBundleSyncRows;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
 const identity_1 = require("../identity");
 const runtime_1 = require("../../nerves/runtime");
-function listEnabledBundleAgents(options = {}) {
+/**
+ * Walk the bundles root and return one row per `<name>.ouro` directory whose
+ * `agent.json` is readable and parseable. Includes both enabled and disabled
+ * agents — the caller decides what to do with the `enabled` flag.
+ *
+ * Bundles whose `agent.json` is missing, malformed, or unreadable are skipped
+ * silently (they aren't real agents from the harness's perspective).
+ *
+ * Sorted alphabetically by name for stable display.
+ */
+function listAllBundleAgents(options = {}) {
     const bundlesRoot = options.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)();
     const readdirSync = options.readdirSync ?? fs.readdirSync;
     const readFileSync = options.readFileSync ?? fs.readFileSync;
@@ -73,9 +86,72 @@ function listEnabledBundleAgents(options = {}) {
         catch {
             continue;
         }
+        discovered.push({ name: agentName, enabled });
+    }
+    return discovered.sort((left, right) => left.name.localeCompare(right.name));
+}
+function listEnabledBundleAgents(options = {}) {
+    return listAllBundleAgents(options).filter((row) => row.enabled).map((row) => row.name);
+}
+/**
+ * Read the per-agent sync block from each enabled bundle's agent.json.
+ * Used by the daemon (and stopped-state status renderer) to build per-agent
+ * sync rows without depending on argv-derived global identity. Bundles that
+ * cannot be read are skipped silently.
+ *
+ * For rows with sync enabled, also checks whether the bundle is a git repo
+ * (via .git directory presence) and resolves the remote URL via
+ * `git remote get-url <remote>`. On any error the URL is left undefined and
+ * the status renderer falls back to "local only" or "not a git repo".
+ */
+function listBundleSyncRows(options = {}) {
+    const bundlesRoot = options.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)();
+    const readFileSync = options.readFileSync ?? fs.readFileSync;
+    const execFileSync = options.execFileSync ?? child_process_1.execFileSync;
+    const existsSync = options.existsSync ?? fs.existsSync;
+    const agents = listEnabledBundleAgents(options);
+    const rows = [];
+    for (const agent of agents) {
+        const bundleRoot = path.join(bundlesRoot, `${agent}.ouro`);
+        const configPath = path.join(bundleRoot, "agent.json");
+        let enabled = false;
+        let remote = "origin";
+        try {
+            const raw = readFileSync(configPath, "utf-8");
+            const parsed = JSON.parse(raw);
+            if (parsed.sync && typeof parsed.sync === "object") {
+                if (typeof parsed.sync.enabled === "boolean")
+                    enabled = parsed.sync.enabled;
+                if (typeof parsed.sync.remote === "string" && parsed.sync.remote.length > 0) {
+                    remote = parsed.sync.remote;
+                }
+            }
+        }
+        catch {
+            // Best-effort: bundle without readable config still gets a row with defaults
+        }
+        const row = { agent, enabled, remote };
         if (enabled) {
-            discovered.push(agentName);
+            // Only meaningful when sync is enabled — we don't care about disabled bundles'
+            // git state. Check .git presence before attempting any git invocation.
+            const gitInitialized = existsSync(path.join(bundleRoot, ".git"));
+            row.gitInitialized = gitInitialized;
+            if (gitInitialized) {
+                try {
+                    const out = execFileSync("git", ["remote", "get-url", remote], {
+                        cwd: bundleRoot,
+                        stdio: "pipe",
+                        timeout: 5000,
+                    }).toString().trim();
+                    if (out.length > 0)
+                        row.remoteUrl = out;
+                }
+                catch {
+                    // No remote configured or git missing — leave remoteUrl undefined.
+                }
+            }
         }
+        rows.push(row);
     }
-    return discovered.sort((left, right) => left.localeCompare(right));
+    return rows;
 }

package/dist/heart/daemon/agent-service.js

@@ -0,0 +1,360 @@
+"use strict";
+/**
+ * Agent service layer — handles MCP-facing daemon commands.
+ * Each handler receives { agent, friendId, ...params } and returns DaemonResponse.
+ *
+ * DRY: uses the same shared functions the agent's own tools use (diary, session transcript).
+ * This file is a thin adapter — no reimplemented search, parsing, or state reading.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleAgentStatus = handleAgentStatus;
+exports.handleAgentAsk = handleAgentAsk;
+exports.handleAgentCatchup = handleAgentCatchup;
+exports.handleAgentDelegate = handleAgentDelegate;
+exports.handleAgentGetContext = handleAgentGetContext;
+exports.handleAgentSearchNotes = handleAgentSearchNotes;
+exports.handleAgentGetTask = handleAgentGetTask;
+exports.handleAgentCheckScope = handleAgentCheckScope;
+exports.handleAgentRequestDecision = handleAgentRequestDecision;
+exports.handleAgentCheckGuidance = handleAgentCheckGuidance;
+exports.handleAgentReportProgress = handleAgentReportProgress;
+exports.handleAgentReportBlocker = handleAgentReportBlocker;
+exports.handleAgentReportComplete = handleAgentReportComplete;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const identity_1 = require("../identity");
+const diary_1 = require("../../mind/diary");
+const runtime_1 = require("../../nerves/runtime");
+/** Format diary hits the same way the search_notes tool does. */
+function formatDiaryHits(hits) {
+    return hits.map((f) => `[diary] ${f.text} (source=${f.source}, createdAt=${f.createdAt})`);
+}
+/** Read a file from the agent root, returning null if it doesn't exist. */
+function readAgentFile(agent, ...segments) {
+    const filePath = path.join((0, identity_1.getAgentRoot)(agent), ...segments);
+    if (!fs.existsSync(filePath))
+        return null;
+    return fs.readFileSync(filePath, "utf-8");
+}
+/** Resolve the diary root for a specific agent. */
+function agentDiaryRoot(agent) {
+    return (0, diary_1.resolveDiaryRoot)(path.join((0, identity_1.getAgentRoot)(agent), "diary"));
+}
+/** Read inner dialog runtime status. */
+function readInnerDialogStatus(agent) {
+    const content = readAgentFile(agent, "state", "sessions", "self", "inner", "runtime.json");
+    if (!content)
+        return null;
+    try {
+        const data = JSON.parse(content);
+        return { status: data.status ?? "unknown", lastCompletedAt: data.lastCompletedAt ?? "" };
+    }
+    catch {
+        return null;
+    }
+}
+function safeReaddir(dirPath) {
+    try {
+        return fs.readdirSync(dirPath).map(String);
+        /* v8 ignore start — catch is defensive; tested paths don't trigger fs errors */
+    }
+    catch {
+        return [];
+    }
+    /* v8 ignore stop */
+}
+function safeIsDir(dirPath) {
+    try {
+        return fs.statSync(dirPath).isDirectory();
+        /* v8 ignore start — catch is defensive; tested paths don't trigger fs errors */
+    }
+    catch {
+        return false;
+    }
+    /* v8 ignore stop */
+}
+/** Enumerate sessions from state/sessions/, reading session.json files. */
+function enumerateSessions(agent) {
+    const sessionsDir = path.join((0, identity_1.getAgentRoot)(agent), "state", "sessions");
+    if (!fs.existsSync(sessionsDir))
+        return [];
+    const sessions = [];
+    for (const friendId of safeReaddir(sessionsDir)) {
+        const friendPath = path.join(sessionsDir, friendId);
+        if (!safeIsDir(friendPath))
+            continue;
+        for (const channel of safeReaddir(friendPath)) {
+            const channelPath = path.join(friendPath, channel);
+            if (!safeIsDir(channelPath))
+                continue;
+            for (const key of safeReaddir(channelPath)) {
+                const sessionFile = path.join(channelPath, key, "session.json");
+                if (!fs.existsSync(sessionFile))
+                    continue;
+                try {
+                    const data = JSON.parse(fs.readFileSync(sessionFile, "utf-8"));
+                    sessions.push({ friendId, channel, key, lastUsage: data.lastUsage ?? "" });
+                }
+                catch { /* skip malformed */ }
+            }
+        }
+    }
+    return sessions;
+}
+/** List markdown files in {agentRoot}/tasks/. */
+function listTaskFiles(agent) {
+    const tasksDir = path.join((0, identity_1.getAgentRoot)(agent), "tasks");
+    if (!fs.existsSync(tasksDir))
+        return [];
+    try {
+        return fs.readdirSync(tasksDir).map(String).filter((f) => f.endsWith(".md"));
+    }
+    catch {
+        return [];
+    }
+}
+function emit(event, message, meta) {
+    (0, runtime_1.emitNervesEvent)({ component: "daemon", event, message, meta });
+}
+// ─── Handlers ────────────────────────────────────────────────────────────────
+async function handleAgentStatus(params) {
+    (0, runtime_1.emitNervesEvent)({ component: "daemon", event: "daemon.agent_service_start", message: "handling agent.status", meta: { agent: params.agent } });
+    const diaryRoot = agentDiaryRoot(params.agent);
+    const facts = (0, diary_1.readDiaryEntries)(diaryRoot);
+    const innerStatus = readInnerDialogStatus(params.agent);
+    const sessions = enumerateSessions(params.agent);
+    emit("daemon.agent_service_end", "completed agent.status", { agent: params.agent });
+    return {
+        ok: true,
+        message: `Agent ${params.agent} status`,
+        data: {
+            agent: params.agent,
+            innerStatus: innerStatus?.status ?? "unknown",
+            lastThoughtAt: innerStatus?.lastCompletedAt ?? null,
+            sessionCount: sessions.length,
+            hasDiaryEntries: facts.length > 0,
+            factCount: facts.length,
+        },
+    };
+}
+async function handleAgentAsk(params) {
+    emit("daemon.agent_service_start", "handling agent.ask", { agent: params.agent });
+    const question = params.question;
+    if (!question) {
+        emit("daemon.agent_service_error", "agent.ask missing question", { agent: params.agent });
+        return { ok: false, error: "Missing required parameter: question" };
+    }
+    // Use the same searchDiaryEntries the search_notes tool uses (substring fallback — no embedding provider in shim)
+    const diaryRoot = agentDiaryRoot(params.agent);
+    const hits = await (0, diary_1.searchDiaryEntries)(question, (0, diary_1.readDiaryEntries)(diaryRoot));
+    const context = hits.length > 0
+        ? hits.slice(0, 10).map((f) => f.text).join("\n")
+        : `No relevant notes found for: ${question}`;
+    emit("daemon.agent_service_end", "completed agent.ask", { agent: params.agent });
+    return { ok: true, message: context };
+}
+async function handleAgentCatchup(params) {
+    emit("daemon.agent_service_start", "handling agent.catchup", { agent: params.agent });
+    const sessions = enumerateSessions(params.agent);
+    const sorted = sessions.sort((a, b) => (b.lastUsage || "").localeCompare(a.lastUsage || ""));
+    const recentSessions = sorted.slice(0, 5);
+    const innerStatus = readInnerDialogStatus(params.agent);
+    const parts = [];
+    if (innerStatus) {
+        parts.push(`Inner dialog: ${innerStatus.status} (last completed: ${innerStatus.lastCompletedAt || "never"})`);
+    }
+    if (recentSessions.length > 0) {
+        parts.push(`Recent sessions (${recentSessions.length}):`);
+        for (const s of recentSessions) {
+            parts.push(`  - ${s.friendId}/${s.channel}/${s.key} (${s.lastUsage || "unknown"})`);
+        }
+    }
+    else {
+        parts.push("No recent sessions");
+    }
+    emit("daemon.agent_service_end", "completed agent.catchup", { agent: params.agent });
+    return {
+        ok: true,
+        /* v8 ignore next — parts always has at least one element (either sessions or "No recent sessions") */
+        message: parts.length > 0 ? parts.join("\n") : `No recent activity for ${params.agent}`,
+        data: { recentSessions, innerStatus },
+    };
+}
+async function handleAgentDelegate(params) {
+    emit("daemon.agent_service_start", "handling agent.delegate", { agent: params.agent });
+    const task = params.task;
+    if (!task) {
+        emit("daemon.agent_service_error", "agent.delegate missing task", { agent: params.agent });
+        return { ok: false, error: "Missing required parameter: task" };
+    }
+    emit("daemon.agent_service_end", "completed agent.delegate", { agent: params.agent });
+    return { ok: true, message: `Task queued: ${task}`, data: { task, context: params.context ?? null, queuedAt: new Date().toISOString() } };
+}
+async function handleAgentGetContext(params) {
+    emit("daemon.agent_service_start", "handling agent.getContext", { agent: params.agent });
+    const query = (params.question ?? params.query ?? params.topic);
+    const diaryRoot = agentDiaryRoot(params.agent);
+    const facts = (0, diary_1.readDiaryEntries)(diaryRoot);
+    const innerStatus = readInnerDialogStatus(params.agent);
+    const sessions = enumerateSessions(params.agent);
+    const taskFiles = listTaskFiles(params.agent);
+    let noteSummary = null;
+    if (query) {
+        const hits = await (0, diary_1.searchDiaryEntries)(query, facts);
+        noteSummary = hits.length > 0
+            ? hits.slice(0, 10).map((f) => f.text).join("\n")
+            : `No relevant notes for: ${query}`;
+    }
+    else {
+        const recent = facts.slice(-10);
+        if (recent.length > 0)
+            noteSummary = recent.map((f) => f.text).join("\n");
+    }
+    emit("daemon.agent_service_end", "completed agent.getContext", { agent: params.agent });
+    return {
+        ok: true,
+        data: {
+            agent: params.agent,
+            hasDiaryEntries: facts.length > 0,
+            factCount: facts.length,
+            noteSummary,
+            taskCount: taskFiles.length,
+            sessionCount: sessions.length,
+            innerStatus: innerStatus?.status ?? null,
+        },
+    };
+}
+async function handleAgentSearchNotes(params) {
+    emit("daemon.agent_service_start", "handling agent.searchNotes", { agent: params.agent });
+    const query = params.query;
+    if (!query) {
+        emit("daemon.agent_service_error", "agent.searchNotes missing query", { agent: params.agent });
+        return { ok: false, error: "Missing required parameter: query" };
+    }
+    // Same searchDiaryEntries as the search_notes tool
+    const diaryRoot = agentDiaryRoot(params.agent);
+    const hits = await (0, diary_1.searchDiaryEntries)(query, (0, diary_1.readDiaryEntries)(diaryRoot));
+    const formatted = formatDiaryHits(hits.slice(0, 20));
+    emit("daemon.agent_service_end", "completed agent.searchNotes", { agent: params.agent, matchCount: hits.length });
+    return {
+        ok: true,
+        message: hits.length > 0 ? `Found ${hits.length} matches` : "No matches found",
+        data: { query, matches: formatted },
+    };
+}
+async function handleAgentGetTask(params) {
+    emit("daemon.agent_service_start", "handling agent.getTask", { agent: params.agent });
+    const taskFiles = listTaskFiles(params.agent);
+    const activeTasks = taskFiles.filter((f) => f.toLowerCase().includes("doing") && !f.toLowerCase().includes("done"));
+    const taskNames = activeTasks.length > 0 ? activeTasks : taskFiles;
+    const tasks = taskNames.map((name) => {
+        const content = readAgentFile(params.agent, "tasks", name);
+        const firstLine = content?.split("\n").find((l) => l.trim().length > 0)?.trim() ?? "";
+        return { name, statusLine: firstLine };
+    });
+    emit("daemon.agent_service_end", "completed agent.getTask", { agent: params.agent });
+    return {
+        ok: true,
+        message: tasks.length > 0 ? `Tasks (${tasks.length}): ${tasks.map((t) => t.name).join(", ")}` : `No active tasks for ${params.agent}`,
+        data: { tasks, activeCount: activeTasks.length, totalCount: taskFiles.length },
+    };
+}
+async function handleAgentCheckScope(params) {
+    emit("daemon.agent_service_start", "handling agent.checkScope", { agent: params.agent });
+    const item = params.item;
+    if (!item) {
+        emit("daemon.agent_service_error", "agent.checkScope missing item", { agent: params.agent });
+        return { ok: false, error: "Missing required parameter: item" };
+    }
+    emit("daemon.agent_service_end", "completed agent.checkScope", { agent: params.agent });
+    return { ok: true, message: `Scope check for: ${item}`, data: { item, inScope: true, reason: "MVP: scope check requires inference — defaulting to in-scope" } };
+}
+async function handleAgentRequestDecision(params) {
+    emit("daemon.agent_service_start", "handling agent.requestDecision", { agent: params.agent });
+    const topic = params.topic;
+    if (!topic) {
+        emit("daemon.agent_service_error", "agent.requestDecision missing topic", { agent: params.agent });
+        return { ok: false, error: "Missing required parameter: topic" };
+    }
+    emit("daemon.agent_service_end", "completed agent.requestDecision", { agent: params.agent });
+    return { ok: true, message: `Decision request queued: ${topic}`, data: { topic, options: params.options ?? null, status: "pending" } };
+}
+async function handleAgentCheckGuidance(params) {
+    emit("daemon.agent_service_start", "handling agent.checkGuidance", { agent: params.agent });
+    const topic = params.topic;
+    if (!topic) {
+        emit("daemon.agent_service_error", "agent.checkGuidance missing topic", { agent: params.agent });
+        return { ok: false, error: "Missing required parameter: topic" };
+    }
+    // Same searchDiaryEntries as the search_notes tool
+    const diaryRoot = agentDiaryRoot(params.agent);
+    const hits = await (0, diary_1.searchDiaryEntries)(topic, (0, diary_1.readDiaryEntries)(diaryRoot));
+    const guidance = hits.length > 0
+        ? `Relevant guidance:\n${hits.slice(0, 10).map((f) => f.text).join("\n")}`
+        : `No specific guidance found for: ${topic}`;
+    emit("daemon.agent_service_end", "completed agent.checkGuidance", { agent: params.agent });
+    return { ok: true, message: guidance };
+}
+async function handleAgentReportProgress(params) {
+    emit("daemon.agent_service_start", "handling agent.reportProgress", { agent: params.agent });
+    const summary = params.summary;
+    if (!summary) {
+        emit("daemon.agent_service_error", "agent.reportProgress missing summary", { agent: params.agent });
+        return { ok: false, error: "Missing required parameter: summary" };
+    }
+    emit("daemon.agent_service_end", "completed agent.reportProgress", { agent: params.agent });
+    return { ok: true, message: `Progress noted: ${summary}`, data: { summary, receivedAt: new Date().toISOString() } };
+}
+async function handleAgentReportBlocker(params) {
+    emit("daemon.agent_service_start", "handling agent.reportBlocker", { agent: params.agent });
+    const blocker = params.blocker;
+    if (!blocker) {
+        emit("daemon.agent_service_error", "agent.reportBlocker missing blocker", { agent: params.agent });
+        return { ok: false, error: "Missing required parameter: blocker" };
+    }
+    emit("daemon.agent_service_end", "completed agent.reportBlocker", { agent: params.agent });
+    return { ok: true, message: `Blocker reported: ${blocker}`, data: { blocker, receivedAt: new Date().toISOString() } };
+}
+async function handleAgentReportComplete(params) {
+    emit("daemon.agent_service_start", "handling agent.reportComplete", { agent: params.agent });
+    const summary = params.summary;
+    if (!summary) {
+        emit("daemon.agent_service_error", "agent.reportComplete missing summary", { agent: params.agent });
+        return { ok: false, error: "Missing required parameter: summary" };
+    }
+    emit("daemon.agent_service_end", "completed agent.reportComplete", { agent: params.agent });
+    return { ok: true, message: `Completion reported: ${summary}`, data: { summary, receivedAt: new Date().toISOString() } };
+}

package/dist/heart/daemon/agentic-repair.js

@@ -0,0 +1,216 @@
+"use strict";
+/**
+ * Agentic repair flow for degraded agents detected during `ouro up`.
+ *
+ * Runs known local repair prompts first, then offers AI-assisted diagnosis
+ * when no local repair was attempted and a working LLM provider is available.
+ * This is a lightweight integration: one diagnostic LLM call, not a chat loop.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAgenticDiagnosisProviderRuntime = createAgenticDiagnosisProviderRuntime;
+exports.runAgenticRepair = runAgenticRepair;
+const runtime_1 = require("../../nerves/runtime");
+const interactive_repair_1 = require("./interactive-repair");
+const provider_ping_1 = require("../provider-ping");
+const readiness_repair_1 = require("./readiness-repair");
+function buildSystemPrompt(degraded) {
+    const agentList = degraded
+        .map((d) => `- ${d.agent}: error="${d.errorReason}", hint="${d.fixHint}"`)
+        .join("\n");
+    return [
+        "You are a diagnostic assistant for the Ouroboros agent daemon.",
+        "The daemon detected degraded agents during startup.",
+        "Analyze the errors below and provide a concise diagnosis with suggested fixes.",
+        "",
+        "Degraded agents:",
+        agentList,
+        "",
+        "Keep your response brief and actionable. Focus on the most likely root cause",
+        "and the simplest fix the user can apply.",
+    ].join("\n");
+}
+function buildUserMessage(degraded, logsTail) {
+    const agentDetails = degraded
+        .map((d) => `Agent: ${d.agent}\n  Error: ${d.errorReason}\n  Fix hint: ${d.fixHint}`)
+        .join("\n\n");
+    return [
+        "Here are the degraded agents and recent daemon logs:",
+        "",
+        agentDetails,
+        "",
+        "Recent daemon logs:",
+        logsTail,
+        "",
+        "What is the most likely cause and how should I fix it?",
+    ].join("\n");
+}
+function makeInteractiveRepairDeps(deps) {
+    return {
+        promptInput: deps.promptInput,
+        writeStdout: deps.writeStdout,
+        /* v8 ignore next -- fallback no-op: tests always inject runAuthFlow; default is for production @preserve */
+        runAuthFlow: deps.runAuthFlow ?? (async () => undefined),
+        runVaultUnlock: deps.runVaultUnlock,
+        skipQueueSummary: deps.skipQueueSummary,
+        isTTY: deps.isTTY,
+        stdoutColumns: deps.stdoutColumns,
+    };
+}
+async function runDeterministicRepair(degraded, deps) {
+    return deps.runInteractiveRepair(degraded, makeInteractiveRepairDeps(deps));
+}
+function discoveredProviderModel(provider) {
+    const model = provider.providerConfig.model?.trim();
+    return model ? model : undefined;
+}
+function createAgenticDiagnosisProviderRuntime(provider) {
+    const config = {
+        ...provider.providerConfig,
+        ...provider.credentials,
+    };
+    return (0, provider_ping_1.createProviderRuntimeForConfig)(provider.provider, config, {
+        model: discoveredProviderModel(provider),
+    });
+}
+async function tryAgenticDiagnosis(degraded, provider, deps) {
+    const logsTail = deps.readDaemonLogsTail();
+    const runtime = deps.createProviderRuntime(provider);
+    const systemPrompt = buildSystemPrompt(degraded);
+    const userMessage = buildUserMessage(degraded, logsTail);
+    const messages = [
+        { role: "system", content: systemPrompt },
+        { role: "user", content: userMessage },
+    ];
+    /* v8 ignore start -- no-op callbacks: satisfy interface contract, never invoked by diagnostic call @preserve */
+    const noopCallbacks = {
+        onModelStart: () => { },
+        onModelStreamStart: () => { },
+        onTextChunk: () => { },
+        onReasoningChunk: () => { },
+        onToolStart: () => { },
+        onToolEnd: () => { },
+        onError: () => { },
+    };
+    /* v8 ignore stop */
+    const result = await runtime.streamTurn({
+        messages,
+        activeTools: [],
+        callbacks: noopCallbacks,
+    });
+    if (result.content) {
+        deps.writeStdout("");
+        deps.writeStdout("--- AI Diagnosis ---");
+        deps.writeStdout(result.content);
+        deps.writeStdout("--- End Diagnosis ---");
+        deps.writeStdout("");
+    }
+    return true;
+}
+async function runAgenticRepair(degraded, deps) {
+    (0, runtime_1.emitNervesEvent)({
+        level: "info",
+        component: "daemon",
+        event: "daemon.agentic_repair_start",
+        message: "agentic repair flow started",
+        meta: { degradedCount: degraded.length },
+    });
+    if (degraded.length === 0) {
+        return { repairsAttempted: false, usedAgentic: false };
+    }
+    const hasLocalRepair = degraded.some(interactive_repair_1.hasRunnableInteractiveRepair);
+    const hasKnownTypedRepair = degraded.some((entry) => (0, readiness_repair_1.isKnownReadinessIssue)(entry.issue));
+    if (hasLocalRepair) {
+        const interactiveResult = await runDeterministicRepair(degraded, deps);
+        if (interactiveResult.repairsAttempted) {
+            return { repairsAttempted: true, usedAgentic: false };
+        }
+        if (hasKnownTypedRepair) {
+            return { repairsAttempted: false, usedAgentic: false };
+        }
+    }
+    else if (hasKnownTypedRepair) {
+        return { repairsAttempted: false, usedAgentic: false };
+    }
+    // Try to discover a working provider for agentic diagnosis
+    let discoveredProvider = null;
+    try {
+        discoveredProvider = await deps.discoverWorkingProvider(degraded[0].agent);
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "daemon",
+            event: "daemon.agentic_repair_discovery_error",
+            message: `provider discovery failed during agentic repair: ${msg}`,
+            meta: { error: msg },
+        });
+    }
+    if (!discoveredProvider) {
+        // No working provider — fall back to deterministic repair
+        (0, runtime_1.emitNervesEvent)({
+            level: "info",
+            component: "daemon",
+            event: "daemon.agentic_repair_no_provider",
+            message: "no working provider found, falling back to deterministic repair",
+            meta: {},
+        });
+        if (hasLocalRepair) {
+            return { repairsAttempted: false, usedAgentic: false };
+        }
+        const interactiveResult = await runDeterministicRepair(degraded, deps);
+        return { repairsAttempted: interactiveResult.repairsAttempted, usedAgentic: false };
+    }
+    // Offer agentic diagnosis
+    const answer = await deps.promptInput("would you like AI-assisted diagnosis? [y/n] ");
+    if (!(0, interactive_repair_1.isAffirmativeAnswer)(answer)) {
+        // User declined — fall back to deterministic repair
+        (0, runtime_1.emitNervesEvent)({
+            level: "info",
+            component: "daemon",
+            event: "daemon.agentic_repair_declined",
+            message: "user declined agentic diagnosis",
+            meta: {},
+        });
+        if (hasLocalRepair) {
+            return { repairsAttempted: false, usedAgentic: false };
+        }
+        const interactiveResult = await runDeterministicRepair(degraded, deps);
+        return { repairsAttempted: interactiveResult.repairsAttempted, usedAgentic: false };
+    }
+    // User accepted — run agentic diagnosis then fall through to deterministic repair
+    let usedAgentic = false;
+    try {
+        usedAgentic = await tryAgenticDiagnosis(degraded, discoveredProvider, deps);
+        (0, runtime_1.emitNervesEvent)({
+            level: "info",
+            component: "daemon",
+            event: "daemon.agentic_repair_diagnosis_complete",
+            message: "agentic diagnosis completed, proceeding to deterministic repair",
+            meta: { provider: discoveredProvider.provider },
+        });
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        deps.writeStdout(`AI diagnosis failed: ${msg}`);
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "daemon",
+            event: "daemon.agentic_repair_diagnosis_error",
+            message: `agentic diagnosis failed: ${msg}`,
+            meta: { error: msg, provider: discoveredProvider.provider },
+        });
+    }
+    // Always fall through to deterministic repair for actionable fixes
+    const interactiveResult = hasLocalRepair
+        ? { repairsAttempted: false }
+        : await runDeterministicRepair(degraded, deps);
+    (0, runtime_1.emitNervesEvent)({
+        level: "info",
+        component: "daemon",
+        event: "daemon.agentic_repair_end",
+        message: "agentic repair flow completed",
+        meta: { usedAgentic, repairsAttempted: interactiveResult.repairsAttempted },
+    });
+    return { repairsAttempted: interactiveResult.repairsAttempted, usedAgentic };
+}