lazyopencode-core 0.0.1

package/dist/hooks/session-events.js

@@ -0,0 +1,65 @@
+/**
+ * Session lifecycle hooks — cleanup, reconciliation, and state tracking.
+ *
+ * ponytail: minimal lifecycle. Only track what affects job board integrity.
+ */
+import { jobBoard } from "./background-job-board.js";
+import { rm } from "node:fs/promises";
+import { join } from "node:path";
+/**
+ * Combined session event hook — dispatches on event.type.
+ * SDK only supports "event" as a single hook, not per-event-type hooks.
+ */
+export function createSessionEventsHook(rememberFn, runtime) {
+    return async (input) => {
+        const evt = input.event;
+        switch (evt.type) {
+            // --- session.idle — reconcile all terminal jobs ---
+            case "session.idle": {
+                const sid = evt.properties?.sessionID;
+                if (!sid)
+                    return;
+                const taskIDs = rememberFn(sid);
+                for (const tid of taskIDs) {
+                    ;
+                    (runtime?.jobBoard ?? jobBoard).markReconciled(tid);
+                }
+                runtime?.recordEvent("reconcile", `Reconciled ${taskIDs.length} terminal jobs for ${sid}.`);
+                await runtime?.save();
+                return;
+            }
+            // --- session.compacted — record compaction event ---
+            case "session.compacted": {
+                const sid = evt.properties?.sessionID;
+                if (sid) {
+                    runtime?.recordEvent("compaction", `Session ${sid} compacted.`);
+                    await runtime?.save();
+                }
+                return;
+            }
+            // --- session.created — nothing to initialize yet ---
+            case "session.created":
+                return;
+            // --- session.deleted / session.error — cleanup ---
+            case "session.deleted":
+            case "session.error": {
+                const sid = evt.properties?.sessionID ??
+                    evt.properties?.info
+                        ?.id;
+                if (!sid)
+                    return;
+                (runtime?.jobBoard ?? jobBoard).dropSession(sid);
+                runtime?.sessionAgentMap.delete(sid);
+                runtime?.sessionDepth.delete(sid);
+                // Use same base as processImageAttachments (runtime.scope.projectRoot or cwd)
+                const baseDir = runtime?.scope.projectRoot ?? process.cwd();
+                const imagesDir = join(baseDir, ".opencode", "lazy", "images", sid);
+                rm(imagesDir, { recursive: true, force: true }).catch((err) => {
+                    console.error("[session-events] failed to cleanup images:", err);
+                });
+                await runtime?.save();
+                return;
+            }
+        }
+    };
+}

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

@@ -0,0 +1,8 @@
+import type { Model } from "@opencode-ai/sdk";
+import type { LazyRuntime } from "./runtime.js";
+export declare function createSystemTransformHook(runtime?: LazyRuntime): (input: {
+    sessionID?: string;
+    model: Model;
+}, output: {
+    system: string[];
+}) => Promise<void>;

package/dist/hooks/system-transform.js

@@ -0,0 +1,113 @@
+import { PONYTAIL_MODE } from "../ponytail.js";
+const LAZY_SYSTEM_PROMPT = `<Role>
+You are a lazy workflow engine for coding work. Your job is to plan, schedule, delegate, monitor, reconcile, and verify specialist-agent work. You default to the lazy workflow unless the user says "just do it" or the task is trivial.
+</Role>
+
+## The lazy workflow (default for any non-trivial task)
+
+1. **grill** — interview the user relentlessly to sharpen the plan. Load \`lazy/grill\`.
+2. **specify** — turn the discussion into a PRD and tracking issue. Load \`lazy/specify\`.
+3. **plan** — break the PRD into independently-grabbable issues. Load \`lazy/plan\`.
+4. **build** — implement one issue at a time, test-first, YAGNI-gated. Load \`lazy/build\`.
+5. **review** — code review: find bugs, suggest deletions. Load \`lazy/review\`.
+
+- After every \`lazy/review\`: ask @lazy-oracle to identify deletions. No review is complete without a simplification pass.
+
+## Shortcuts
+- User says "just do it" → skip grill/specify/plan, go to build with ponytail rules.
+- Trivial task (one-liner, config, typo) → answer directly, no workflow.
+- "Quick prototype, no tests" → load \`lazy/build --prototype\`.
+- User says "debug this" → load \`lazy/debug\`.
+- User says "simplify this" → load \`lazy/simplify\`.
+- User says "review this" → load \`lazy/review\`.
+- Managing git worktrees → load \`lazy/worktree\`.
+
+## Available lazy skills
+- \`lazy/grill\` — Align on goals, constraints, risks before building
+- \`lazy/specify\` — Synthesize convo into PRD with domain terms
+- \`lazy/plan\` — Break spec into vertical-slice issues
+- \`lazy/build\` — TDD per slice, supports --prototype mode
+- \`lazy/review\` — Find bugs, missing cases, deletion opportunities
+- \`lazy/debug\` — Systematic diagnosis loop for hard bugs
+- \`lazy/simplify\` — Find dead code and shallow modules, delete
+- \`lazy/worktree\` — Isolated Git worktrees for parallel/risky work
+
+## Available agents
+- @lazy-explorer — Fast codebase recon (glob, grep, AST). Delegate for discovery, not full content.
+- @lazy-librarian — External docs, API references, web research. Delegate for unfamiliar libraries.
+- @lazy-oracle — Architecture, risk, debugging strategy, code review. Delegate for high-stakes decisions, persistent bugs, simplification review.
+- @lazy-designer — UI/UX design, visual polish, responsive layouts. Delegate for user-facing interfaces.
+- @lazy-fixer — Bounded implementation, fast execution. Delegate for well-defined, multi-file mechanical changes.
+- @lazy-observer — Visual analysis of images, screenshots, PDFs.
+
+## Delegation rules
+- Reference paths/lines, don't paste files.
+- Launch parallel independent agents simultaneously.
+- Record task IDs, reconcile results, verify.
+- Do not duplicate work already dispatched to a specialist.
+
+## Background Task Discipline
+- Prefer task(..., background: true) for delegated work
+- Launch specialist agents in the background by default
+- Track each task's specialist, objective, task/session ID
+- Before final response, reconcile any terminal jobs shown in the Background Job Board
+- Parallel background tasks allowed only when write scopes do not conflict
+- Use cancel_task only when user asks, or when a running lane is obsolete
+
+<Workflow>
+1. Understand the request.
+2. Run the lazy workflow ladder — pick the right stage.
+3. Delegate efficiently to specialists.
+4. Verify results. Verify results. Verify results.
+</Workflow>
+
+<Communication>
+- Be concise. One-word answers are fine.
+- No flattery. No "Great idea!"
+- If the user's approach seems problematic: state concern + alternative concisely. Ask if they want to proceed.
+- Don't summarize what you did unless asked.
+- Don't explain code unless asked.
+</Communication>`;
+const LAZY_SYSTEM_PROMPT_LITE = `## Lazy workflow (brief)
+If this is a non-trivial task, follow: grill → specify → plan → build → review.
+Available agents: @lazy-explorer, @lazy-oracle, @lazy-librarian, @lazy-designer, @lazy-fixer, @lazy-observer.
+Delegate parallel work when possible.`;
+// ponytail: inject PONYTAIL_MODE for ALL agents, LAZY_SYSTEM_PROMPT only for lazy primary.
+// Guard double-injection for both.
+export function createSystemTransformHook(runtime) {
+    return async (input, output) => {
+        // Always inject PONYTAIL_MODE for all agents
+        if (runtime?.config.ponytailMode !== false &&
+            !output.system.some((s) => s.includes("PONYTAIL MODE ACTIVE"))) {
+            if (output.system.length > 0) {
+                output.system[output.system.length - 1] += "\n\n" + PONYTAIL_MODE;
+            }
+            else {
+                output.system.push(PONYTAIL_MODE);
+            }
+        }
+        // Additionally inject scope-governor prompt for lazy primary sessions only
+        const sid = input.sessionID;
+        if (!sid)
+            return;
+        const agentName = runtime?.sessionAgentMap.get(sid);
+        if (!agentName) {
+            // Race condition: chat.params may not have run yet. Inject lite prompt.
+            if (output.system.some((s) => s.includes("Lazy workflow")))
+                return;
+            output.system.push(LAZY_SYSTEM_PROMPT_LITE);
+            return;
+        }
+        if (agentName !== "lazy")
+            return;
+        // Guard against double injection
+        if (output.system[0]?.startsWith(LAZY_SYSTEM_PROMPT.slice(0, 30)))
+            return;
+        if (output.system.length > 0) {
+            output.system[0] = LAZY_SYSTEM_PROMPT + "\n\n" + output.system[0];
+        }
+        else {
+            output.system.push(LAZY_SYSTEM_PROMPT);
+        }
+    };
+}

package/dist/hooks/task-session.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Task session management — track subagent dispatch via BackgroundJobBoard.
+ *
+ * Matches slim's full state machine:
+ *   - Launch registration (tool.execute.before)
+ *   - Completion parsing (tool.execute.after)
+ *   - Context file accumulation (tool.execute.after read)
+ *   - Late-cancel normalization
+ */
+import type { LazyRuntime } from "./runtime.js";
+interface ToolBeforeInput {
+    tool: string;
+    sessionID: string;
+    callID: string;
+}
+interface ToolBeforeOutput {
+    args: Record<string, unknown>;
+}
+interface ToolAfterInput {
+    tool: string;
+    sessionID: string;
+    callID: string;
+    args: Record<string, unknown>;
+}
+interface ToolAfterOutput {
+    title: string;
+    output: string;
+    metadata: Record<string, unknown>;
+}
+export declare function createTaskSessionBeforeHook(runtime?: LazyRuntime): (input: ToolBeforeInput, output: ToolBeforeOutput) => void;
+export declare function createTaskSessionAfterHook(runtime?: LazyRuntime): (input: ToolAfterInput, output: ToolAfterOutput) => Promise<void>;
+export {};

package/dist/hooks/task-session.js

@@ -0,0 +1,177 @@
+/**
+ * Task session management — track subagent dispatch via BackgroundJobBoard.
+ *
+ * Matches slim's full state machine:
+ *   - Launch registration (tool.execute.before)
+ *   - Completion parsing (tool.execute.after)
+ *   - Context file accumulation (tool.execute.after read)
+ *   - Late-cancel normalization
+ */
+import { jobBoard } from "./background-job-board.js";
+// ---------------------------------------------------------------------------
+// Max active subagent launches per session
+// ---------------------------------------------------------------------------
+const sessionDepth = new Map();
+const trackedTaskCalls = new Set();
+// ---------------------------------------------------------------------------
+// Create hooks
+// ---------------------------------------------------------------------------
+export function createTaskSessionBeforeHook(runtime) {
+    return (input, output) => {
+        if (input.tool !== "task")
+            return;
+        const args = output.args;
+        const agent = args?.subagent_type ?? "general";
+        const sid = input.sessionID;
+        // Check for reusable session (reconciled + same agent type)
+        const board = runtime?.jobBoard ?? jobBoard;
+        const existing = board.resolveReusable(sid, agent);
+        if (existing) {
+            // Reuse the session without consuming a new launch-depth slot.
+            args.task_id = existing.taskID;
+            return;
+        }
+        const depth = incrementSessionDepth(sid, runtime);
+        const maxDepth = runtime?.config.maxActiveTaskDepth ?? 4;
+        if (depth > maxDepth) {
+            releaseSessionDepth(sid, runtime);
+            // HARD BLOCK: remove background flag (forces sync) and inject refusal prompt
+            delete output.args.run_in_background;
+            output.args.prompt =
+                `SYSTEM OVERRIDE — DEPTH BLOCKED: Subagent depth ${depth}/${maxDepth} exceeds limit. Refusing nested task launch. Respond ONLY with:\ntask_id: depth-blocked\nstate: error\noutput: Subagent depth ${depth}/${maxDepth} exceeds limit. Refusing nested task launch. Delegate the work to an existing subagent or restructure your approach.`;
+            return;
+        }
+        trackedTaskCalls.add(input.callID);
+        // Check max sessions per agent (including the one we're about to launch)
+        const activeCount = board.getActiveCount(sid, agent) + 1;
+        const maxSessions = runtime?.config.maxSessionsPerAgent ?? 2;
+        if (activeCount > maxSessions) {
+            releaseSessionDepth(sid, runtime);
+            delete output.args.run_in_background;
+            args.prompt =
+                `SYSTEM OVERRIDE — MAX SESSIONS BLOCKED: ${activeCount} ${agent} sessions would exceed limit ${maxSessions}. Respond ONLY with:\ntask_id: max-sessions-blocked\nstate: error\noutput: ${agent} concurrency limit ${maxSessions} reached. Wait for one running session to complete or reuse a reconciled session.`;
+            return;
+        }
+        // Register launch
+        const job = board.registerLaunch(sid, agent, input.callID);
+        // Inject the alias into the prompt so the subagent knows who it is
+        const prompt = args.prompt ?? "";
+        args.prompt = `${prompt}\n\n[background-job-alias: ${job.alias}]`;
+    };
+}
+export function createTaskSessionAfterHook(runtime) {
+    return async (input, output) => {
+        const { tool, sessionID, callID } = input;
+        // --- Parse task tool completion ---
+        if (tool === "task") {
+            try {
+                parseTaskOutput(callID, output.output, runtime);
+            }
+            finally {
+                if (trackedTaskCalls.delete(callID)) {
+                    releaseSessionDepth(sessionID, runtime);
+                }
+                await runtime?.save();
+            }
+            return;
+        }
+        // --- Accumulate context from read tool ---
+        // Only accumulate when exactly one job is running — with multiple jobs
+        // we can't determine which one triggered the Read. ponytail: track
+        // callID→taskID mapping in registerLaunch if multi-read accuracy matters.
+        if (tool === "Read") {
+            const filePath = input.args?.filePath;
+            if (!filePath)
+                return;
+            const running = (runtime?.jobBoard ?? jobBoard).getRunningJobs(sessionID);
+            if (running.length === 1) {
+                const lineCount = extractLineCount(output.output);
+                (runtime?.jobBoard ?? jobBoard).addContext(running[0].taskID, {
+                    path: filePath,
+                    lineCount,
+                });
+                await runtime?.save();
+            }
+        }
+    };
+}
+function incrementSessionDepth(sessionID, runtime) {
+    const map = runtime?.sessionDepth ?? sessionDepth;
+    // Prune to prevent memory leaks
+    if (map.size > 1000) {
+        const firstKey = map.keys().next().value;
+        map.delete(firstKey);
+    }
+    const depth = (map.get(sessionID) ?? 0) + 1;
+    map.set(sessionID, depth);
+    return depth;
+}
+function releaseSessionDepth(sessionID, runtime) {
+    const map = runtime?.sessionDepth ?? sessionDepth;
+    const depth = map.get(sessionID);
+    if (!depth)
+        return;
+    if (depth <= 1) {
+        map.delete(sessionID);
+        return;
+    }
+    map.set(sessionID, depth - 1);
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/**
+ * Parse task tool output to extract task_id + state.
+ */
+function parseTaskOutput(callID, output, runtime) {
+    const board = runtime?.jobBoard ?? jobBoard;
+    const taskID = extractTaskID(output);
+    const state = extractState(output);
+    const summary = extractSummary(output);
+    // Late-cancel check
+    if (board.isLateCancelledTaskError(callID) && state === "error") {
+        board.updateStatus(callID, taskID ?? callID, "cancelled");
+        return;
+    }
+    if (state && taskID) {
+        board.updateStatus(callID, taskID, state, summary);
+    }
+    else if (state) {
+        // Use callID as fallback taskID
+        board.updateStatus(callID, callID, state, summary);
+    }
+}
+function extractTaskID(output) {
+    const match = output.match(/task_id:\s*(\S+)/);
+    return match ? match[1] : null;
+}
+function extractState(output) {
+    if (output.includes("state: cancelled"))
+        return "cancelled";
+    if (output.includes("state: error"))
+        return "error";
+    if (output.includes("state: completed"))
+        return "completed";
+    // Heuristic based on output
+    if (/error|fail|crash/i.test(output.slice(0, 200)))
+        return "error";
+    if (/completed|done|finished/i.test(output.slice(0, 200)))
+        return "completed";
+    return null;
+}
+function extractSummary(output) {
+    // First non-empty line after "result:" or "summary:" or the first output line
+    const lines = output.split("\n").map((l) => l.trim()).filter(Boolean);
+    if (lines.length === 0)
+        return undefined;
+    const resultIdx = lines.findIndex((l) => /^(result|summary|output)\s*:/i.test(l));
+    if (resultIdx >= 0 && resultIdx + 1 < lines.length) {
+        return lines[resultIdx + 1];
+    }
+    // Fallback: first line up to 200 chars
+    return lines[0].slice(0, 200);
+}
+function extractLineCount(output) {
+    const lines = output.split("\n").filter((l) => l.trim()).length;
+    return lines;
+}

package/dist/hooks/workflow-classifier.d.ts

@@ -0,0 +1,17 @@
+export type WorkflowLevel = "trivial" | "small" | "medium" | "high_risk" | "ambiguous";
+export type WorkflowStage = "grill" | "specify" | "plan" | "build" | "review" | "simplify" | "debug";
+export type LazyMode = "off" | "coach" | "governor" | "strict";
+export interface WorkflowDecision {
+    level: WorkflowLevel;
+    action: "allow" | "nudge" | "block";
+    requiredStages: WorkflowStage[];
+    reason: string;
+    bypassedByUser: boolean;
+    suggestedCommand?: string;
+}
+export interface ClassifierInput {
+    text: string;
+    mode?: LazyMode;
+}
+export declare function classifyWorkflow(input: ClassifierInput): WorkflowDecision;
+export declare function formatWorkflowDecision(decision: WorkflowDecision): string;

package/dist/hooks/workflow-classifier.js

@@ -0,0 +1,170 @@
+const BYPASS_PATTERNS = [
+    /\bjust do it\b/i,
+    /\bskip plan\b/i,
+    /\bno questions\b/i,
+    /\bdo it directly\b/i,
+    /直接做/,
+    /别问/,
+    /不用计划/,
+    /跳过计划/,
+];
+const HIGH_RISK_PATTERNS = [
+    /\bauth(entication|orization)?\b/i,
+    /\bsecurity\b/i,
+    /\bpermission(s)?\b/i,
+    /\bpayment(s)?\b/i,
+    /\bmigration\b/i,
+    /\bdelete\b.*\b(table|column|schema|migration|database|production|user|account|payment|index|role|permission|policy)\b/i,
+    /\bdrop\b.*\b(table|column|database|schema|index|view|role|user)\b/i,
+    /\bsecret(s)?\b/i,
+    /\btoken(s)?\b/i,
+    /\bproduction\b/i,
+    /\bdeploy(ment)?\b/i,
+    /\bconcurren(cy|t)\b/i,
+    /\bbroad refactor\b/i,
+    /权限/,
+    /认证/,
+    /安全/,
+    /支付/,
+    /迁移/,
+    /删除/,
+    /生产/,
+    /部署/,
+    /密钥/,
+];
+const AMBIGUOUS_PATTERNS = [
+    /\bmake (it )?better\b/i,
+    /\bclean up everything\b/i,
+    /\boptimi[sz]e (this|the project|everything)\b/i,
+    /\bfix this\b/i,
+    /全面优化/,
+    /全面改造/,
+    /优化一下/,
+    /改好一点/,
+    /整理一下/,
+];
+const MEDIUM_PATTERNS = [
+    /\bmulti[- ]file\b/i,
+    /\brefactor\b/i,
+    /\bimplement\b/i,
+    /\bfeature\b/i,
+    /\bchange behavior\b/i,
+    /\badd\b/i,
+    /\bbuild\b/i,
+    /实现/,
+    /新增/,
+    /重构/,
+    /多个文件/,
+];
+const TRIVIAL_PATTERNS = [
+    /\bwhat is\b/i,
+    /\bexplain\b/i,
+    /\bwhy\b/i,
+    /\btypo\b/i,
+    /\brename\b/i,
+    /\bone[- ]line\b/i,
+    /是什么/,
+    /解释/,
+    /为什么/,
+    /拼写/,
+];
+export function classifyWorkflow(input) {
+    const text = input.text.trim();
+    const mode = input.mode ?? "governor";
+    const bypassedByUser = BYPASS_PATTERNS.some((p) => p.test(text));
+    const level = detectLevel(text);
+    const requiredStages = stagesForLevel(level);
+    const action = chooseAction(level, mode, bypassedByUser);
+    const reason = reasonForLevel(level);
+    return {
+        level,
+        action,
+        requiredStages,
+        reason,
+        bypassedByUser,
+        suggestedCommand: suggestedCommand(level),
+    };
+}
+export function formatWorkflowDecision(decision) {
+    if (decision.action === "allow") {
+        return `[Lazy scope: ${decision.level}. ${decision.reason} Next: ${decision.suggestedCommand ?? "proceed with ponytail discipline"}.]`;
+    }
+    if (decision.action === "nudge") {
+        return `[Lazy nudge: ${decision.level}. ${decision.reason} Suggested next step: ${decision.suggestedCommand}.]`;
+    }
+    return `[Lazy gate: ${decision.level}. ${decision.reason} Need scope, success criteria, and must-not-break list. Say "just do it" to bypass.]`;
+}
+function detectLevel(text) {
+    if (!text)
+        return "ambiguous";
+    if (HIGH_RISK_PATTERNS.some((p) => p.test(text)))
+        return "high_risk";
+    if (AMBIGUOUS_PATTERNS.some((p) => p.test(text)))
+        return "ambiguous";
+    if (MEDIUM_PATTERNS.some((p) => p.test(text)))
+        return "medium";
+    if (TRIVIAL_PATTERNS.some((p) => p.test(text)))
+        return "trivial";
+    if (text.length < 200 &&
+        /\b(why|what|how|when|where|does|is|are|can|could|should|would)\b.*\?/i.test(text))
+        return "trivial";
+    if (text.length < 80)
+        return "small";
+    return "medium";
+}
+function chooseAction(level, mode, bypassedByUser) {
+    if (mode === "off" || bypassedByUser)
+        return "allow";
+    if (mode === "coach")
+        return level === "trivial" || level === "small" ? "allow" : "nudge";
+    if (mode === "strict") {
+        return level === "medium" || level === "high_risk" || level === "ambiguous" ? "block" : "allow";
+    }
+    if (level === "high_risk" || level === "ambiguous")
+        return "block";
+    if (level === "medium")
+        return "nudge";
+    return "allow";
+}
+function stagesForLevel(level) {
+    switch (level) {
+        case "trivial":
+            return [];
+        case "small":
+            return ["build", "review"];
+        case "medium":
+            return ["plan", "build", "review", "simplify"];
+        case "high_risk":
+            return ["grill", "specify", "plan", "build", "review", "simplify"];
+        case "ambiguous":
+            return ["grill", "specify", "plan"];
+    }
+}
+function reasonForLevel(level) {
+    switch (level) {
+        case "trivial":
+            return "Tiny or explanatory task; no workflow gate needed.";
+        case "small":
+            return "Bounded task; build and verify directly.";
+        case "medium":
+            return "Behavior change needs a short plan and review closure.";
+        case "high_risk":
+            return "Risky area needs alignment before implementation.";
+        case "ambiguous":
+            return "Broad or vague scope needs sharpening before implementation.";
+    }
+}
+function suggestedCommand(level) {
+    switch (level) {
+        case "trivial":
+            return "answer directly";
+        case "small":
+            return "lazy/build";
+        case "medium":
+            return "lazy/plan";
+        case "high_risk":
+            return "lazy/grill";
+        case "ambiguous":
+            return "lazy/grill";
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+import type { Plugin } from "@opencode-ai/plugin";
+import { LazyOpenCodeV2Plugin } from "./v2.js";
+/**
+ * @lazyopencode/core — Governed team runtime for AI coding in OpenCode.
+ *
+ * One plugin. Zero config. Total takeover.
+ *
+ * Install: { "plugin": ["@lazyopencode/core"] }
+ */
+declare const LazyOpenCodePluginV1: Plugin;
+declare const LazyOpenCodePlugin: Plugin;
+export { LazyOpenCodePlugin, LazyOpenCodePluginV1, LazyOpenCodeV2Plugin };
+export default LazyOpenCodeV2Plugin;