lazyopencode-core 0.0.3 → 0.0.4

package/dist/index.js

@@ -6,11 +6,11 @@ import { getSkillsDir } from "./skills/index.js";
 import { createCancelTaskTool, createCouncilTool } from "./tools/index.js";
 import { createOpenCodeControlPlane } from "./opencode-control-plane.js";
 /**
- * @lazyopencode/core — Governed team runtime for AI coding in OpenCode.
+ * lazyopencode-core — Governed team runtime for AI coding in OpenCode.
  *
  * One plugin. Zero config. Total takeover.
  *
- * Install: { "plugin": ["@lazyopencode/core"] }
+ * Install: { "plugin": ["lazyopencode-core"] }
  */
 const LazyOpenCodePluginV1 = async (ctx) => {
     const agents = createAgents();
@@ -19,7 +19,7 @@ const LazyOpenCodePluginV1 = async (ctx) => {
         directory: ctx.directory,
         worktree: ctx.worktree,
     });
-    runtime.setControlPlane(createOpenCodeControlPlane(ctx.client));
+    runtime.setControlPlane(createOpenCodeControlPlane(ctx.client, ctx.directory));
     const hooks = createHooks(runtime);
     const councilTool = createCouncilTool(ctx.client, () => runtime.config.council, () => {
         const council = runtime.config.council;
@@ -46,7 +46,7 @@ const LazyOpenCodePluginV1 = async (ctx) => {
             const cfg = config;
             runtime.configure(cfg.lazyopencode);
             await runtime.load();
-            cfg.agent = mergeAgents(cfg.agent ?? {}, agents);
+            cfg.agent = mergeAgents(cfg.agent ?? {}, agents, runtime.config);
             cfg.skills = cfg.skills || {};
             const paths = cfg.skills.paths || [];
             const skillsDir = getSkillsDir();
@@ -54,16 +54,7 @@ const LazyOpenCodePluginV1 = async (ctx) => {
                 paths.push(skillsDir);
             }
             cfg.skills.paths = paths;
-            // deno-lint-ignore no-explicit-any
-            const mcp = cfg.mcp;
-            if (!mcp?.context7) {
-                // deno-lint-ignore no-explicit-any
-                ;
-                cfg.mcp = {
-                    ...(mcp || {}),
-                    context7: { command: ["npx", "-y", "@agentdesk/context7-mcp"] },
-                };
-            }
+            maybeInjectContext7(cfg, runtime.config);
             registerLazyCommands(cfg, runtime);
         },
         dispose: async () => {
@@ -73,12 +64,44 @@ const LazyOpenCodePluginV1 = async (ctx) => {
     };
 };
 const LazyOpenCodePlugin = LazyOpenCodePluginV1;
+export { LazyOpenCodeV2Plugin } from "./v2.js";
 export { LazyOpenCodePlugin, LazyOpenCodePluginV1 };
 export default LazyOpenCodePluginV1;
-function mergeAgents(existing, lazyAgents) {
+function mergeAgents(existing, lazyAgents, config) {
     const merged = { ...existing };
     for (const [name, defaults] of Object.entries(lazyAgents)) {
-        merged[name] = { ...defaults, ...merged[name] };
+        const profileModel = modelForAgent(name, defaults, config);
+        const lazyDefaults = profileModel ? { ...defaults, model: profileModel } : defaults;
+        merged[name] = { ...lazyDefaults, ...merged[name] };
     }
     return merged;
 }
+function modelForAgent(name, defaults, config) {
+    if (config.models.mode !== "profile")
+        return undefined;
+    if (config.models.byAgent[name])
+        return config.models.byAgent[name];
+    if (name === "lazy")
+        return config.models.primary;
+    if (name === "lazy-oracle")
+        return config.models.escalation.oracle ?? config.models.primary;
+    if (name === "lazy-councillor") {
+        return config.models.escalation.council ?? config.models.defaultSubagent;
+    }
+    if (defaults.mode === "subagent")
+        return config.models.defaultSubagent;
+    return undefined;
+}
+function maybeInjectContext7(cfg, config) {
+    if (config.opencode.context7 !== "inject")
+        return;
+    // deno-lint-ignore no-explicit-any
+    const mcp = cfg.mcp;
+    if (mcp?.context7)
+        return // deno-lint-ignore no-explicit-any
+        ;
+    cfg.mcp = {
+        ...(mcp || {}),
+        context7: { command: ["npx", "-y", "@agentdesk/context7-mcp"] },
+    };
+}

package/dist/opencode-control-plane.d.ts

@@ -1,20 +1,34 @@
+export interface ModelProfileValidation {
+    currentModel: string;
+    availableModels: string[];
+    invalidModels: string[];
+    warnings: string[];
+}
 export interface OpenCodeControlPlaneSnapshot {
     sessionStatus: string;
+    childSessions: number;
     pendingPermissions: number;
     todos: number;
     diffSummary: string;
+    changedFiles: number;
     worktree: string;
+    currentModel: string;
+    availableModels: string[];
     capabilities: string[];
+    warnings: string[];
 }
 export interface OpenCodeControlPlane {
     snapshot(sessionID?: string): Promise<OpenCodeControlPlaneSnapshot>;
+    validateModels(models: string[]): Promise<ModelProfileValidation>;
     wait(sessionID: string): Promise<{
         ok: boolean;
         reason?: string;
     }>;
-    revert(checkpointID: string): Promise<{
+    revert(sessionID: string, messageID?: string): Promise<{
         ok: boolean;
         reason?: string;
     }>;
+    log(level: "debug" | "info" | "warn" | "error", message: string, metadata?: unknown): Promise<void>;
+    notify(kind: "info" | "warn" | "error", message: string): Promise<void>;
 }
-export declare function createOpenCodeControlPlane(client: unknown): OpenCodeControlPlane;
+export declare function createOpenCodeControlPlane(client: unknown, directory?: string): OpenCodeControlPlane;

package/dist/opencode-control-plane.js

@@ -1,95 +1,268 @@
-export function createOpenCodeControlPlane(client) {
+export function createOpenCodeControlPlane(client, directory) {
     const c = (client ?? {});
     return {
         async snapshot(sessionID) {
+            const warnings = [];
             const capabilities = detectCapabilities(c);
-            const sessionStatus = await callString(c, ["sessionStatus", "status"], sessionID, "unknown");
-            const pendingPermissions = await callCount(c, ["pendingPermissions", "permissions"], sessionID);
-            const todos = await callCount(c, ["todos", "todo"], sessionID);
-            const diffSummary = await callString(c, ["diffSummary", "diff"], sessionID, "not collected");
-            const worktree = await callString(c, ["worktree", "projectWorktree"], sessionID, "unknown");
-            return { sessionStatus, pendingPermissions, todos, diffSummary, worktree, capabilities };
+            const session = asRecord(c.session);
+            const v2Session = asRecord(asRecord(c.v2)?.session);
+            const v2Permission = asRecord(v2Session?.permission);
+            const status = await callSdk(session, "status", [{ directory }], warnings);
+            const sessionInfo = sessionID
+                ? await callSdk(session, "get", [{ sessionID, directory }], warnings)
+                : undefined;
+            const children = sessionID
+                ? await callSdk(session, "children", [{ sessionID, directory }], warnings)
+                : undefined;
+            const todos = sessionID
+                ? await callSdk(session, "todo", [{ sessionID, directory }], warnings)
+                : undefined;
+            const diff = sessionID
+                ? await callSdk(session, "diff", [{ sessionID, directory }], warnings)
+                : undefined;
+            const permissions = sessionID
+                ? await callSdk(v2Permission, "list", [{ sessionID }], warnings)
+                : undefined;
+            const providers = await getProviderModels(c, directory, warnings);
+            const fileStatus = await getFileStatus(c, directory, warnings);
+            return {
+                sessionStatus: extractSessionStatus(status, sessionInfo),
+                childSessions: countItems(children),
+                pendingPermissions: countItems(permissions),
+                todos: countItems(todos),
+                diffSummary: summarizeDiff(diff),
+                changedFiles: fileStatus.changedFiles,
+                worktree: extractWorktree(sessionInfo) ?? directory ?? "unknown",
+                currentModel: providers.currentModel,
+                availableModels: providers.availableModels,
+                capabilities,
+                warnings: unique(warnings),
+            };
+        },
+        async validateModels(models) {
+            const warnings = [];
+            const providers = await getProviderModels(c, directory, warnings);
+            const available = new Set(providers.availableModels);
+            const invalidModels = models
+                .filter(Boolean)
+                .filter((model) => !isProviderModel(model) || (available.size > 0 && !available.has(model)));
+            return {
+                currentModel: providers.currentModel,
+                availableModels: providers.availableModels,
+                invalidModels,
+                warnings: unique(warnings),
+            };
         },
         async wait(sessionID) {
-            return await callOk(c, ["wait", "sessionWait"], sessionID);
+            const warnings = [];
+            const session = asRecord(c.session);
+            const v2Session = asRecord(asRecord(c.v2)?.session);
+            const value = await callSdk(v2Session, "wait", [{ sessionID }], warnings) ??
+                await callSdk(session, "wait", [{ sessionID, directory }], warnings);
+            if (value !== undefined)
+                return { ok: true };
+            return { ok: false, reason: warnings.join("; ") || "session.wait unavailable" };
+        },
+        async revert(sessionID, messageID) {
+            const warnings = [];
+            const session = asRecord(c.session);
+            const value = await callSdk(session, "revert", [{ sessionID, messageID, directory }], warnings);
+            if (value !== undefined)
+                return { ok: true };
+            return { ok: false, reason: warnings.join("; ") || "session.revert unavailable" };
+        },
+        async log(level, message, metadata) {
+            const app = asRecord(c.app);
+            const global = asRecord(c.global);
+            await callSdk(app, "log", [{ level, message, metadata }], []) ??
+                await callSdk(global, "log", [{ level, message, metadata }], []);
         },
-        async revert(checkpointID) {
-            return await callOk(c, ["revert", "revertCheckpoint"], checkpointID);
+        async notify(kind, message) {
+            const tui = asRecord(c.tui);
+            await callSdk(tui, "showToast", [{ type: kind, message }], []) ??
+                await callSdk(tui, "publish", [{ body: { type: "toast.show", variant: kind, message } }], []);
         },
     };
 }
 function detectCapabilities(client) {
-    const names = [
-        ["sessionStatus", "status"],
-        ["children"],
-        ["wait", "sessionWait"],
-        ["context"],
-        ["messages"],
-        ["diffSummary", "diff"],
-        ["todos", "todo"],
-        ["pendingPermissions", "permissions"],
-        ["worktree", "projectWorktree"],
-        ["revert", "revertCheckpoint"],
+    const session = asRecord(client.session);
+    const v2 = asRecord(client.v2);
+    const v2Session = asRecord(v2?.session);
+    const v2Permission = asRecord(v2Session?.permission);
+    const fs = asRecord(v2?.fs);
+    const groups = [
+        ["session.status", session?.status],
+        ["session.get", session?.get],
+        ["session.children", session?.children],
+        ["session.todo", session?.todo],
+        ["session.diff", session?.diff],
+        ["session.messages", session?.messages],
+        ["session.wait", session?.wait ?? v2Session?.wait],
+        ["session.revert", session?.revert],
+        ["v2.session.context", v2Session?.context],
+        ["v2.session.permission", v2Permission?.list],
+        ["config.get", asRecord(client.config)?.get],
+        ["config.providers", asRecord(client.config)?.providers],
+        ["provider.list", asRecord(client.provider)?.list],
+        ["file.status", asRecord(client.file)?.status],
+        ["find.files", asRecord(client.find)?.files ?? fs?.find],
+        ["app.log", asRecord(client.app)?.log ?? asRecord(client.global)?.log],
+        ["tui.showToast", asRecord(client.tui)?.showToast],
     ];
-    return names
-        .filter((group) => group.some((name) => typeof client[name] === "function"))
-        .map((group) => group[0]);
+    return groups.filter(([, fn]) => typeof fn === "function").map(([name]) => name);
 }
-async function callString(client, names, arg, fallback) {
+async function getProviderModels(client, directory, warnings) {
+    const config = asRecord(client.config);
+    const provider = asRecord(client.provider);
+    const configData = await callSdk(config, "get", [{ directory }], warnings);
+    const providerData = await callSdk(config, "providers", [{ directory }], warnings) ??
+        await callSdk(provider, "list", [{ directory }], warnings);
+    return {
+        currentModel: extractCurrentModel(configData),
+        availableModels: extractAvailableModels(providerData),
+    };
+}
+async function getFileStatus(client, directory, warnings) {
+    const value = await callSdk(asRecord(client.file), "status", [{ directory }], warnings) ??
+        await callSdk(asRecord(client.vcs), "status", [{ directory }], warnings);
+    return { changedFiles: countItems(value) };
+}
+async function callSdk(target, name, args, warnings) {
+    const fn = target?.[name];
+    if (typeof fn !== "function")
+        return undefined;
     try {
-        const value = await callFirst(client, names, arg);
-        if (value === undefined || value === null)
-            return fallback;
-        if (typeof value === "string")
-            return value;
-        if (typeof value === "object") {
-            const record = value;
-            return String(record.summary ?? record.status ?? record.path ?? fallback);
+        const result = await fn(...args);
+        const unwrapped = unwrapResult(result);
+        if (isErrorResult(result)) {
+            warnings.push(`${name}: ${stringify(result.error)}`);
         }
-        return String(value);
+        return unwrapped;
     }
-    catch {
-        return fallback;
+    catch (error) {
+        warnings.push(`${name}: ${error instanceof Error ? error.message : String(error)}`);
+        return undefined;
     }
 }
-async function callCount(client, names, arg) {
-    try {
-        const value = await callFirst(client, names, arg);
-        if (Array.isArray(value))
-            return value.length;
-        if (typeof value === "number")
-            return value;
-        if (value && typeof value === "object") {
-            const record = value;
-            if (typeof record.count === "number")
-                return record.count;
-            if (Array.isArray(record.items))
-                return record.items.length;
-        }
+function unwrapResult(value) {
+    if (value && typeof value === "object" && ("data" in value || "error" in value)) {
+        return value.data;
     }
-    catch {
+    return value;
+}
+function isErrorResult(value) {
+    return Boolean(value && typeof value === "object" && "error" in value && value.error);
+}
+function asRecord(value) {
+    return value && typeof value === "object" ? value : undefined;
+}
+function countItems(value) {
+    const data = unwrapResult(value);
+    if (Array.isArray(data))
+        return data.length;
+    if (typeof data === "number")
+        return data;
+    const record = asRecord(data);
+    if (!record)
         return 0;
+    for (const key of ["count", "total"]) {
+        if (typeof record[key] === "number")
+            return record[key];
+    }
+    for (const key of ["items", "data", "children", "todos", "permissions", "requests", "files"]) {
+        if (Array.isArray(record[key]))
+            return record[key].length;
     }
-    return 0;
+    return Object.keys(record).length;
 }
-async function callOk(client, names, arg) {
-    try {
-        const value = await callFirst(client, names, arg);
-        if (value && typeof value === "object" && "ok" in value) {
-            return value;
+function extractSessionStatus(status, sessionInfo) {
+    const session = asRecord(sessionInfo);
+    const statusRecord = asRecord(status);
+    return String(session?.status ??
+        session?.state ??
+        statusRecord?.status ??
+        statusRecord?.state ??
+        (statusRecord && Object.keys(statusRecord).length > 0 ? "available" : "unknown"));
+}
+function summarizeDiff(value) {
+    const data = unwrapResult(value);
+    if (!data)
+        return "not collected";
+    if (typeof data === "string")
+        return data || "empty";
+    const record = asRecord(data);
+    if (!record)
+        return String(data);
+    const summary = record.summary ?? record.text ?? record.diff;
+    if (typeof summary === "string" && summary.trim())
+        return summary;
+    const changed = countItems(record);
+    return changed > 0 ? `${changed} changed file(s)` : "empty";
+}
+function extractWorktree(value) {
+    const record = asRecord(value);
+    return String(record?.worktree ?? record?.directory ?? record?.path ?? record?.location ?? "") ||
+        undefined;
+}
+function extractCurrentModel(value) {
+    const data = asRecord(unwrapResult(value));
+    const raw = data?.model ?? data?.default_model ?? data?.small_model;
+    if (typeof raw === "string")
+        return raw;
+    const model = asRecord(raw);
+    if (model)
+        return joinModel(model.providerID, model.modelID ?? model.id);
+    return "OpenCode selected model";
+}
+function extractAvailableModels(value) {
+    const data = unwrapResult(value);
+    const providers = Array.isArray(data)
+        ? data
+        : asRecord(data)?.providers ?? asRecord(data)?.items ?? asRecord(data)?.data;
+    if (!Array.isArray(providers))
+        return [];
+    const models = [];
+    for (const provider of providers) {
+        const p = asRecord(provider);
+        const providerID = String(p?.id ?? p?.providerID ?? p?.name ?? "");
+        const modelList = p?.models;
+        if (Array.isArray(modelList)) {
+            for (const model of modelList) {
+                const m = asRecord(model);
+                const modelID = String(m?.id ?? m?.modelID ?? m?.name ?? "");
+                const joined = joinModel(providerID, modelID);
+                if (joined)
+                    models.push(joined);
+            }
+        }
+        else if (modelList && typeof modelList === "object") {
+            for (const modelID of Object.keys(modelList)) {
+                const joined = joinModel(providerID, modelID);
+                if (joined)
+                    models.push(joined);
+            }
         }
-        return { ok: true };
-    }
-    catch (error) {
-        return { ok: false, reason: error instanceof Error ? error.message : String(error) };
     }
+    return unique(models);
 }
-async function callFirst(client, names, arg) {
-    for (const name of names) {
-        const fn = client[name];
-        if (typeof fn === "function") {
-            return await fn(arg);
-        }
+function joinModel(providerID, modelID) {
+    const provider = String(providerID ?? "");
+    const model = String(modelID ?? "");
+    return provider && model ? `${provider}/${model}` : "";
+}
+function isProviderModel(value) {
+    return /^[^/\s]+\/[^/\s]+$/.test(value);
+}
+function stringify(value) {
+    if (typeof value === "string")
+        return value;
+    try {
+        return JSON.stringify(value);
     }
-    return undefined;
+    catch {
+        return String(value);
+    }
+}
+function unique(items) {
+    return Array.from(new Set(items.filter(Boolean)));
 }

package/dist/skills/lazy/debug/SKILL.md

@@ -6,7 +6,7 @@ description: Systematic diagnosis loop for bugs where the cause is unclear.
 ## Process
 
 1. **Reproduce.** Can you reliably trigger it? Gather exact steps/logs. If unreproducible, document environment/conditions.
-2. **Isolate.** Narrow scope: what changed (git log/bisect)? Smallest triggering input? Boundary? If bug involves a library API, check current docs via context7.
+2. **Isolate.** Narrow scope: what changed (git log/bisect)? Smallest triggering input? Boundary? If bug involves a library API, check current docs via configured documentation tools.
 3. **Hypothesize.** Form exactly one hypothesis. State it clearly.
 4. **Test hypothesis.** Smallest test/log that proves/disproves it. Do NOT fix yet.
 5. **Iterate.** Disproven → new hypothesis. Proven → go to 6. Stuck after 3 cycles → escalate to @lazy-oracle.

package/dist/v2.js

@@ -2,7 +2,7 @@ import { define } from "@opencode-ai/plugin/v2/promise";
 import { createAgents } from "./agents/index.js";
 import { getSkillsDir } from "./skills/index.js";
 export const LazyOpenCodeV2Plugin = define({
-    id: "@lazyopencode/core",
+    id: "lazyopencode-core",
     setup(context) {
         const ctx = context;
         ctx.agent?.transform((draft) => {

package/docs/desktop-distribution.md

@@ -9,7 +9,7 @@ LazyOpenCode Desktop ships the governed defaults and health surface.
 ## Strategy
 
 The plugin remains the source of truth. Desktop bundles and enables
-`@lazyopencode/core`; it does not duplicate LazyOpenCode governance logic.
+`lazyopencode-core`; it does not duplicate LazyOpenCode governance logic.
 
 ## First-Run Defaults
 
@@ -17,7 +17,7 @@ Desktop should merge the defaults from
 `apps/lazyopencode-desktop/lazyopencode.default.jsonc` into the user's generated
 OpenCode config:
 
-- Add `@lazyopencode/core` to `plugin` if absent.
+- Add `lazyopencode-core` to `plugin` if absent.
 - Add `lazyopencode` defaults only where the user has not set values.
 - Preserve provider, auth, model, MCP, session, and project settings.
 

package/docs/opencode-integration.md

@@ -3,12 +3,11 @@
 LazyOpenCode is an OpenCode-native workflow governor. The plugin should work
 with no `lazyopencode` config block; configuration only customizes defaults.
 
-OpenCode loads `dist/index.js` from the npm package. The default export uses the
-v2 promise registration surface for agents, commands, skills, and references.
-The named `LazyOpenCodePluginV1` export remains available for legacy hook
-registration and existing tests. The legacy adapter stays enabled by default
-because current governance still depends on chat, message, command, permission,
-and tool hooks.
+OpenCode loads `dist/index.js` from the npm package. The default export remains
+the legacy hook adapter because current governance depends on chat, message,
+command, permission, and tool hooks. The named `LazyOpenCodeV2Plugin` export
+keeps the v2 promise registration surface available for agents, commands,
+skills, and references while v2 hook coverage matures.
 
 ## Hook Boundaries
 
@@ -22,6 +21,22 @@ and tool hooks.
 - chat transforms: inject workflow guidance, job-board status, token-control
   pruning, image redirects, and Ponytail behavior.
 
+## SDK Control Plane
+
+`0.0.4` uses the OpenCode SDK as a best-effort control plane for status, doctor,
+and close reports. The adapter prefers real SDK groups such as `session`,
+`config`, `file`, `find`, `app`, `tui`, and v2 session permission/fs APIs.
+
+Collected evidence includes:
+
+- session status, child sessions, todos, messages, diffs, wait, and revert
+- pending session permissions from v2 permission APIs when available
+- configured providers and models for model profile validation
+- file status / changed file counts
+- app logging and TUI notifications when available
+
+Missing SDK APIs degrade to warnings. They should never block normal governance.
+
 ## Zero Config
 
 Outside Desktop, users still install/load the plugin through OpenCode's normal
@@ -36,6 +51,9 @@ plugin mechanism. Once loaded, LazyOpenCode defaults are complete:
 - `sdk.legacyHookAdapter: true`
 - `takeover: "governed"`
 - `opencode.worktreeIsolation: "risky-only"`
+- `opencode.sdkControlPlane: true`
+- `opencode.sdkTelemetry: true`
+- `opencode.tuiNotifications: true`
 - `closeReport.autoCollect: true`
 
 ## Config Merge Contract

package/docs/positioning.md

@@ -39,6 +39,6 @@ Autonomous coding assistants optimize for longer independent runs, memory, and
 self-improvement loops. LazyOpenCode emphasizes governed OpenCode operation:
 small scope, explicit risk gates, budget visibility, and boring closure.
 
-Desktop is a later `0.1.0` task. The current `0.0.1` target is to make
-`@lazyopencode/core` a complete plugin kernel that a Desktop fork can preinstall
+Desktop is a later `0.1.0` task. The current `0.0.x` target is to make
+`lazyopencode-core` a complete plugin kernel that a Desktop fork can preinstall
 safely.

package/docs/product-audit.md

@@ -11,7 +11,7 @@ prompt toolbox. The product combines three things:
 - A governance layer for scope, risk, budget, permissions, and closure.
 - A future Desktop distribution that makes those defaults visible and easy.
 
-The current `0.0.1` core is close to a usable kernel: commands, agents, skills,
+The current `0.0.x` core is close to a usable kernel: commands, agents, skills,
 runtime state, job board, council guard, token control, doctor output, and close
 report all exist and pass verification. The next work is mostly deepening,
 simplifying, and making the boundaries sharper.
@@ -73,7 +73,7 @@ Small scope, visible work, bounded context, reviewed output.
 - Worktree isolation is advice/policy, not full automation.
 - Doctor output checks the important basics, but should become a deeper module
   with structured checks.
-- Desktop is intentionally not implemented in `0.0.1`.
+- Desktop is intentionally not implemented in `0.0.x`.
 
 ## Project Design
 
@@ -171,12 +171,12 @@ but adds governance and closure.
 Compared with autonomous coding assistants, LazyOpenCode stays OpenCode-native
 and prioritizes controlled engineering workflow over long independent runs.
 
-Compared with future Desktop distributions, `@lazyopencode/core` is the source
+Compared with future Desktop distributions, `lazyopencode-core` is the source
 of truth. Desktop should package and visualize core behavior, not duplicate it.
 
 ## Release Readiness
 
-`0.0.1` is releaseable once these stay true:
+`0.0.4` is releaseable once these stay true:
 
 - `npm run verify` passes.
 - README and docs use governed team runtime positioning.