lazyopencode-core 0.0.1

package/dist/hooks/background-job-board.js

@@ -0,0 +1,452 @@
+/**
+ * BackgroundJobBoard — in-memory state machine for subagent task tracking.
+ *
+ * ponytail: global singletons, no DI. Upgrade: per-session isolation if starvation occurs.
+ */
+// ---------------------------------------------------------------------------
+// Config
+// ---------------------------------------------------------------------------
+const _MAX_SESSIONS_PER_AGENT = 2;
+const MAX_PENDING_CALLS = 100;
+const MAX_INJECTED_COMPLETIONS = 500;
+const CONTEXT_MIN_LINES = 10;
+const CONTEXT_MAX_FILES = 8;
+function findJobByTaskID(jobs, taskID) {
+    for (const job of jobs.values()) {
+        if (job.taskID === taskID)
+            return job;
+    }
+    return undefined;
+}
+function findJobByCallIDScan(jobs, callID) {
+    for (const job of jobs.values()) {
+        if (job.callID === callID)
+            return job;
+    }
+    return undefined;
+}
+function isReusableJob(job) {
+    return job.state === "reconciled" && !job.terminalUnreconciled;
+}
+// ---------------------------------------------------------------------------
+// Board
+// ---------------------------------------------------------------------------
+export class BackgroundJobBoard {
+    jobs = new Map();
+    pendingCalls = [];
+    agentCounter = new Map();
+    processedCompletions = new Set();
+    injectedCompletionsSeen = new Set();
+    maxReusablePerAgent = 2;
+    dirty = false;
+    constructor(options) {
+        if (options?.maxReusablePerAgent) {
+            this.maxReusablePerAgent = options.maxReusablePerAgent;
+        }
+    }
+    configure(options) {
+        if (options.maxReusablePerAgent) {
+            this.maxReusablePerAgent = options.maxReusablePerAgent;
+        }
+    }
+    // -----------------------------------------------------------------------
+    // Launch
+    // -----------------------------------------------------------------------
+    registerLaunch(parentSessionID, agent, callID) {
+        const taskID = Date.now().toString(36).slice(-4) + Math.random().toString(36).slice(2, 6); // placeholder; real taskID set in parseLaunch
+        const count = this.agentCounter.get(agent) ?? 0;
+        this.agentCounter.set(agent, count + 1);
+        const alias = `${agent}-${count + 1}`;
+        const now = Date.now();
+        const job = {
+            taskID,
+            parentSessionID,
+            agent,
+            state: "running",
+            terminalUnreconciled: false,
+            timedOut: false,
+            cancellationRequested: false,
+            alias,
+            callID,
+            contextFiles: [],
+            launchedAt: now,
+            lastLaunchedAt: now,
+            lastUsedAt: now,
+            updatedAt: now,
+            completedAt: 0,
+        };
+        // Store by alias (used for lookup before real taskID is known)
+        this.jobs.set(alias, job);
+        // Track pending call
+        this.pendingCalls.push({ callID, sessionID: parentSessionID, alias });
+        if (this.pendingCalls.length > MAX_PENDING_CALLS) {
+            this.pendingCalls.shift();
+        }
+        this.dirty = true;
+        return job;
+    }
+    // -----------------------------------------------------------------------
+    // Match pending call to job
+    // -----------------------------------------------------------------------
+    findJobByCallID(callID) {
+        const pending = this.pendingCalls.find((p) => p.callID === callID);
+        if (!pending?.alias)
+            return undefined;
+        return this.jobs.get(pending.alias) ?? findJobByCallIDScan(this.jobs, callID);
+    }
+    findJobByTaskID(taskID) {
+        return findJobByTaskID(this.jobs, taskID);
+    }
+    findJobByAlias(alias) {
+        for (const job of this.jobs.values()) {
+            if (job.alias === alias)
+                return job;
+        }
+        return undefined;
+    }
+    // -----------------------------------------------------------------------
+    // Update state (called from tool.execute.after)
+    // -----------------------------------------------------------------------
+    updateStatus(callID, taskID, state, resultSummary) {
+        const job = this.findJobByCallID(callID);
+        if (!job)
+            return;
+        // Late-cancel normalization: if cancelled + error → force cancelled
+        if (state === "error" && job.cancellationRequested) {
+            state = "cancelled";
+        }
+        const now = Date.now();
+        const oldTaskID = job.taskID;
+        job.taskID = taskID || job.taskID;
+        if (oldTaskID !== job.taskID)
+            this.jobs.delete(oldTaskID);
+        job.state = state;
+        job.updatedAt = now;
+        if (resultSummary)
+            job.resultSummary = resultSummary;
+        if (state === "completed" || state === "error" || state === "cancelled") {
+            job.completedAt = now;
+            job.terminalUnreconciled = true;
+            this.trimReusable(taskID);
+        }
+        // Re-index by taskID and drop stale alias key
+        this.jobs.set(taskID, job);
+        const pending = this.pendingCalls.find((p) => p.callID === callID);
+        if (pending?.alias)
+            this.jobs.delete(pending.alias);
+        this.dirty = true;
+    }
+    // -----------------------------------------------------------------------
+    // Context accumulation
+    // -----------------------------------------------------------------------
+    addContext(taskID, file) {
+        if (file.lineCount < CONTEXT_MIN_LINES)
+            return;
+        const job = findJobByTaskID(this.jobs, taskID);
+        if (!job || job.state !== "running")
+            return;
+        const existing = job.contextFiles.find((f) => f.path === file.path);
+        if (existing) {
+            existing.lineCount = Math.max(existing.lineCount, file.lineCount);
+        }
+        else {
+            job.contextFiles.push(file);
+        }
+        job.contextFiles = job.contextFiles
+            .sort((a, b) => b.lineCount - a.lineCount)
+            .slice(0, CONTEXT_MAX_FILES);
+    }
+    // -----------------------------------------------------------------------
+    // Reconciliation
+    // -----------------------------------------------------------------------
+    markReconciled(taskID) {
+        const job = findJobByTaskID(this.jobs, taskID);
+        if (job) {
+            job.terminalUnreconciled = false;
+            if (job.state === "completed" || job.state === "reconciled") {
+                job.state = "reconciled";
+            }
+            job.updatedAt = Date.now();
+        }
+        this.injectedCompletionsSeen.delete(taskID);
+        this.trimReusable(taskID);
+        this.dirty = true;
+    }
+    trimReusable(taskID) {
+        const job = findJobByTaskID(this.jobs, taskID);
+        if (!job || !isReusableJob(job))
+            return;
+        const reusable = [...this.jobs.values()]
+            .filter((j) => j.agent === job.agent &&
+            j.parentSessionID === job.parentSessionID &&
+            isReusableJob(j))
+            .sort((a, b) => b.lastUsedAt - a.lastUsedAt);
+        for (const stale of reusable.slice(this.maxReusablePerAgent)) {
+            this.jobs.delete(stale.taskID);
+        }
+    }
+    getTerminalUnreconciledJobs(parentSessionID) {
+        const result = [];
+        for (const job of this.jobs.values()) {
+            if (job.parentSessionID === parentSessionID &&
+                job.terminalUnreconciled) {
+                result.push(job);
+            }
+        }
+        return result;
+    }
+    getRunningJobs(parentSessionID) {
+        const result = [];
+        for (const job of this.jobs.values()) {
+            if (job.parentSessionID === parentSessionID && job.state === "running") {
+                result.push(job);
+            }
+        }
+        return result;
+    }
+    getStaleJobs(parentSessionID) {
+        const result = [];
+        for (const job of this.jobs.values()) {
+            if (job.parentSessionID === parentSessionID && job.state === "stale") {
+                result.push(job);
+            }
+        }
+        return result;
+    }
+    getReusableJobs(parentSessionID) {
+        return [...this.jobs.values()].filter((job) => job.parentSessionID === parentSessionID && isReusableJob(job));
+    }
+    // -----------------------------------------------------------------------
+    // Session reuse
+    // -----------------------------------------------------------------------
+    resolveReusable(parentSessionID, agent) {
+        const candidates = [];
+        for (const job of this.jobs.values()) {
+            if (job.parentSessionID === parentSessionID &&
+                job.agent === agent &&
+                isReusableJob(job)) {
+                candidates.push(job);
+            }
+        }
+        // Return oldest reconciled session
+        if (candidates.length > 0) {
+            candidates.sort((a, b) => a.completedAt - b.completedAt);
+            const job = candidates[0];
+            const now = Date.now();
+            job.lastLaunchedAt = now;
+            job.lastUsedAt = now;
+            return job;
+        }
+        return undefined;
+    }
+    getReusableJob(taskID) {
+        const job = findJobByTaskID(this.jobs, taskID);
+        if (job && isReusableJob(job)) {
+            return job;
+        }
+        return undefined;
+    }
+    getActiveCount(parentSessionID, agent) {
+        let count = 0;
+        for (const job of this.jobs.values()) {
+            if (job.parentSessionID === parentSessionID &&
+                job.agent === agent &&
+                job.state === "running") {
+                count++;
+            }
+        }
+        return count;
+    }
+    isLateCancelledTaskError(callID) {
+        const job = this.findJobByCallID(callID);
+        return job?.cancellationRequested === true;
+    }
+    cancelJob(id) {
+        const job = findJobByTaskID(this.jobs, id) ?? this.findJobByAlias(id);
+        if (job) {
+            job.cancellationRequested = true;
+            this.dirty = true;
+        }
+    }
+    // -----------------------------------------------------------------------
+    // Prompt injection
+    // -----------------------------------------------------------------------
+    formatForPrompt(parentSessionID) {
+        const running = this.getRunningJobs(parentSessionID);
+        const terminal = this.getTerminalUnreconciledJobs(parentSessionID);
+        const reusable = this.getReusableJobs(parentSessionID);
+        const stale = this.getStaleJobs(parentSessionID);
+        if (running.length === 0 && terminal.length === 0 && reusable.length === 0 && stale.length === 0) {
+            return null;
+        }
+        const lines = ["[Background Job Board]"];
+        if (running.length > 0) {
+            lines.push("  Running:");
+            const now = Date.now();
+            for (const j of running) {
+                const ageMs = now - j.lastLaunchedAt;
+                const isResume = j.lastLaunchedAt !== j.launchedAt;
+                let ageLabel = "";
+                if (j.state === "running" && ageMs < 30000) {
+                    ageLabel = isResume
+                        ? ` [resumed, ${Math.floor(ageMs / 1000)}s ago]`
+                        : ` [just launched, ${Math.floor(ageMs / 1000)}s ago]`;
+                }
+                lines.push(`    - ${j.alias} task_id:${j.taskID} agent:${j.agent}${ageLabel}`);
+            }
+        }
+        if (terminal.length > 0) {
+            lines.push("  Terminal (unreconciled):");
+            for (const j of terminal) {
+                const summary = j.resultSummary ? ` — ${j.resultSummary.slice(0, 120)}` : "";
+                lines.push(`    - ${j.alias} task_id:${j.taskID} state:${j.state}${summary}`);
+                if (j.contextFiles.length > 0) {
+                    lines.push("      Context files read:");
+                    const shown = j.contextFiles.slice(0, 5);
+                    const rest = j.contextFiles.length - shown.length;
+                    const rendered = shown.map((f) => `${f.path} (${f.lineCount} lines)`);
+                    lines.push(`        ${rendered.join(", ")}${rest > 0 ? ` (+${rest} more)` : ""}`);
+                }
+            }
+            lines.push("  → Call reconcileTerminalJobs() to process these results.");
+        }
+        const injectedIDs = [...this.injectedCompletionsSeen];
+        if (injectedIDs.length > 0) {
+            lines.push("");
+            lines.push("## Injected Background Completions");
+            lines.push("The following subagent results were injected into the chat by opencode (duplicated in the job board above). Use `reconcileTerminalJobs` to acknowledge them and prevent double-response.");
+            for (const id of injectedIDs.slice(0, 10)) {
+                const job = findJobByTaskID(this.jobs, id);
+                if (job) {
+                    lines.push(`- \`${job.alias}\` — ${job.state} — ${job.resultSummary ?? "(no summary)"}`);
+                }
+            }
+        }
+        if (reusable.length > 0) {
+            lines.push("  Reusable Sessions:");
+            for (const j of reusable) {
+                lines.push(`    - ${j.alias} task_id:${j.taskID} agent:${j.agent}`);
+                if (j.contextFiles.length > 0) {
+                    lines.push("      Context files:");
+                    const shown = j.contextFiles.slice(0, 3);
+                    const rest = j.contextFiles.length - shown.length;
+                    const rendered = shown.map((f) => `${f.path} (${f.lineCount} lines)`);
+                    lines.push(`        ${rendered.join(", ")}${rest > 0 ? ` (+${rest} more)` : ""}`);
+                }
+            }
+        }
+        if (stale.length > 0) {
+            lines.push("  Stale Sessions:");
+            for (const j of stale) {
+                lines.push(`    - ${j.alias} task_id:${j.taskID} agent:${j.agent} (restart detected)`);
+            }
+        }
+        if (terminal.length > 0 || running.length > 0) {
+            lines.push("", "## Operational Guardrails");
+            lines.push("- Do not poll running jobs — wait for hook-driven background completion notifications.");
+            lines.push("- Use cancel_task only when the user asks or a running lane becomes obsolete.");
+            lines.push("- Reconcile ALL terminal jobs before your final response to the user.");
+            lines.push("- Reuse only completed sessions for the same specialist/context — never reuse cancelled or errored ones.");
+        }
+        lines.push("", "## Summary");
+        return lines.join("\n");
+    }
+    // -----------------------------------------------------------------------
+    // Dirty polling (ponytail: 1-byte state-change tracker)
+    // -----------------------------------------------------------------------
+    isDirty() {
+        return this.dirty;
+    }
+    markClean() {
+        this.dirty = false;
+    }
+    // -----------------------------------------------------------------------
+    // Mini status (ponytail: ~20 tokens, injected every round when clean)
+    // -----------------------------------------------------------------------
+    formatMini(parentSessionID) {
+        const running = this.getRunningJobs(parentSessionID);
+        const terminal = this.getTerminalUnreconciledJobs(parentSessionID);
+        if (running.length === 0 && terminal.length === 0)
+            return null;
+        let s = `Jobs: ${running.length}r/${terminal.length}u`;
+        if (terminal.length > 0)
+            s += ` | reconcileTerminalJobs()`;
+        return s;
+    }
+    // -----------------------------------------------------------------------
+    // Dedup injected completions
+    // -----------------------------------------------------------------------
+    isInjectedCompletionProcessed(id) {
+        if (this.processedCompletions.has(id))
+            return true;
+        if (this.processedCompletions.size >= MAX_INJECTED_COMPLETIONS) {
+            // Evict oldest half
+            const entries = [...this.processedCompletions];
+            this.processedCompletions = new Set(entries.slice(entries.length / 2));
+        }
+        this.processedCompletions.add(id);
+        return false;
+    }
+    markInjectedCompletionSeen(taskID) {
+        this.injectedCompletionsSeen.add(taskID);
+    }
+    // -----------------------------------------------------------------------
+    // Cleanup
+    // -----------------------------------------------------------------------
+    dropSession(sessionID) {
+        const toDelete = [];
+        for (const [key, job] of this.jobs) {
+            if (job.taskID === sessionID || job.parentSessionID === sessionID) {
+                toDelete.push(key);
+            }
+        }
+        if (toDelete.length > 0) {
+            for (const key of toDelete) {
+                this.jobs.delete(key);
+            }
+            this.dirty = true;
+        }
+    }
+    clear() {
+        this.jobs.clear();
+        this.pendingCalls = [];
+        this.agentCounter.clear();
+        this.processedCompletions.clear();
+        this.injectedCompletionsSeen.clear();
+        this.dirty = true;
+    }
+    snapshot() {
+        return {
+            jobs: [...this.jobs.values()],
+            pendingCalls: [...this.pendingCalls],
+            agentCounter: [...this.agentCounter],
+            processedCompletions: [...this.processedCompletions],
+            injectedCompletionsSeen: [...this.injectedCompletionsSeen],
+        };
+    }
+    restore(snapshot) {
+        this.clear();
+        for (const job of snapshot.jobs ?? []) {
+            const restored = { ...job };
+            if (restored.state === "running") {
+                restored.state = "stale";
+                restored.terminalUnreconciled = true;
+            }
+            this.jobs.set(restored.taskID, restored);
+        }
+        this.pendingCalls = [...(snapshot.pendingCalls ?? [])];
+        this.agentCounter = new Map(snapshot.agentCounter ?? []);
+        this.processedCompletions = new Set(snapshot.processedCompletions ?? []);
+        this.injectedCompletionsSeen = new Set(snapshot.injectedCompletionsSeen ?? []);
+        this.dirty = true;
+    }
+    get size() {
+        return this.jobs.size;
+    }
+}
+// ---------------------------------------------------------------------------
+// Singleton
+// ---------------------------------------------------------------------------
+// ponytail: single board for entire plugin lifetime.
+// Upgrade: isolate per worktree or project if concurrent sessions collide.
+export const jobBoard = new BackgroundJobBoard();

package/dist/hooks/chat-params.d.ts

@@ -0,0 +1,16 @@
+import type { Model, UserMessage } from "@opencode-ai/sdk";
+import type { ProviderContext } from "@opencode-ai/plugin";
+import type { LazyRuntime } from "./runtime.js";
+export declare function createChatParamsHook(runtime?: LazyRuntime): (input: {
+    sessionID: string;
+    agent: string;
+    model: Model;
+    provider: ProviderContext;
+    message: UserMessage;
+}, output: {
+    temperature: number;
+    topP: number;
+    topK: number;
+    maxOutputTokens: number | undefined;
+    options: Record<string, unknown>;
+}) => Promise<void>;

package/dist/hooks/chat-params.js

@@ -0,0 +1,30 @@
+/**
+ * Per-agent LLM parameter configuration.
+ * Sets temperature and other params based on agent role.
+ *
+ * ponytail: hardcoded defaults. Designer gets 0.7 for creativity, rest 0.1-0.2.
+ */
+const AGENT_TEMPERATURES = {
+    lazy: 0.1,
+    "lazy-explorer": 0.1,
+    "lazy-oracle": 0.1,
+    "lazy-librarian": 0.2,
+    "lazy-designer": 0.7,
+    "lazy-fixer": 0.2,
+    "lazy-observer": 0.1,
+};
+export function createChatParamsHook(runtime) {
+    return async (input, output) => {
+        const temp = AGENT_TEMPERATURES[input.agent] ?? 0.2;
+        output.temperature = temp;
+        const map = runtime?.sessionAgentMap;
+        if (map) {
+            map.set(input.sessionID, input.agent);
+            // Prune to prevent memory leaks
+            if (map.size > 1000) {
+                const firstKey = map.keys().next().value;
+                map.delete(firstKey);
+            }
+        }
+    };
+}

package/dist/hooks/deepwork.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Deepwork command — heavy multi-phase coding sessions.
+ *
+ * Activated by: /deepwork <task description>
+ *
+ * ponytail: command injects deepwork rules directly into the conversation
+ * as activation text. No skill file, no two-step activation.
+ */
+export declare const DEEPWORK_ACTIVATION: (task: string) => string;

package/dist/hooks/deepwork.js

@@ -0,0 +1,55 @@
+/**
+ * Deepwork command — heavy multi-phase coding sessions.
+ *
+ * Activated by: /deepwork <task description>
+ *
+ * ponytail: command injects deepwork rules directly into the conversation
+ * as activation text. No skill file, no two-step activation.
+ */
+export const DEEPWORK_ACTIVATION = (task) => `DEEPWORK MODE ACTIVE — heavy multi-phase coding session
+
+Task: ${task}
+
+## 1. Pre-work Context Gathering
+Before any planning or coding, review existing context thoroughly:
+- Read PRDs, spec issues, GitHub issues — understand the "why" before the "how"
+- Review the existing codebase: current architecture, patterns, conventions
+- Load any related design mockups, Figma links, or visual references
+- Know what's already built and what's net-new
+
+## 2. Plan Loading
+- Multi-file read with Read tool to bring all relevant files into context
+- Summarize findings in the deepwork file before starting implementation
+- Get @lazy-oracle review of the plan before Phase 1 execution begins
+
+## 3. Designer Handoff Discipline
+When @lazy-designer delivers UI/UX components:
+- @lazy-designer must explain every layout, spacing, color, typography decision
+- Use CSS comments to annotate design rationale (not just what, but WHY)
+- NO merge-squashing of designer output — cherry-pick: one component file at a time
+- Preserve design intent across later phases; @lazy-fixer only does mechanical follow-up
+- If a later phase must alter design, flag it to @lazy-designer for re-review
+
+## 4. Multiple Parallel Lanes
+- Launch two @lazy-designer lanes with different aesthetic philosophies when ambiguity exists
+- Each lane gets its own deepwork tracking slug: \`.lazy/deepwork/<task>-<lanename>.md\`
+- Compare lanes independently; @lazy-oracle picks the winning lane before merging
+
+## 5. Progress Tracking
+- Create \`.lazy/deepwork/<slug>.md\` — track goals, plans, oracle reviews, phases, blockers
+- Reference files by path, not content. Keep out of git (\`.lazy/\` is gitignored)
+- Update after every phase: what was done, what was reviewed, what's next
+- Mark each phase as ✓ COMPLETE or ⚠ BLOCKED
+
+## 6. Self-Critique After Each Check-in
+After every check-in (commit, phase completion, designer delivery):
+- @lazy-oracle: found issues → fix actionable ones immediately before continuing
+- @lazy/review: scan the diff for bugs, unnecessary complexity, deviations from plan
+- Add self-critique notes to the deepwork file — what went well, what could be tighter
+- Non-actionable critique becomes ponytail debt (note it, move on)
+
+## Exit Discipline
+- All phases ✓ COMPLETE before declaring the session done
+- Final @lazy-oracle review passes with no blocking issues
+- Deepwork file archived as session record
+- Wait for hook-driven background completion before consuming results`;

package/dist/hooks/error-recovery.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 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)
+ */
+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 createErrorRecoveryHook(runtime?: import("./runtime.js").LazyRuntime): (input: ToolAfterInput, output: ToolAfterOutput) => void;
+export {};