lazyopencode-core 0.0.1

package/dist/hooks/error-recovery.js

@@ -0,0 +1,216 @@
+/**
+ * Error recovery hook (tool.execute.after).
+ * Full slim-equivalent pattern set:
+ *   1. JSON parse error recovery (8+ patterns)
+ *   2. Apply-patch failure with structured guidance
+ *   3. Task delegate retry guidance (8 error patterns)
+ *   4. Post-file-tool nudge (phase reminder for lazy primary read/write)
+ */
+// ---------------------------------------------------------------------------
+// JSON recovery patterns (match slim's 8 patterns)
+// ---------------------------------------------------------------------------
+const JSON_ERROR_PATTERNS = [
+    /SyntaxError.*JSON/i,
+    /Unexpected token.*JSON/i,
+    /Unexpected end of JSON input/i,
+    /JSON\.parse/i,
+    /Expected.*JSON/i,
+    /is not valid JSON/i,
+    /Unexpected token ['"].*in JSON/i,
+    /malformed JSON/i,
+];
+const JSON_RECOVERY_EXCLUDED_TOOLS = new Set([
+    "bash",
+    "read",
+    "glob",
+    "webfetch",
+]);
+/**
+ * Check if output contains a JSON-related error.
+ */
+function hasJsonError(output) {
+    // If the output is valid JSON, it's not a JSON parse error
+    try {
+        JSON.parse(output);
+        return false;
+    }
+    catch { /* not valid JSON, check patterns */ }
+    return JSON_ERROR_PATTERNS.some((p) => p.test(output));
+}
+/**
+ * Try to extract valid JSON from mixed output.
+ * ponytail: greedy regex. Upgrade: AST-based extraction for large outputs.
+ */
+function tryFixJsonOutput(output) {
+    const match = output.match(/(\{[\s\S]*\}|\[[\s\S]*\])/);
+    if (!match)
+        return null;
+    try {
+        JSON.parse(match[1]);
+        return match[1];
+    }
+    catch {
+        return null;
+    }
+}
+// ---------------------------------------------------------------------------
+// Apply-patch failure patterns
+// ---------------------------------------------------------------------------
+const PATCH_FAILURE_PATTERNS = [
+    "failed",
+    "no match",
+    "not found",
+    "error applying",
+    "patch failed",
+    "hunk failed",
+    "rejected",
+];
+function isPatchFailure(output) {
+    return PATCH_FAILURE_PATTERNS.some((p) => output.toLowerCase().includes(p));
+}
+const TASK_RETRY_GUIDANCE = [
+    {
+        pattern: /run_in_background/,
+        guidance: "You used `run_in_background` with a non-`task` tool. Only the `task` tool supports background execution. Remove the parameter or switch to the `task` tool.",
+    },
+    {
+        pattern: /load_skills/,
+        guidance: "One or more skills could not be loaded. Check the skill name spelling, verify the skill name matches what opencode has installed, or remove the parameter.",
+    },
+    {
+        pattern: /category or subagent_type/,
+        guidance: "You must specify either `category` (general) or `subagent_type` (specialist). Provide exactly one — not both, not neither.",
+    },
+    {
+        pattern: /Must provide either category or subagent_type/,
+        guidance: "You omitted a required parameter. Add `subagent_type` with one of the available specialist types listed in the error output.",
+    },
+    {
+        pattern: /Unknown category/,
+        guidance: "The `category` name you used is not recognized. Rerun with the correct category name, or switch to `subagent_type` with a valid specialist type. Check the error output for the list of accepted values.",
+    },
+    {
+        pattern: /Unknown agent/,
+        guidance: "The `subagent_type` you specified does not exist. Use one from the list shown in the error output. Run the task again with a valid agent type.",
+    },
+    {
+        pattern: /Skills not found/,
+        guidance: "One or more skills referenced in `skill_names` were not found. Verify the skill names are correct and match what opencode has installed. Remove or correct the offending names and retry.",
+    },
+    {
+        pattern: /is not allowed\. Allowed agents:/,
+        guidance: "You tried to use a subagent that is not permitted. Use only agent types from the allowed list shown in the error output. If you need a specialist, delegate to `@lazy-oracle` for architecture/design advice.",
+    },
+];
+// ---------------------------------------------------------------------------
+// Main hook
+// ---------------------------------------------------------------------------
+export function createErrorRecoveryHook(runtime) {
+    return (input, output) => {
+        const { tool, sessionID } = input;
+        const out = output.output;
+        // Guard: avoid double-injection
+        if (output.output.includes("[JSON PARSE ERROR"))
+            return;
+        // --- 1. JSON error recovery ---
+        // Skip recovery for tools where JSON errors are expected in output (bash, web responses, etc.)
+        const isExcludedTool = JSON_RECOVERY_EXCLUDED_TOOLS.has(tool.toLowerCase());
+        if (hasJsonError(out) && !isExcludedTool) {
+            const fixed = tryFixJsonOutput(out);
+            if (fixed) {
+                output.output = `${out}\n\n[JSON PARSE ERROR — IMMEDIATE ACTION REQUIRED]
+The system could not parse your JSON. However, valid JSON was extracted from the output.
+STOP and do this NOW:
+1. LOOK at the recovered JSON below
+2. CORRECT your JSON (missing braces, unescaped quotes, trailing commas, etc.)
+3. RETRY the tool call with valid JSON
+
+Recovered JSON:
+\`\`\`json\n${fixed}\n\`\`\`
+
+DO NOT repeat the exact same invalid call.`;
+                output.metadata = {
+                    ...output.metadata,
+                    _recovered: true,
+                    _recoveryType: "json",
+                };
+            }
+            else {
+                // No valid JSON to recover — inject the error reminder
+                output.output = `${out}\n\n[JSON PARSE ERROR — IMMEDIATE ACTION REQUIRED]
+You sent invalid JSON arguments. The system could not parse your tool call.
+STOP and do this NOW:
+1. LOOK at the error message above to see what was expected vs what you sent.
+2. CORRECT your JSON syntax (missing braces, unescaped quotes, trailing commas, etc).
+3. RETRY the tool call with valid JSON.
+DO NOT repeat the exact same invalid call.`;
+                output.metadata = {
+                    ...output.metadata,
+                    _recovered: false,
+                    _recoveryType: "json",
+                };
+            }
+        }
+        // --- 2. Task tool error — retry guidance ---
+        if (tool === "task" && isErrorOutput(out)) {
+            const guidance = matchRetryGuidance(out);
+            if (guidance) {
+                output.output = `${output.output}\n\n[HINT: ${guidance}]`;
+                output.metadata = {
+                    ...output.metadata,
+                    _retryGuidance: true,
+                };
+            }
+        }
+        // --- 3. Bash tool JSON error — explicit retry instruction ---
+        if (tool === "bash" &&
+            (hasJsonError(output.output) || output.output.includes("SyntaxError"))) {
+            // Even if JSON was extracted, the model needs the instruction to use it
+            const jsonMatch = output.output.match(/(\{[\s\S]*\}|\[[\s\S]*\])/);
+            if (jsonMatch) {
+                output.output =
+                    `${output.output}\n\n[IMMEDIATE ACTION: The output above contains JSON. Parse and use:\n\`\`\`json\n${jsonMatch[1]}\n\`\`\`\nIgnore the error message — the JSON is intact.]`;
+                output.metadata = {
+                    ...output.metadata,
+                    _immediateAction: true,
+                };
+            }
+        }
+        // --- 4. Apply-patch failure — detailed guidance ---
+        if (tool === "apply_patch" && isPatchFailure(out)) {
+            output.output = `${output.output}\n\n[PATCH FAILURE — try these in order:
+1. Read the target file with Read tool to see current state
+2. Rewrite the patch with exact whitespace (tabs/spaces) matching the file
+3. If line numbers shifted, use broader surrounding context lines
+4. As last resort: use Write tool to edit the file directly]`;
+            output.metadata = {
+                ...output.metadata,
+                _patchGuidance: true,
+            };
+        }
+        // --- 5. Post-file-tool phase reminder (lazy primary only) ---
+        if ((tool === "Read" || tool === "Write" || tool === "edit") &&
+            isLazyPrimarySession(sessionID, runtime)) {
+            output.output =
+                `${output.output}\n\n[Scheduler: plan lanes → dispatch → wait for hook-driven completion → reconcile → verify.]`;
+        }
+    };
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function isErrorOutput(output) {
+    return /error|fail|exception|crash|abort/i.test(output.slice(0, 500));
+}
+function matchRetryGuidance(output) {
+    for (const { pattern, guidance } of TASK_RETRY_GUIDANCE) {
+        if (pattern.test(output))
+            return guidance;
+    }
+    return null;
+}
+function isLazyPrimarySession(sessionID, runtime) {
+    if (!sessionID || !runtime)
+        return false;
+    return runtime.sessionAgentMap.get(sessionID) === "lazy";
+}

package/dist/hooks/index.d.ts

@@ -0,0 +1,3 @@
+import type { Hooks } from "@opencode-ai/plugin";
+import type { LazyRuntime } from "./runtime.js";
+export declare function createHooks(runtime?: LazyRuntime): Pick<Hooks, "experimental.chat.system.transform" | "experimental.chat.messages.transform" | "experimental.session.compacting" | "experimental.compaction.autocontinue" | "chat.params" | "command.execute.before" | "permission.ask" | "tool.execute.before" | "tool.execute.after" | "event">;

package/dist/hooks/index.js

@@ -0,0 +1,61 @@
+import { createSystemTransformHook } from "./system-transform.js";
+import { createMessagesTransformHook } from "./messages-transform.js";
+import { createChatParamsHook } from "./chat-params.js";
+import { createTaskSessionAfterHook, createTaskSessionBeforeHook } from "./task-session.js";
+import { createErrorRecoveryHook } from "./error-recovery.js";
+import { createSessionEventsHook } from "./session-events.js";
+import { jobBoard } from "./background-job-board.js";
+import { createApplyPatchRescueHook } from "./apply-patch-rescue.js";
+import { createLazyCommandHandler } from "./lazy-command.js";
+import { createPermissionGuardHook } from "./permission-guard.js";
+// Compose tool.execute.before: patch rescue before task session manager
+const applyPatchRescue = createApplyPatchRescueHook();
+export function createHooks(runtime) {
+    const taskSessionBefore = createTaskSessionBeforeHook(runtime);
+    const taskSessionAfter = createTaskSessionAfterHook(runtime);
+    const errorRecovery = createErrorRecoveryHook(runtime);
+    const commandHandler = runtime ? createLazyCommandHandler(runtime) : undefined;
+    const permissionGuard = createPermissionGuardHook(runtime);
+    const sessionEvents = createSessionEventsHook((sid) => (runtime?.jobBoard ?? jobBoard).getTerminalUnreconciledJobs(sid).map((j) => j.taskID), runtime);
+    return {
+        "experimental.chat.system.transform": createSystemTransformHook(runtime),
+        "experimental.chat.messages.transform": createMessagesTransformHook(runtime),
+        "experimental.session.compacting": async (_input, output) => {
+            const stage = runtime?.workflow.stage;
+            const decision = runtime?.workflow.lastDecision;
+            if (stage && stage !== "idle") {
+                output.context.push(`Current workflow stage: ${stage}`);
+            }
+            if (decision) {
+                output.context.push(`Last workflow decision: ${decision.action} (${decision.level}) — ${decision.reason}`);
+            }
+            const recentEvents = runtime?.workflow.recentEvents.slice(-5);
+            if (recentEvents && recentEvents.length > 0) {
+                output.context.push(`Recent events: ${recentEvents.map((e) => e.summary).join("; ")}`);
+            }
+        },
+        "experimental.compaction.autocontinue": async (_input, output) => {
+            const stage = runtime?.workflow.stage;
+            // Disable auto-continue during user-interaction stages
+            if (stage === "grill" || stage === "specify" || stage === "plan") {
+                output.enabled = false;
+            }
+        },
+        "chat.params": createChatParamsHook(runtime),
+        "command.execute.before": async (input, output) => {
+            if (commandHandler)
+                await commandHandler(input, output);
+        },
+        "permission.ask": permissionGuard,
+        "tool.execute.before": async (input, output) => {
+            await taskSessionBefore(input, output);
+            await applyPatchRescue(input, output);
+        },
+        "tool.execute.after": async (input, output) => {
+            await taskSessionAfter(input, output);
+            await runtime?.recordToolEvidence(input, output);
+            await errorRecovery(input, output);
+        },
+        "event": sessionEvents,
+    };
+}

package/dist/hooks/lazy-command.d.ts

@@ -0,0 +1,16 @@
+import type { Config } from "@opencode-ai/plugin";
+import type { LazyRuntime } from "./runtime.js";
+type CommandOutput = {
+    parts: {
+        type: string;
+        text?: string;
+        [key: string]: unknown;
+    }[];
+};
+export declare function registerLazyCommands(opencodeConfig: Config, runtime: LazyRuntime): void;
+export declare function createLazyCommandHandler(runtime: LazyRuntime): (input: {
+    command: string;
+    arguments?: string;
+    sessionID?: string;
+}, output: CommandOutput) => Promise<void>;
+export {};

package/dist/hooks/lazy-command.js

@@ -0,0 +1,178 @@
+import { DEEPWORK_ACTIVATION } from "./deepwork.js";
+import { classifyWorkflow, formatWorkflowDecision, } from "./workflow-classifier.js";
+const MODES = new Set(["off", "coach", "governor", "strict"]);
+export function registerLazyCommands(opencodeConfig, runtime) {
+    if (!opencodeConfig.command)
+        opencodeConfig.command = {};
+    if (runtime.config.commands.lazy && !opencodeConfig.command.lazy) {
+        opencodeConfig.command.lazy = {
+            template: "Scope-govern a task: start/status/reset/mode/explain/review/simplify/debug/close/doctor/verify/risk/behavior/deepwork",
+            description: "Classify, gate, track, and close AI coding work",
+        };
+    }
+    if (runtime.config.commands.deepworkAlias && !opencodeConfig.command.deepwork) {
+        opencodeConfig.command.deepwork = {
+            template: "Alias for /lazy deepwork <task>",
+            description: "Compatibility alias for lazy deepwork mode",
+        };
+    }
+}
+export function createLazyCommandHandler(runtime) {
+    return async (input, output) => {
+        if (input.command === "deepwork" && runtime.config.commands.deepworkAlias) {
+            writeText(output, handleDeepwork(input.arguments ?? ""));
+            return;
+        }
+        if (input.command !== "lazy")
+            return;
+        const raw = input.arguments?.trim() ?? "";
+        const [subcommand, ...rest] = raw.split(/\s+/);
+        const args = rest.join(" ").trim();
+        switch (subcommand || "status") {
+            case "start":
+                await runtime.refreshOpenCodeSnapshot(input.sessionID);
+                writeText(output, await handleStart(runtime, args));
+                return;
+            case "status":
+                await runtime.refreshOpenCodeSnapshot(input.sessionID);
+                writeText(output, runtime.formatStatus(input.sessionID));
+                return;
+            case "reset":
+                await runtime.reset();
+                writeText(output, "Lazy runtime reset. Stage: idle.");
+                return;
+            case "mode":
+                writeText(output, await handleMode(runtime, args));
+                return;
+            case "explain":
+                writeText(output, handleExplain(runtime));
+                return;
+            case "review":
+                runtime.setStage("review");
+                await runtime.save();
+                writeText(output, "Load `lazy/review`. Review current changes for must-fix bugs first, then deletion opportunities and test gaps.");
+                return;
+            case "simplify":
+                runtime.setStage("simplify");
+                await runtime.save();
+                writeText(output, "Load `lazy/simplify`. Find what to delete, collapse, or replace with stdlib. One finding per line.");
+                return;
+            case "debug":
+                writeText(output, await handleDebug(runtime, args));
+                return;
+            case "close":
+                await runtime.refreshOpenCodeSnapshot(input.sessionID);
+                writeText(output, await handleClose(runtime, input.sessionID));
+                return;
+            case "doctor":
+                writeText(output, runtime.formatDoctorReport());
+                await runtime.save();
+                return;
+            case "verify":
+                writeText(output, await handleVerify(runtime, args));
+                return;
+            case "risk":
+                writeText(output, await handleEvidence(runtime, "risk", args, "Remaining risk recorded."));
+                return;
+            case "behavior":
+                writeText(output, await handleEvidence(runtime, "behavior", args, "Changed behavior recorded."));
+                return;
+            case "deepwork":
+                writeText(output, handleDeepwork(args));
+                return;
+            default:
+                writeText(output, "Usage: /lazy start <task> | status | reset | mode <off|coach|governor|strict> | explain | review | simplify | debug <msg> | close | doctor | verify <pass|fail|pending> | risk <text> | behavior <text> | deepwork <task>");
+        }
+    };
+}
+async function handleStart(runtime, task) {
+    if (!task)
+        return "Usage: /lazy start <task>";
+    const decision = classifyWorkflow({ text: task, mode: runtime.config.mode });
+    await runtime.recordDecision(decision);
+    runtime.setStage(stageForDecision(decision));
+    await runtime.save();
+    return [
+        "LAZY START",
+        `Task: ${task}`,
+        formatWorkflowDecision(decision),
+        `Stage: ${runtime.workflow.stage}`,
+        runtime.formatIsolationAdvice(decision),
+        `Next: ${decision.suggestedCommand ?? "proceed"}`,
+    ].filter(Boolean).join("\n");
+}
+async function handleMode(runtime, mode) {
+    if (!MODES.has(mode)) {
+        return `Current mode: ${runtime.config.mode}. Usage: /lazy mode <off|coach|governor|strict>`;
+    }
+    await runtime.setMode(mode);
+    return `Lazy mode set to ${mode}.`;
+}
+function handleExplain(runtime) {
+    const decision = runtime.workflow.lastDecision;
+    if (!decision)
+        return "No lazy decision has been recorded yet.";
+    return [
+        `Last lazy decision: ${decision.action} ${decision.level}`,
+        `Reason: ${decision.reason}`,
+        `Required stages: ${decision.requiredStages.join(" -> ") || "none"}`,
+        `Bypassed: ${decision.bypassedByUser ? "yes" : "no"}`,
+    ].join("\n");
+}
+async function handleDebug(runtime, args) {
+    runtime.setStage("debug");
+    await runtime.save();
+    return [
+        "LAZY DEBUG",
+        `Context: ${args || "(no additional context)"}`,
+        "",
+        "Load `lazy/debug`. Systematic diagnosis loop: reproduce → isolate → hypothesize → test → fix.",
+        "Available: @lazy-oracle for escalation, context7 for library API checks.",
+    ].join("\n");
+}
+function handleDeepwork(task) {
+    if (!task.trim()) {
+        return "What task should deepwork manage? Run `/lazy deepwork <task description>`.";
+    }
+    return DEEPWORK_ACTIVATION(task.trim());
+}
+async function handleClose(runtime, sessionID) {
+    runtime.setStage("close");
+    await runtime.save();
+    return [
+        "LAZY CLOSE",
+        "Close contract: review, simplify, verify, reconcile.",
+        "Manual corrections: /lazy behavior <text>, /lazy risk <text>, /lazy verify <pass|fail|pending>.",
+        "",
+        runtime.formatCloseReport(sessionID),
+    ].join("\n");
+}
+async function handleVerify(runtime, result) {
+    if (result !== "pass" && result !== "fail" && result !== "pending") {
+        return "Usage: /lazy verify <pass|fail|pending>";
+    }
+    await runtime.recordCloseEvidence("verification", result);
+    return `Verification result recorded: ${result}.`;
+}
+async function handleEvidence(runtime, kind, text, ok) {
+    if (!text.trim()) {
+        return kind === "risk" ? "Usage: /lazy risk <text>" : "Usage: /lazy behavior <text>";
+    }
+    await runtime.recordCloseEvidence(kind, text.trim());
+    return ok;
+}
+function stageForDecision(decision) {
+    if (decision.requiredStages.includes("grill"))
+        return "grill";
+    if (decision.requiredStages.includes("debug"))
+        return "debug";
+    if (decision.requiredStages.includes("plan"))
+        return "plan";
+    if (decision.requiredStages.includes("build"))
+        return "build";
+    return "idle";
+}
+function writeText(output, text) {
+    output.parts.length = 0;
+    output.parts.push({ type: "text", text });
+}

package/dist/hooks/messages-transform.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Context pruning + image redirect + job board + workflow gate via messages.transform.
+ *
+ * Features:
+ *   1. Enhanced pruning: keep system + last N user turns + everything between
+ *   2. Image processing (strip images, inject @lazy-observer redirect)
+ *   3. Job board injection for lazy primary (terminal unreconciled jobs only)
+ *   4. Workflow gate: detect skipped steps, inject STOP message
+ *   5. Skill filtering per-agent
+ *
+ * ponytail: Don't remind — gate. Only inject when a condition is met.
+ */
+import type { LazyRuntime } from "./runtime.js";
+interface MessagePart {
+    type: string;
+    text?: string;
+    tool_call?: {
+        name: string;
+        arguments: string;
+    };
+    tool_result?: {
+        tool_use_id: string;
+        content: unknown[];
+    };
+}
+interface ChatMessage {
+    info: {
+        role: string;
+        agent?: string;
+    };
+    parts: MessagePart[];
+}
+interface TransformInput {
+    sessionID?: string;
+    agent?: string;
+}
+export declare function createMessagesTransformHook(runtime?: LazyRuntime): (input: TransformInput, output: {
+    messages: ChatMessage[];
+}) => Promise<void>;
+export {};