@pfoundation/ocadvisor 26.9.0

package/dist/ocAdvisor.js

@@ -0,0 +1,1127 @@
+import { Database } from "bun:sqlite";
+import { appendFile } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+const DB_PATH = join(homedir(), ".local/share/opencode/opencode.db");
+const METRICS_PATH = join(homedir(), ".local/share/opencode/ocAdvisor-metrics.jsonl");
+const ADVISOR_PROVIDER = "anthropic";
+const ADVISOR_MODEL = "claude-fable-5-1";
+const ADVISOR_VARIANT = "max";
+const ADVISOR_SESSION_TITLE = "advisor";
+// Sessions created before the ocAdvisor → advisor rename keep working: title
+// discovery accepts both, and the storage key below is unchanged.
+const LEGACY_ADVISOR_SESSION_TITLE = "ocAdvisor";
+const ADVISOR_STORAGE_KEY = "advisorSessionID";
+const ADVISOR_TIMEOUT_MS = 300_000;
+const FABLE_DISABLED = "advisor is disabled for anthropic/claude-fable-* sessions — the current model is already Fable.";
+const DEFAULT_ADVISOR_CONFIG = {
+    provider: ADVISOR_PROVIDER,
+    model: ADVISOR_MODEL,
+    variant: ADVISOR_VARIANT,
+    timeoutMs: ADVISOR_TIMEOUT_MS,
+    maxTranscriptChars: 0,
+};
+function normalizeVariant(value) {
+    if (value === null || value === undefined)
+        return undefined;
+    const text = String(value).trim();
+    if (!text || text.toLowerCase() === "none")
+        return undefined;
+    return text;
+}
+function toBoundedInt(value, min) {
+    const raw = typeof value === "number"
+        ? value
+        : typeof value === "string" && value.trim()
+            ? Number(value)
+            : NaN;
+    return Number.isFinite(raw) && raw >= min ? Math.floor(raw) : undefined;
+}
+// Splits a "provider/model#variant" reference. All three parts are optional;
+// a bare "claude-opus-5" (no slash) is treated as a model id.
+function parseModelRef(ref) {
+    const out = {};
+    let rest = ref.trim();
+    if (!rest)
+        return out;
+    const hash = rest.indexOf("#");
+    if (hash >= 0) {
+        const variant = rest.slice(hash + 1).trim();
+        if (variant)
+            out.variant = variant;
+        rest = rest.slice(0, hash).trim();
+    }
+    const slash = rest.indexOf("/");
+    if (slash >= 0) {
+        const provider = rest.slice(0, slash).trim();
+        const model = rest.slice(slash + 1).trim();
+        if (provider)
+            out.provider = provider;
+        if (model)
+            out.model = model;
+    }
+    else if (rest) {
+        out.model = rest;
+    }
+    return out;
+}
+function applyAdvisorConfigSource(base, src) {
+    if (!src || typeof src !== "object")
+        return base;
+    const next = { ...base };
+    if (typeof src.model === "string" && src.model.trim()) {
+        const parsed = parseModelRef(src.model);
+        if (parsed.provider)
+            next.provider = parsed.provider;
+        if (parsed.model)
+            next.model = parsed.model;
+        if (parsed.variant !== undefined) {
+            next.variant = normalizeVariant(parsed.variant);
+        }
+    }
+    if (typeof src.provider === "string" && src.provider.trim()) {
+        next.provider = src.provider.trim();
+    }
+    // An explicit `variant` (including null / "none") overrides the pin.
+    if (src.variant !== undefined) {
+        next.variant = normalizeVariant(src.variant);
+    }
+    const timeout = toBoundedInt(src.timeoutMs ?? src.timeout_ms, 1);
+    if (timeout !== undefined)
+        next.timeoutMs = timeout;
+    const cap = toBoundedInt(src.maxTranscriptChars ?? src.max_transcript_chars, 0);
+    if (cap !== undefined)
+        next.maxTranscriptChars = cap;
+    return next;
+}
+function envAdvisorConfigSource(env = process.env) {
+    return {
+        model: env.OCADVISOR_MODEL,
+        provider: env.OCADVISOR_PROVIDER,
+        variant: env.OCADVISOR_VARIANT,
+        timeoutMs: env.OCADVISOR_TIMEOUT_MS,
+        maxTranscriptChars: env.OCADVISOR_MAX_TRANSCRIPT_CHARS,
+    };
+}
+// Precedence (low to high): built-in defaults, environment variables,
+// plugin options from opencode.json.
+function resolveAdvisorConfig(options, env = process.env) {
+    let config = applyAdvisorConfigSource(DEFAULT_ADVISOR_CONFIG, envAdvisorConfigSource(env));
+    config = applyAdvisorConfigSource(config, options);
+    return config;
+}
+const SYSTEM_BASE = `You are a senior advisor reviewing a coding agent's work. You have the full session transcript.
+Respond in 500-750 words with structured analysis and enumerated steps. Be direct and actionable.`;
+const SYSTEM_PROMPTS = {
+    general: `${SYSTEM_BASE}
+You are a senior software engineer. Analyze the conversation, identify issues, misunderstandings, or missed opportunities. Suggest corrections and improvements. If the agent is on the right track, confirm and suggest optimizations.`,
+    review: `${SYSTEM_BASE}
+You are a code reviewer. Focus on correctness, edge cases, security vulnerabilities, performance issues, and adherence to best practices. Evaluate the code changes in context of the broader codebase patterns visible in the transcript.`,
+    plan: `${SYSTEM_BASE}
+You are a software architect. Evaluate the current approach and plan. Identify risks, suggest alternatives, flag missing considerations. Assess whether the scope is appropriate and dependencies are accounted for.`,
+    debug: `${SYSTEM_BASE}
+You are a debugger. Analyze error patterns, stack traces, and failed attempts in the transcript. Identify root causes, explain why previous fixes didn't work, and propose targeted solutions.`,
+};
+const TOOL_DESCRIPTION = `Consult a senior advisor model with your full session transcript — including parent sessions for subagents — for high-quality analysis.
+
+Use advisor selectively on substantial, non-trivial work. Straightforward tasks normally need no consultation.
+
+- Normally make AT MOST ONE consultation per task, at the point where a second opinion has the most value: a consequential unresolved design decision (mode "plan"), a blocker after two substantially different attempts (mode "debug"), or a high-risk change with a specific unresolved correctness concern (mode "review"). Pick one stage, not all three.
+- mode "general": a second opinion that does not fit the above.
+
+Rules:
+- Always pass a concrete "question" naming the decision or artifact under review.
+- A second consultation requires material new evidence, a distinct unresolved issue, or an explicit user request. Reconcile an advisor conflict with primary-source evidence via one "followup" call stating both sides.
+- Give the advice serious weight. A passing self-test alone is not counter-evidence; primary-source evidence (the file says X) is. Clear factual corrections do not need another confirmation call.
+
+Args: "mode" (general, review, plan, debug), "trigger" (before_approach, stuck, pre_complete, followup, other), "question" (concrete question focusing the advisor).
+`;
+const CHECKPOINT_INSTRUCTION = `[advisor] Use advisor selectively on substantial work: normally 0-1 consultations per task, at most one unless material new evidence, a distinct unresolved issue, or an explicit user request. Consult for a consequential undecided design (mode "plan"), a blocker after 2+ different attempts (mode "debug"), or a high-risk change with a specific correctness concern (mode "review"). Always pass a concrete question.`;
+const ADVISOR_TRIGGERS = [
+    "before_approach",
+    "stuck",
+    "pre_complete",
+    "followup",
+    "other",
+];
+const ADVISOR_INPUT_SCHEMA = {
+    type: "object",
+    properties: {
+        mode: {
+            type: "string",
+            enum: ["general", "review", "plan", "debug"],
+            description: "Advisory mode: general, review, plan, or debug",
+        },
+        trigger: {
+            type: "string",
+            enum: ["before_approach", "stuck", "pre_complete", "followup", "other"],
+            description: "Why you are consulting now: before_approach, stuck, pre_complete, followup, or other",
+        },
+        question: {
+            type: "string",
+            description: "Concrete question naming the decision or artifact under review",
+        },
+    },
+};
+function openDb() {
+    return new Database(DB_PATH, { readonly: true });
+}
+function tableExists(db, name) {
+    const row = db
+        .query("SELECT 1 AS ok FROM sqlite_master WHERE type = 'table' AND name = ?")
+        .get(name);
+    return Boolean(row);
+}
+function parseModelJson(raw) {
+    if (!raw)
+        return null;
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === "object")
+            return parsed;
+    }
+    catch { }
+    return null;
+}
+function isFableModel(model) {
+    if (!model)
+        return false;
+    const provider = String(model.providerID || model.provider || "").toLowerCase();
+    const id = String(model.id || model.modelID || "").toLowerCase();
+    return provider.includes("anthropic") && id.includes("fable");
+}
+function inferTrigger(mode, trigger) {
+    if (trigger && ADVISOR_TRIGGERS.includes(trigger)) {
+        return trigger;
+    }
+    switch ((mode || "general").toLowerCase()) {
+        case "plan":
+            return "before_approach";
+        case "debug":
+            return "stuck";
+        case "review":
+            return "pre_complete";
+        default:
+            return "other";
+    }
+}
+function classifyAdvisorError(message) {
+    const text = message.toLowerCase();
+    if (text.includes("credit balance is too low") ||
+        text.includes("insufficient")) {
+        return "insufficient_credit";
+    }
+    if (text.includes("rate_limit") || text.includes(" 429")) {
+        return "rate_limit";
+    }
+    if (text.includes("failed to parse json") ||
+        text.includes("unexpected token")) {
+        return "json_parse";
+    }
+    if (text.includes("aborted") || text.includes("abort")) {
+        return "aborted";
+    }
+    if (text.includes("timeout") || text.includes("timed out")) {
+        return "timeout";
+    }
+    if (text.includes(" 401") ||
+        text.includes("unauthorized") ||
+        text.includes("invalid x-api-key") ||
+        text.includes("authentication") ||
+        text.includes("no anthropic connection") ||
+        text.includes("connection configured") ||
+        text.includes("not connected") ||
+        text.includes("needs authentication") ||
+        text.includes("missing credential")) {
+        return "auth";
+    }
+    if (text.includes("model unavailable") ||
+        text.includes("model not found") ||
+        (text.includes("model") &&
+            (text.includes("not enabled") || text.includes("disabled")))) {
+        return "model_unavailable";
+    }
+    if (text.includes("provider") &&
+        (text.includes("unavailable") ||
+            text.includes("disabled") ||
+            text.includes("not found") ||
+            text.includes("service unavailable"))) {
+        return "provider_unavailable";
+    }
+    if (text.includes("no transcript"))
+        return "no_transcript";
+    if (text.includes("no session"))
+        return "no_session";
+    return "api_error";
+}
+function callerLabel(model) {
+    if (!model)
+        return null;
+    const provider = model.providerID || model.provider || "unknown";
+    const id = model.id || model.modelID || "unknown";
+    return `${provider}/${id}`;
+}
+function getSessionInfo(db, sessionId) {
+    for (const table of ["session_v2", "session"]) {
+        if (!tableExists(db, table))
+            continue;
+        try {
+            const row = db
+                .query(`SELECT model, agent, directory, parent_id FROM ${table} WHERE id = ?`)
+                .get(sessionId);
+            if (row) {
+                return {
+                    model: parseModelJson(row.model),
+                    agent: row.agent ?? null,
+                    directory: row.directory ?? null,
+                    parentId: row.parent_id ?? null,
+                };
+            }
+        }
+        catch { }
+    }
+    return null;
+}
+function collectSessionChain(db, sessionId) {
+    const chain = [];
+    const visited = new Set();
+    let current = sessionId;
+    while (current && !visited.has(current) && chain.length < 10) {
+        visited.add(current);
+        chain.push(current);
+        current = getSessionInfo(db, current)?.parentId ?? null;
+    }
+    return chain;
+}
+function isTerminalToolStatus(status) {
+    return status === "completed" || status === "error";
+}
+// Matches the current "advisor" tool name and the pre-rename "ocAdvisor"
+// name so history counting and the context hook keep working across the
+// rename. Normalization mirrors the hook: lowercase, letters only.
+function isAdvisorToolName(name) {
+    if (typeof name !== "string")
+        return false;
+    const normalized = name.toLowerCase().replace(/[^a-z]/g, "");
+    return normalized === "advisor" || normalized === "ocadvisor";
+}
+function countPriorAdvisorCalls(db, sessionId) {
+    const callIds = new Set();
+    const modes = [];
+    try {
+        for (const sid of collectSessionChain(db, sessionId)) {
+            if (tableExists(db, "session_message")) {
+                const rows = db
+                    .query("SELECT id, data FROM session_message WHERE session_id = ? AND type = 'assistant'")
+                    .all(sid);
+                for (const row of rows) {
+                    let data;
+                    try {
+                        data = JSON.parse(row.data);
+                    }
+                    catch {
+                        continue;
+                    }
+                    for (const block of data.content || []) {
+                        if (!block || typeof block !== "object")
+                            continue;
+                        if (block.type !== "tool")
+                            continue;
+                        const name = String(block.name || block.tool || "");
+                        const state = block.state || {};
+                        if (!isTerminalToolStatus(state.status))
+                            continue;
+                        const nested = state.metadata?.toolCalls || [];
+                        if (isAdvisorToolName(name)) {
+                            const cid = String(block.id || block.callID || row.id);
+                            if (!callIds.has(cid)) {
+                                callIds.add(cid);
+                                modes.push(String(state.input?.mode || "general"));
+                            }
+                        }
+                        nested.forEach((call, index) => {
+                            if (isAdvisorToolName(call.tool || call.name)) {
+                                const cid = `${block.id || row.id}#${index}`;
+                                if (!callIds.has(cid)) {
+                                    callIds.add(cid);
+                                    modes.push(String(call.input?.mode || "general"));
+                                }
+                            }
+                        });
+                    }
+                }
+            }
+            if (tableExists(db, "part")) {
+                const rows = db
+                    .query("SELECT data FROM part WHERE session_id = ? AND json_extract(data, '$.type') = 'tool'")
+                    .all(sid);
+                for (const row of rows) {
+                    let block;
+                    try {
+                        block = JSON.parse(row.data);
+                    }
+                    catch {
+                        continue;
+                    }
+                    const name = String(block.tool || block.name || "");
+                    if (!isAdvisorToolName(name))
+                        continue;
+                    if (!isTerminalToolStatus(block.state?.status))
+                        continue;
+                    const cid = String(block.callID || block.id || "");
+                    if (!cid || callIds.has(cid))
+                        continue;
+                    callIds.add(cid);
+                    modes.push(String(block.state?.input?.mode || "general"));
+                }
+            }
+        }
+    }
+    catch { }
+    return { count: callIds.size, modes };
+}
+async function logAdvisorMetrics(metrics) {
+    try {
+        await appendFile(METRICS_PATH, JSON.stringify(metrics) + "\n", "utf-8");
+    }
+    catch {
+        // Metrics must never break the advisor call.
+    }
+}
+function getSession(db, sessionId) {
+    return db
+        .query("SELECT id, parent_id, title, directory FROM session WHERE id = ?")
+        .get(sessionId);
+}
+function getSessionV2(db, sessionId) {
+    return db
+        .query("SELECT id, parent_id, title, directory FROM session_v2 WHERE id = ?")
+        .get(sessionId);
+}
+function getMessages(db, sessionId) {
+    return db
+        .query("SELECT id, data, time_created FROM message WHERE session_id = ? ORDER BY time_created ASC")
+        .all(sessionId);
+}
+function getParts(db, messageId) {
+    return db
+        .query("SELECT data, time_created FROM part WHERE message_id = ? ORDER BY time_created ASC")
+        .all(messageId);
+}
+function getSessionMessages(db, sessionId) {
+    return db
+        .query("SELECT type, data FROM session_message WHERE session_id = ? ORDER BY seq ASC")
+        .all(sessionId);
+}
+function truncate(value, max) {
+    return value.length > max ? value.slice(0, max) + "\n... (truncated)" : value;
+}
+function stringifyUnknown(value) {
+    return typeof value === "string" ? value : JSON.stringify(value, null, 2);
+}
+function formatPartContent(part) {
+    switch (part.type) {
+        case "text":
+            return part.text || null;
+        case "tool": {
+            const name = part.tool || part.name || "unknown";
+            const status = part.state?.status || "unknown";
+            const lines = [`[Tool: ${name}] (${status})`];
+            if (part.state?.input) {
+                lines.push(`Input: ${truncate(stringifyUnknown(part.state.input), 2000)}`);
+            }
+            const output = part.state?.output ?? part.state?.content;
+            if (output) {
+                lines.push(`Output: ${truncate(stringifyUnknown(output), 3000)}`);
+            }
+            if (part.state?.error)
+                lines.push(`Error: ${part.state.error}`);
+            return lines.join("\n");
+        }
+        case "compaction":
+            return `[Context compaction occurred${part.auto ? " (auto)" : " (manual)"}]`;
+        default:
+            return null;
+    }
+}
+function formatV2Content(block) {
+    switch (block.type) {
+        case "text":
+            return block.text || null;
+        case "reasoning":
+            return null;
+        case "tool":
+            return formatPartContent({
+                type: "tool",
+                tool: block.name || block.tool,
+                state: block.state,
+            });
+        default:
+            return typeof block.text === "string" && block.text ? block.text : null;
+    }
+}
+function formatV2Message(type, data) {
+    if (type === "user") {
+        const text = typeof data.text === "string" ? data.text : "";
+        return text ? `## User\n${text}` : null;
+    }
+    if (type === "assistant") {
+        const agent = data.agent ? ` (agent: ${data.agent})` : "";
+        const modelId = data.model?.id || data.model?.modelID;
+        const model = modelId ? ` [${modelId}]` : "";
+        const parts = [];
+        for (const block of data.content || []) {
+            if (!block || typeof block !== "object")
+                continue;
+            const content = formatV2Content(block);
+            if (content)
+                parts.push(content);
+        }
+        if (parts.length === 0)
+            return null;
+        return `## Assistant${agent}${model}\n${parts.join("\n\n")}`;
+    }
+    if (type === "compaction") {
+        const auto = data.reason === "auto" || data.auto;
+        const summary = typeof data.summary === "string" && data.summary
+            ? `\n${truncate(data.summary, 2000)}`
+            : "";
+        return `[Context compaction occurred${auto ? " (auto)" : " (manual)"}]${summary}`;
+    }
+    if (type === "synthetic" && typeof data.text === "string" && data.text) {
+        return `## Synthetic\n${truncate(data.text, 3000)}`;
+    }
+    if (type === "system" && typeof data.text === "string" && data.text) {
+        return `## System\n${truncate(data.text, 2000)}`;
+    }
+    return null;
+}
+function buildTranscriptV1(db, sessionId, visited = new Set()) {
+    if (visited.has(sessionId))
+        return "";
+    visited.add(sessionId);
+    const session = getSession(db, sessionId);
+    if (!session)
+        return "";
+    const sections = [];
+    if (session.parent_id && !visited.has(session.parent_id)) {
+        const parentTranscript = buildTranscriptV1(db, session.parent_id, visited);
+        if (parentTranscript) {
+            sections.push(`═══ Parent Session: ${getSession(db, session.parent_id)?.title || session.parent_id} ═══\n`, parentTranscript, `\n═══ Current Subagent Session: ${session.title} ═══\n`);
+        }
+    }
+    const messages = getMessages(db, sessionId);
+    for (const msg of messages) {
+        let msgData;
+        try {
+            msgData = JSON.parse(msg.data);
+        }
+        catch {
+            continue;
+        }
+        const role = msgData.role === "assistant" ? "Assistant" : "User";
+        const agent = msgData.agent ? ` (agent: ${msgData.agent})` : "";
+        const model = msgData.model?.modelID ? ` [${msgData.model.modelID}]` : "";
+        const parts = getParts(db, msg.id);
+        const partTexts = [];
+        for (const part of parts) {
+            let partData;
+            try {
+                partData = JSON.parse(part.data);
+            }
+            catch {
+                continue;
+            }
+            const content = formatPartContent(partData);
+            if (content)
+                partTexts.push(content);
+        }
+        if (partTexts.length > 0) {
+            sections.push(`## ${role}${agent}${model}\n${partTexts.join("\n\n")}`);
+        }
+    }
+    return sections.join("\n\n");
+}
+function buildTranscriptV2(db, sessionId, visited = new Set()) {
+    if (visited.has(sessionId))
+        return "";
+    visited.add(sessionId);
+    const session = getSessionV2(db, sessionId);
+    if (!session)
+        return "";
+    const sections = [];
+    if (session.parent_id && !visited.has(session.parent_id)) {
+        const parentTranscript = buildTranscriptV2(db, session.parent_id, visited);
+        if (parentTranscript) {
+            sections.push(`═══ Parent Session: ${getSessionV2(db, session.parent_id)?.title || session.parent_id} ═══\n`, parentTranscript, `\n═══ Current Subagent Session: ${session.title} ═══\n`);
+        }
+    }
+    for (const msg of getSessionMessages(db, sessionId)) {
+        let data;
+        try {
+            data = JSON.parse(msg.data);
+        }
+        catch {
+            continue;
+        }
+        const formatted = formatV2Message(msg.type, data);
+        if (formatted)
+            sections.push(formatted);
+    }
+    return sections.join("\n\n");
+}
+function buildTranscript(db, sessionId) {
+    if (tableExists(db, "session_message")) {
+        const row = db
+            .query("SELECT 1 AS ok FROM session_message WHERE session_id = ? LIMIT 1")
+            .get(sessionId);
+        if (row)
+            return buildTranscriptV2(db, sessionId);
+    }
+    return buildTranscriptV1(db, sessionId);
+}
+function buildAdvisorPrompt(systemPrompt, transcript, question, priorNote) {
+    const body = priorNote ? `${transcript}\n\n---\n${priorNote}` : transcript;
+    const task = question
+        ? `Specific question: ${question}`
+        : "Please analyze the above session and provide your advisory guidance.";
+    return `${systemPrompt}\n\nHere is the full session transcript:\n\n${body}\n\n---\n\n${task}`;
+}
+function unwrapData(value) {
+    if (value === null || value === undefined)
+        return null;
+    if (typeof value === "object" &&
+        "data" in value) {
+        return value.data ?? null;
+    }
+    return value;
+}
+function extractGeneratedText(value) {
+    if (typeof value === "string")
+        return value;
+    if (!value || typeof value !== "object")
+        return null;
+    const record = value;
+    if (typeof record.text === "string")
+        return record.text;
+    return extractGeneratedText(record.data);
+}
+async function withTimeout(promise, ms, label) {
+    let timer;
+    try {
+        return await Promise.race([
+            promise,
+            new Promise((_, reject) => {
+                timer = setTimeout(() => reject(new Error(`${label} timed out after ${ms} ms`)), ms);
+            }),
+        ]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
+function isProviderUsable(provider) {
+    if (!provider)
+        return false;
+    return provider.activation !== "disabled";
+}
+function findAdvisorModel(models, config = DEFAULT_ADVISOR_CONFIG) {
+    if (!Array.isArray(models))
+        return null;
+    for (const model of models) {
+        if (!model || typeof model !== "object")
+            continue;
+        if (model.providerID !== config.provider)
+            continue;
+        if (model.id !== config.model && model.modelID !== config.model)
+            continue;
+        if (model.enabled === false)
+            continue;
+        return model;
+    }
+    return null;
+}
+function resolveAdvisorVariant(model, config = DEFAULT_ADVISOR_CONFIG) {
+    if (config.variant === undefined)
+        return undefined;
+    if (!model || !Array.isArray(model.variants))
+        return config.variant;
+    const ids = model.variants.map((variant) => variant?.id);
+    return ids.includes(config.variant) ? config.variant : undefined;
+}
+function hasAdvisorConnection(connection) {
+    if (connection === null || connection === undefined)
+        return false;
+    if (typeof connection === "object" && !Array.isArray(connection)) {
+        const record = connection;
+        if (record.active === false || record.available === false)
+            return false;
+        if (record.status === "disconnected" || record.status === "expired") {
+            return false;
+        }
+    }
+    return true;
+}
+async function checkAdvisorSupport(runtime, config = DEFAULT_ADVISOR_CONFIG) {
+    if (typeof runtime.catalog?.provider?.get === "function") {
+        let provider = null;
+        try {
+            provider = unwrapData((await runtime.catalog.provider.get({
+                providerID: config.provider,
+            })));
+        }
+        catch (err) {
+            return {
+                supported: false,
+                reason: `Provider ${config.provider} unavailable in OpenCode: ${err instanceof Error ? err.message : String(err)}`,
+            };
+        }
+        if (!isProviderUsable(provider)) {
+            return {
+                supported: false,
+                reason: `Advisor provider is disabled or unavailable in OpenCode (provider: ${config.provider}).`,
+            };
+        }
+    }
+    let variant = config.variant;
+    if (typeof runtime.catalog?.model?.list === "function") {
+        let models = null;
+        try {
+            models = unwrapData((await runtime.catalog.model.list()));
+        }
+        catch (err) {
+            return {
+                supported: false,
+                reason: `Could not list OpenCode models: ${err instanceof Error ? err.message : String(err)}`,
+            };
+        }
+        const model = findAdvisorModel(models, config);
+        if (!model) {
+            return {
+                supported: false,
+                reason: `Model unavailable: ${config.provider}/${config.model}`,
+            };
+        }
+        variant = resolveAdvisorVariant(model, config);
+    }
+    if (typeof runtime.integration?.connection?.active === "function") {
+        let connection = null;
+        try {
+            connection = await runtime.integration.connection.active(config.provider);
+        }
+        catch (err) {
+            return {
+                supported: false,
+                reason: `Could not check the ${config.provider} connection in OpenCode: ${err instanceof Error ? err.message : String(err)}`,
+            };
+        }
+        if (!hasAdvisorConnection(connection)) {
+            return {
+                supported: false,
+                reason: `No ${config.provider} connection configured in OpenCode (sign in or connect an API key first).`,
+            };
+        }
+    }
+    return { supported: true, variant };
+}
+let cachedAdvisorSessionId = null;
+let advisorQueue = Promise.resolve();
+function resetAdvisorSessionCache() {
+    cachedAdvisorSessionId = null;
+}
+function enqueueAdvisor(task) {
+    const next = advisorQueue.then(task, task);
+    advisorQueue = next.catch(() => { });
+    return next;
+}
+function readSessionId(value) {
+    const session = unwrapData(value);
+    return typeof session?.id === "string" ? session.id : null;
+}
+function readSessionList(value) {
+    const list = unwrapData(value);
+    return Array.isArray(list)
+        ? list.filter((entry) => !!entry && typeof entry === "object")
+        : [];
+}
+async function readStoredAdvisorSessionId(runtime) {
+    if (typeof runtime.storage?.get !== "function")
+        return null;
+    try {
+        const stored = await runtime.storage.get(ADVISOR_STORAGE_KEY);
+        return typeof stored === "string" && stored.startsWith("ses")
+            ? stored
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function storeAdvisorSessionId(runtime, sessionId) {
+    if (typeof runtime.storage?.set !== "function")
+        return;
+    try {
+        await runtime.storage.set(ADVISOR_STORAGE_KEY, sessionId);
+    }
+    catch { }
+}
+async function getAdvisorSession(runtime, sessionId) {
+    if (typeof runtime.session?.get !== "function")
+        return null;
+    try {
+        const session = unwrapData((await runtime.session.get({ sessionID: sessionId })));
+        return session && typeof session === "object" ? session : null;
+    }
+    catch {
+        return null;
+    }
+}
+function advisorSessionNeedsModel(session, config = DEFAULT_ADVISOR_CONFIG) {
+    if (!session)
+        return true;
+    const model = session.model;
+    if (!model || typeof model !== "object")
+        return true;
+    const provider = String(model.providerID || "").toLowerCase();
+    const id = String(model.id || model.modelID || "").toLowerCase();
+    return (provider !== config.provider.toLowerCase() ||
+        id !== config.model.toLowerCase());
+}
+async function switchAdvisorSessionModel(runtime, sessionId, variant, config = DEFAULT_ADVISOR_CONFIG) {
+    if (typeof runtime.session?.switchModel !== "function") {
+        throw new Error("OpenCode runtime cannot switch the advisor session model (session.switchModel unavailable).");
+    }
+    const model = {
+        providerID: config.provider,
+        id: config.model,
+    };
+    if (variant)
+        model.variant = variant;
+    await runtime.session.switchModel({ sessionID: sessionId, model });
+}
+async function ensureAdvisorSession(runtime, variant, config = DEFAULT_ADVISOR_CONFIG) {
+    const candidates = [
+        cachedAdvisorSessionId,
+        await readStoredAdvisorSessionId(runtime),
+    ];
+    for (const candidate of candidates) {
+        if (!candidate)
+            continue;
+        const session = await getAdvisorSession(runtime, candidate);
+        if (!session)
+            continue;
+        if (advisorSessionNeedsModel(session, config)) {
+            await switchAdvisorSessionModel(runtime, candidate, variant, config);
+        }
+        cachedAdvisorSessionId = candidate;
+        return candidate;
+    }
+    if (typeof runtime.session?.list === "function") {
+        try {
+            const sessions = readSessionList(await runtime.session.list());
+            const existing = sessions.find((session) => session.title === ADVISOR_SESSION_TITLE ||
+                session.title === LEGACY_ADVISOR_SESSION_TITLE);
+            const existingId = typeof existing?.id === "string" ? existing.id : null;
+            if (existing && existingId) {
+                if (advisorSessionNeedsModel(existing, config)) {
+                    await switchAdvisorSessionModel(runtime, existingId, variant, config);
+                }
+                cachedAdvisorSessionId = existingId;
+                await storeAdvisorSessionId(runtime, existingId);
+                return existingId;
+            }
+        }
+        catch { }
+    }
+    if (typeof runtime.session?.create !== "function") {
+        throw new Error("OpenCode runtime cannot create the advisor session (session.create unavailable).");
+    }
+    const created = await runtime.session.create({
+        title: ADVISOR_SESSION_TITLE,
+    });
+    const sessionId = readSessionId(created);
+    if (!sessionId) {
+        throw new Error("OpenCode did not return an advisor session id.");
+    }
+    await switchAdvisorSessionModel(runtime, sessionId, variant, config);
+    cachedAdvisorSessionId = sessionId;
+    await storeAdvisorSessionId(runtime, sessionId);
+    return sessionId;
+}
+async function callAdvisor(opts) {
+    const runtime = opts.runtime;
+    const config = opts.config ?? DEFAULT_ADVISOR_CONFIG;
+    if (typeof runtime?.session?.generate !== "function") {
+        throw new Error("advisor requires the OpenCode V2 plugin runtime (session.generate unavailable).");
+    }
+    const support = await checkAdvisorSupport(runtime, config);
+    if (!support.supported) {
+        throw new Error(support.reason);
+    }
+    const prompt = buildAdvisorPrompt(opts.systemPrompt, opts.transcript, opts.question, opts.priorNote);
+    const generate = runtime.session.generate.bind(runtime.session);
+    // The timeout wraps only the generation, not the time spent waiting in the
+    // queue behind other advisor calls — otherwise a backlog guarantees timeouts.
+    const text = await enqueueAdvisor(() => withTimeout((async () => {
+        const sessionId = await ensureAdvisorSession(runtime, support.variant, config);
+        const request = { sessionID: sessionId, prompt };
+        const result = opts.signal
+            ? await generate(request, { signal: opts.signal })
+            : await generate(request);
+        const output = extractGeneratedText(result);
+        if (!output?.trim()) {
+            throw new Error("Advisor returned an empty response.");
+        }
+        return output;
+    })(), config.timeoutMs, "Advisor generation"));
+    const modelLabel = support.variant
+        ? `${config.provider}/${config.model} (effort=${support.variant})`
+        : `${config.provider}/${config.model}`;
+    return {
+        text: `${text}\n\n---\n_advisor via OpenCode: ${modelLabel} (token usage unavailable via session generation)_`,
+        inputTokens: null,
+        outputTokens: null,
+    };
+}
+async function runAdvisor(opts) {
+    const started = Date.now();
+    const config = opts.config ?? DEFAULT_ADVISOR_CONFIG;
+    const mode = opts.mode || "general";
+    const trigger = inferTrigger(opts.mode, opts.trigger);
+    const sessionId = opts.sessionId;
+    const questionChars = opts.question?.length ?? 0;
+    if (!sessionId) {
+        await logAdvisorMetrics({
+            ts: new Date().toISOString(),
+            sessionId: null,
+            callerModel: null,
+            callerAgent: opts.callerAgent || null,
+            directory: opts.callerDirectory || null,
+            mode,
+            trigger,
+            questionChars,
+            outcome: "no_session",
+            errorType: "no_session",
+            latencyMs: Date.now() - started,
+            inputTokens: null,
+            outputTokens: null,
+            transcriptChars: 0,
+            priorConsultations: 0,
+            via: "opencode-session",
+        });
+        throw new Error("advisor requires a valid OpenCode session context (no session ID available).");
+    }
+    let db = null;
+    try {
+        db = openDb();
+        const info = getSessionInfo(db, sessionId);
+        const callerModel = callerLabel(info?.model ?? null);
+        const callerAgent = opts.callerAgent || info?.agent || null;
+        const directory = opts.callerDirectory || info?.directory || null;
+        if (isFableModel(info?.model)) {
+            await logAdvisorMetrics({
+                ts: new Date().toISOString(),
+                sessionId,
+                callerModel,
+                callerAgent,
+                directory,
+                mode,
+                trigger,
+                questionChars,
+                outcome: "skipped_fable",
+                errorType: null,
+                latencyMs: Date.now() - started,
+                inputTokens: null,
+                outputTokens: null,
+                transcriptChars: 0,
+                priorConsultations: 0,
+                via: "opencode-session",
+            });
+            console.log(`[advisor] session=${sessionId} mode=${mode} outcome=skipped_fable (already Fable)`);
+            return FABLE_DISABLED;
+        }
+        let transcript = buildTranscript(db, sessionId);
+        if (!transcript?.trim()) {
+            await logAdvisorMetrics({
+                ts: new Date().toISOString(),
+                sessionId,
+                callerModel,
+                callerAgent,
+                directory,
+                mode,
+                trigger,
+                questionChars,
+                outcome: "no_transcript",
+                errorType: "no_transcript",
+                latencyMs: Date.now() - started,
+                inputTokens: null,
+                outputTokens: null,
+                transcriptChars: 0,
+                priorConsultations: 0,
+                via: "opencode-session",
+            });
+            throw new Error(`No transcript found for session ${sessionId}.`);
+        }
+        // Cap oversized transcripts, keeping the most recent tail. Large
+        // transcripts drive advisor latency and can blow the generation timeout.
+        if (config.maxTranscriptChars > 0 &&
+            transcript.length > config.maxTranscriptChars) {
+            transcript =
+                "... (older transcript trimmed to fit maxTranscriptChars) ...\n\n" +
+                    transcript.slice(-config.maxTranscriptChars);
+        }
+        const prior = countPriorAdvisorCalls(db, sessionId);
+        const priorNote = prior.count > 0
+            ? `Note: this session chain already has ${prior.count} recorded advisor consultation(s) (modes: ${prior.modes.join(", ") || "unknown"}). Focus on what is new since then; do not repeat settled advice unless new evidence changes it.`
+            : null;
+        const systemPrompt = SYSTEM_PROMPTS[mode] || SYSTEM_PROMPTS.general;
+        try {
+            const result = await callAdvisor({
+                runtime: opts.runtime,
+                systemPrompt,
+                transcript,
+                question: opts.question,
+                priorNote,
+                signal: opts.signal,
+                config,
+            });
+            const latencyMs = Date.now() - started;
+            await logAdvisorMetrics({
+                ts: new Date().toISOString(),
+                sessionId,
+                callerModel,
+                callerAgent,
+                directory,
+                mode,
+                trigger,
+                questionChars,
+                outcome: "advisor_response",
+                errorType: null,
+                latencyMs,
+                inputTokens: result.inputTokens,
+                outputTokens: result.outputTokens,
+                transcriptChars: transcript.length,
+                priorConsultations: prior.count,
+                via: "opencode-session",
+            });
+            console.log(`[advisor] session=${sessionId} mode=${mode} trigger=${trigger} outcome=advisor_response latencyMs=${latencyMs}`);
+            return (result.text +
+                `\n\n_advisor consultation #${prior.count + 1} in this session chain (trigger=${trigger})_`);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            const errorType = classifyAdvisorError(message);
+            const latencyMs = Date.now() - started;
+            await logAdvisorMetrics({
+                ts: new Date().toISOString(),
+                sessionId,
+                callerModel,
+                callerAgent,
+                directory,
+                mode,
+                trigger,
+                questionChars,
+                outcome: "error",
+                errorType,
+                latencyMs,
+                inputTokens: null,
+                outputTokens: null,
+                transcriptChars: transcript.length,
+                priorConsultations: prior.count,
+                via: "opencode-session",
+            });
+            console.log(`[advisor] session=${sessionId} mode=${mode} trigger=${trigger} outcome=error errorType=${errorType} latencyMs=${latencyMs}`);
+            throw new Error(`advisor failed (${errorType}): ${message}`);
+        }
+    }
+    finally {
+        db?.close();
+    }
+}
+export async function setupOcAdvisorV2(ctx) {
+    const registrations = [];
+    const advisorConfig = resolveAdvisorConfig(ctx.options);
+    if (typeof ctx.tool?.transform === "function") {
+        const reg = await ctx.tool.transform((draft) => {
+            draft.add({
+                name: "advisor",
+                description: TOOL_DESCRIPTION,
+                input: ADVISOR_INPUT_SCHEMA,
+                // Register as a direct tool, not a Code Mode tool. OpenCode 2 only
+                // exposes tools with `codemode: false` to the model directly; every
+                // other tool is reachable solely through `execute`, whose tool log
+                // records just the nested call's input and hides the script output
+                // on success — so the advisor's answer never appeared in the TUI.
+                // A direct call renders as the input fields (mode, trigger,
+                // question) followed by `output:` with the answer, and it also
+                // avoids Code Mode's output-size truncation.
+                options: { codemode: false },
+                async execute(input, context) {
+                    const text = await runAdvisor({
+                        runtime: ctx,
+                        sessionId: context.sessionID ?? context.sessionId,
+                        mode: input?.mode,
+                        trigger: input?.trigger,
+                        question: input?.question,
+                        signal: context.abort,
+                        callerAgent: context.agent,
+                        callerDirectory: context.directory,
+                        config: advisorConfig,
+                    });
+                    return { content: text };
+                },
+            });
+        });
+        if (reg)
+            registrations.push(reg);
+    }
+    if (typeof ctx.session?.hook === "function") {
+        const reg = await ctx.session.hook("context", (event) => {
+            if (!event.tools)
+                return;
+            // `event.tools` lists the direct tools available to this request.
+            // OpenCode drops entries a hook adds for tools it did not register,
+            // so the hook can only hide the tool (Fable sessions), never add it.
+            // The checkpoint instruction is injected only when the tool is
+            // actually available, e.g. not when a permission rule removed it.
+            let available = false;
+            for (const key of Object.keys(event.tools)) {
+                if (!isAdvisorToolName(key)) {
+                    continue;
+                }
+                if (isFableModel(event.model)) {
+                    delete event.tools[key];
+                }
+                else {
+                    available = true;
+                }
+            }
+            if (!available || !Array.isArray(event.system))
+                return;
+            event.system.push({ type: "text", text: CHECKPOINT_INSTRUCTION });
+        });
+        if (reg)
+            registrations.push(reg);
+    }
+    return () => {
+        for (const reg of registrations) {
+            try {
+                reg.dispose?.();
+            }
+            catch { }
+        }
+    };
+}
+const plugin = {
+    // Plugin id intentionally unchanged by the ocAdvisor → advisor rename:
+    // plugin storage (the pinned advisor session id) is scoped to it.
+    id: "oc-advisor",
+    setup: setupOcAdvisorV2,
+};
+export const OcAdvisorPluginV2 = plugin;
+export default plugin;
+// Named exports for unit tests (bun test). The plugin entrypoint is the
+// default export above.
+export { ADVISOR_TRIGGERS, CHECKPOINT_INSTRUCTION, DEFAULT_ADVISOR_CONFIG, TOOL_DESCRIPTION, buildAdvisorPrompt, checkAdvisorSupport, classifyAdvisorError, ensureAdvisorSession, extractGeneratedText, findAdvisorModel, hasAdvisorConnection, inferTrigger, isAdvisorToolName, isFableModel, isProviderUsable, parseModelRef, resolveAdvisorConfig, resolveAdvisorVariant, resetAdvisorSessionCache, unwrapData, withTimeout, };
+//# sourceMappingURL=ocAdvisor.js.map