lazyopencode-core 0.0.1

package/dist/agents/oracle.js

@@ -0,0 +1,30 @@
+export const ORACLE_PROMPT = `<Role>
+You are a strategic technical advisor. You handle architecture decisions, complex debugging, code review, and simplification. You enforce YAGNI. You are a senior dev who has seen every over-engineered mess and been paged at 3am for one.
+</Role>
+
+## Core principles
+- **Deletion over addition.** Your first question is always: "what can we delete?"
+- **Simplest thing that works.** Not cleverest. Not most flexible. Simplest.
+- **YAGNI is law.** Speculative abstraction = technical debt, not foresight.
+- **One line verdicts.** Your review output is: finding + fix suggestion. No essays.
+
+## When you're called
+- Architecture decisions with long-term impact
+- Problems persisting after 2+ fix attempts
+- High-risk refactors
+- Costly trade-offs (performance vs maintainability)
+- Complex debugging with unclear root cause
+- Code review (load \`lazy/review\` for methodology)
+- Simplification audit (load \`lazy/simplify\` for methodology)
+
+## Output format
+1. **Verdict** (one line): what's the call?
+2. **Why** (max 3 lines): critical reasoning only
+3. **What to do** (minimal diff): the change, not the explanation
+
+## Anti-patterns you kill on sight
+- Interface with one implementation
+- Factory for one product
+- Config for a value that never changes
+- "We might need this later"
+- Clever code that someone decodes at 3am`;

package/dist/council/council-manager.d.ts

@@ -0,0 +1,42 @@
+interface CouncilConfig {
+    enabled?: boolean;
+    eligibility?: "guarded" | "always";
+    default_preset?: string;
+    timeout?: number;
+    execution_mode?: "parallel" | "serial";
+    retries?: number;
+    maxCouncillors?: number;
+    presets?: Record<string, Record<string, {
+        model?: string;
+        prompt?: string;
+    }>>;
+}
+interface RequiredCouncilConfig {
+    enabled: boolean;
+    eligibility: "guarded" | "always";
+    default_preset: string;
+    timeout: number;
+    execution_mode: "parallel" | "serial";
+    retries: number;
+    maxCouncillors: number;
+    presets: Record<string, Record<string, {
+        model: string;
+        prompt?: string;
+    }>>;
+}
+interface CouncillorResult {
+    name: string;
+    status: "success" | "error" | "timeout";
+    result?: string;
+    error?: string;
+}
+interface CouncilOutput {
+    success: boolean;
+    error?: string;
+    councillorResults: CouncillorResult[];
+    formatted: string;
+}
+export declare function defaultCouncilConfig(overrides?: CouncilConfig): RequiredCouncilConfig;
+export declare function runCouncil(prompt: string, client: any, councilConfig: RequiredCouncilConfig, presetName?: string, parentSessionId?: string, abortSignal?: AbortSignal): Promise<CouncilOutput>;
+export declare function formatResults(prompt: string, results: CouncillorResult[]): string;
+export type { CouncilConfig, CouncillorResult, CouncilOutput, RequiredCouncilConfig };

package/dist/council/council-manager.js

@@ -0,0 +1,223 @@
+export function defaultCouncilConfig(overrides) {
+    const presets = {
+        default: {
+            councillor: { model: "", prompt: undefined },
+        },
+    };
+    if (overrides?.presets) {
+        for (const [name, councillors] of Object.entries(overrides.presets)) {
+            const resolved = {};
+            for (const [key, val] of Object.entries(councillors)) {
+                resolved[key] = { model: val.model ?? "", prompt: val.prompt };
+            }
+            presets[name] = resolved;
+        }
+    }
+    return {
+        enabled: overrides?.enabled ?? true,
+        eligibility: overrides?.eligibility ?? "guarded",
+        default_preset: overrides?.default_preset ?? "default",
+        timeout: overrides?.timeout ?? 180_000,
+        execution_mode: overrides?.execution_mode ?? "parallel",
+        retries: overrides?.retries ?? 2,
+        maxCouncillors: overrides?.maxCouncillors ?? 3,
+        presets,
+    };
+}
+function parseModel(modelStr) {
+    if (!modelStr)
+        return null;
+    const slash = modelStr.indexOf("/");
+    if (slash === -1)
+        return null;
+    return { providerID: modelStr.slice(0, slash), modelID: modelStr.slice(slash + 1) };
+}
+export async function runCouncil(prompt, 
+// deno-lint-ignore no-explicit-any
+client, councilConfig, presetName, parentSessionId, abortSignal) {
+    if (abortSignal?.aborted) {
+        return { success: false, error: "Council aborted", councillorResults: [], formatted: "" };
+    }
+    if (!councilConfig.enabled) {
+        return {
+            success: false,
+            error: "Council is disabled by config",
+            councillorResults: [],
+            formatted: "",
+        };
+    }
+    const presetNameResolved = presetName ?? councilConfig.default_preset;
+    const preset = councilConfig.presets[presetNameResolved];
+    if (!preset) {
+        return {
+            success: false,
+            error: `Council preset "${presetNameResolved}" not found`,
+            councillorResults: [],
+            formatted: "",
+        };
+    }
+    const entries = Object.entries(preset);
+    if (entries.length === 0) {
+        return {
+            success: false,
+            error: "No councillors in preset",
+            councillorResults: [],
+            formatted: "",
+        };
+    }
+    if (entries.length > councilConfig.maxCouncillors) {
+        return {
+            success: false,
+            error: `Council preset "${presetNameResolved}" has ${entries.length} councillors, exceeding maxCouncillors ${councilConfig.maxCouncillors}`,
+            councillorResults: [],
+            formatted: "",
+        };
+    }
+    const runOne = async (name, modelStr, SystemPrompt) => {
+        if (abortSignal?.aborted) {
+            return { name, status: "error", error: "Aborted" };
+        }
+        const system = SystemPrompt ??
+            "You are a member of a coding council. Provide independent analysis. Be concise. Cite evidence.";
+        const model = parseModel(modelStr);
+        let sessionId;
+        try {
+            const createRes = await client.session.create({
+                body: { parentID: parentSessionId, title: `council: ${name}` },
+            });
+            if (createRes.error) {
+                return {
+                    name,
+                    status: "error",
+                    error: `Session creation failed: ${JSON.stringify(createRes.error)}`,
+                };
+            }
+            sessionId = createRes.data.id;
+            const promptRes = await client.session.prompt({
+                body: {
+                    agent: "lazy-councillor",
+                    ...(model ? { model } : {}),
+                    ...(system ? { system } : {}),
+                    parts: [{ type: "text", text: prompt }],
+                    tools: { read: true, glob: true, grep: true, list: true },
+                },
+                path: { id: sessionId },
+            });
+            if (promptRes.error) {
+                return { name, status: "error", error: `Prompt failed: ${JSON.stringify(promptRes.error)}` };
+            }
+            // deno-lint-ignore no-explicit-any
+            const textParts = (promptRes.data.parts ?? []).filter((p) => p.type === "text");
+            // deno-lint-ignore no-explicit-any
+            const result = textParts.map((p) => p.text).join("\n");
+            return { name, status: "success", result };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return { name, status: "error", error: message };
+        }
+        finally {
+            if (sessionId) {
+                client.session.delete({ path: { id: sessionId } }).catch((err) => {
+                    console.error("[council] failed to cleanup session:", err);
+                });
+            }
+        }
+    };
+    const startTime = Date.now();
+    const timeoutMs = councilConfig.timeout;
+    const runAll = async () => {
+        if (abortSignal?.aborted) {
+            return entries.map(([name]) => ({ name, status: "error", error: "Aborted" }));
+        }
+        if (councilConfig.execution_mode === "serial") {
+            const results = [];
+            for (const [name, config] of entries) {
+                if (abortSignal?.aborted) {
+                    results.push({ name, status: "error", error: "Aborted" });
+                    break;
+                }
+                if (Date.now() - startTime >= timeoutMs) {
+                    results.push({ name, status: "timeout", error: "Serial execution timeout" });
+                    break;
+                }
+                results.push(await runOne(name, config.model, config.prompt));
+            }
+            return results;
+        }
+        const promises = entries.map(([name, config]) => runOne(name, config.model, config.prompt));
+        let timeoutHandle;
+        const timeoutPromise = new Promise((resolve) => {
+            timeoutHandle = setTimeout(() => resolve("timeout"), timeoutMs);
+        });
+        const raceResult = await Promise.race([Promise.allSettled(promises), timeoutPromise]);
+        if (timeoutHandle)
+            clearTimeout(timeoutHandle);
+        if (raceResult === "timeout") {
+            return entries.map(([name]) => ({
+                name,
+                status: "timeout",
+                error: "Council timeout exceeded",
+            }));
+        }
+        return raceResult.map((r, i) => {
+            if (r.status === "fulfilled")
+                return r.value;
+            const entry = entries[i];
+            if (!entry) {
+                return { name: "unknown", status: "error", error: "Unknown error" };
+            }
+            return {
+                name: entry[0],
+                status: "error",
+                error: r.reason?.message ?? "Unknown error",
+            };
+        });
+    };
+    const results = await runAll();
+    for (let attempt = 0; attempt < councilConfig.retries; attempt++) {
+        if (abortSignal?.aborted)
+            break;
+        const failed = [];
+        for (let i = 0; i < results.length; i++) {
+            const r = results[i];
+            if (r.status !== "success" || !r.result?.trim()) {
+                failed.push(i);
+            }
+        }
+        if (failed.length === 0)
+            break;
+        if (Date.now() - startTime >= timeoutMs)
+            break;
+        const retryEntries = failed.map((i) => entries[i]);
+        const retryPromises = retryEntries.map(([name, config]) => runOne(name, config.model, config.prompt));
+        const retryResults = await Promise.allSettled(retryPromises);
+        for (let j = 0; j < failed.length; j++) {
+            const rr = retryResults[j];
+            if (rr.status === "fulfilled")
+                results[failed[j]] = rr.value;
+        }
+    }
+    const formatted = formatResults(prompt, results);
+    const allSuccess = results.every((r) => r.status === "success");
+    return { success: allSuccess, councillorResults: results, formatted };
+}
+export function formatResults(prompt, results) {
+    const lines = [
+        `# Council Results\n`,
+        `Councillors: ${results.length}`,
+        `Estimated model calls: ${results.length}\n`,
+        `## Question\n${prompt}\n`,
+    ];
+    for (const r of results) {
+        lines.push(`## ${r.name}`);
+        lines.push(`Status: ${r.status}`);
+        if (r.error)
+            lines.push(`Error: ${r.error}`);
+        if (r.result)
+            lines.push(r.result);
+        lines.push("");
+    }
+    lines.push("## Synthesis Required\nReview each councillor's response above and synthesize a final recommendation.");
+    return lines.join("\n");
+}

package/dist/council/index.d.ts

@@ -0,0 +1,2 @@
+export { defaultCouncilConfig, formatResults, runCouncil } from "./council-manager.js";
+export type { CouncilConfig, CouncillorResult, CouncilOutput, RequiredCouncilConfig, } from "./council-manager.js";

package/dist/council/index.js

@@ -0,0 +1 @@
+export { defaultCouncilConfig, formatResults, runCouncil } from "./council-manager.js";

package/dist/hooks/apply-patch-rescue.d.ts

@@ -0,0 +1,7 @@
+export declare function createApplyPatchRescueHook(): (input: {
+    tool: string;
+    sessionID: string;
+    callID: string;
+}, output: {
+    args: Record<string, unknown>;
+}) => Promise<void>;

package/dist/hooks/apply-patch-rescue.js

@@ -0,0 +1,150 @@
+/**
+ * Hunk offset fixup — rescues apply_patch when the LLM hallucinates line numbers.
+ * ponytail: prefix/suffix context matching via substring containment, no full diff parser.
+ */
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+export function createApplyPatchRescueHook() {
+    return async (input, output) => {
+        if (input.tool !== "apply_patch")
+            return;
+        const args = output.args;
+        const filePath = args?.file_path;
+        const patchContent = args?.content;
+        if (!filePath || !patchContent)
+            return;
+        if (!existsSync(filePath))
+            return;
+        let fileContents;
+        try {
+            fileContents = await readFile(filePath, "utf-8");
+        }
+        catch {
+            return;
+        }
+        const fileLines = fileContents.split("\n");
+        const fixedPatch = fixHunkOffsets(patchContent, fileLines);
+        if (fixedPatch !== patchContent) {
+            output.args = { ...args, content: fixedPatch };
+        }
+    };
+}
+// ---------------------------------------------------------------------------
+// Hunk offset fixup
+// ---------------------------------------------------------------------------
+function fixHunkOffsets(patchContent, fileLines) {
+    const lines = patchContent.split("\n");
+    const hunkHeaders = lines.filter((line) => line.startsWith("@@")).length;
+    if (hunkHeaders !== 1)
+        return patchContent;
+    const result = [];
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        const hunkMatch = line.match(/^@@ -(\d+),(\d+) \+(\d+),(\d+) @@\s*(.*)/);
+        if (!hunkMatch) {
+            result.push(line);
+            i++;
+            continue;
+        }
+        const oldStart = parseInt(hunkMatch[1], 10);
+        const oldCount = hunkMatch[2];
+        const newStart = parseInt(hunkMatch[3], 10);
+        const newCount = hunkMatch[4];
+        const section = hunkMatch[5];
+        if (oldStart !== newStart)
+            return patchContent;
+        // Collect hunk body — lines between header and next @@ or EOF
+        const bodyLines = [];
+        i++;
+        while (i < lines.length && !lines[i].startsWith("@@")) {
+            bodyLines.push(lines[i]);
+            i++;
+        }
+        if (bodyLines.length === 0) {
+            result.push(line);
+            continue;
+        }
+        const adjustedStart = findBestMatch(fileLines, bodyLines, oldStart);
+        if (adjustedStart === -1) {
+            // No match — leave hunk alone
+            result.push(line);
+            result.push(...bodyLines);
+            continue;
+        }
+        const header = `@@ -${adjustedStart},${oldCount} +${adjustedStart},${newCount} @@` +
+            (section ? ` ${section}` : "");
+        result.push(header);
+        result.push(...bodyLines);
+    }
+    return result.join("\n");
+}
+// ---------------------------------------------------------------------------
+// Context matching
+// ---------------------------------------------------------------------------
+function findBestMatch(fileLines, hunkBody, estLine) {
+    const prefix = getFirstContextLine(hunkBody);
+    const suffix = getLastContextLine(hunkBody);
+    // Try prefix first
+    if (prefix) {
+        const match = findLineNear(fileLines, prefix, estLine);
+        if (match !== -1)
+            return match;
+    }
+    // Try suffix if different from prefix
+    if (suffix && suffix !== prefix) {
+        const match = findLineNear(fileLines, suffix, estLine);
+        if (match !== -1)
+            return match;
+    }
+    return -1;
+}
+/**
+ * First non-empty line in hunk body that is context (not + or - prefixed).
+ */
+function getFirstContextLine(body) {
+    for (const line of body) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        if (trimmed.startsWith("+") || trimmed.startsWith("-"))
+            continue;
+        return trimmed;
+    }
+    return null;
+}
+/**
+ * Last non-empty line in hunk body that is context (not + or - prefixed).
+ */
+function getLastContextLine(body) {
+    for (let i = body.length - 1; i >= 0; i--) {
+        const trimmed = body[i].trim();
+        if (!trimmed)
+            continue;
+        if (trimmed.startsWith("+") || trimmed.startsWith("-"))
+            continue;
+        return trimmed;
+    }
+    return null;
+}
+/**
+ * Search +/- 50 lines of estLine (1-indexed) for a line containing `search`.
+ * Returns 1-indexed line number or -1.
+ */
+function findLineNear(fileLines, search, estLine) {
+    const estLine0 = estLine - 1;
+    const searchStart = Math.max(0, estLine0 - 50);
+    const searchEnd = Math.min(fileLines.length, estLine0 + 50);
+    let bestIndex = -1;
+    let bestDist = Infinity;
+    for (let i = searchStart; i < searchEnd; i++) {
+        if (fileLines[i].trim() === search.trim() || fileLines[i].includes(search)) {
+            const dist = Math.abs(i - estLine0);
+            if (dist < bestDist) {
+                bestDist = dist;
+                bestIndex = i;
+            }
+        }
+    }
+    return bestIndex === -1 ? -1 : bestIndex + 1;
+}

package/dist/hooks/background-job-board.d.ts

@@ -0,0 +1,92 @@
+/**
+ * BackgroundJobBoard — in-memory state machine for subagent task tracking.
+ *
+ * ponytail: global singletons, no DI. Upgrade: per-session isolation if starvation occurs.
+ */
+export type JobState = "running" | "completed" | "error" | "cancelled" | "reconciled" | "stale";
+export interface ContextFile {
+    path: string;
+    lineCount: number;
+}
+export interface BackgroundJobRecord {
+    taskID: string;
+    parentSessionID: string;
+    agent: string;
+    state: JobState;
+    terminalUnreconciled: boolean;
+    timedOut: boolean;
+    cancellationRequested: boolean;
+    alias: string;
+    callID: string;
+    resultSummary?: string;
+    contextFiles: ContextFile[];
+    launchedAt: number;
+    lastLaunchedAt: number;
+    lastUsedAt: number;
+    updatedAt: number;
+    completedAt: number;
+}
+export declare class BackgroundJobBoard {
+    private jobs;
+    private pendingCalls;
+    private agentCounter;
+    private processedCompletions;
+    private injectedCompletionsSeen;
+    private maxReusablePerAgent;
+    private dirty;
+    constructor(options?: {
+        maxReusablePerAgent?: number;
+    });
+    configure(options: {
+        maxReusablePerAgent?: number;
+    }): void;
+    registerLaunch(parentSessionID: string, agent: string, callID: string): BackgroundJobRecord;
+    findJobByCallID(callID: string): BackgroundJobRecord | undefined;
+    findJobByTaskID(taskID: string): BackgroundJobRecord | undefined;
+    findJobByAlias(alias: string): BackgroundJobRecord | undefined;
+    updateStatus(callID: string, taskID: string, state: JobState, resultSummary?: string): void;
+    addContext(taskID: string, file: ContextFile): void;
+    markReconciled(taskID: string): void;
+    trimReusable(taskID: string): void;
+    getTerminalUnreconciledJobs(parentSessionID: string): BackgroundJobRecord[];
+    getRunningJobs(parentSessionID: string): BackgroundJobRecord[];
+    getStaleJobs(parentSessionID: string): BackgroundJobRecord[];
+    getReusableJobs(parentSessionID: string): BackgroundJobRecord[];
+    resolveReusable(parentSessionID: string, agent: string): BackgroundJobRecord | undefined;
+    getReusableJob(taskID: string): BackgroundJobRecord | undefined;
+    getActiveCount(parentSessionID: string, agent: string): number;
+    isLateCancelledTaskError(callID: string): boolean;
+    cancelJob(id: string): void;
+    formatForPrompt(parentSessionID: string): string | null;
+    isDirty(): boolean;
+    markClean(): void;
+    formatMini(parentSessionID: string): string | null;
+    isInjectedCompletionProcessed(id: string): boolean;
+    markInjectedCompletionSeen(taskID: string): void;
+    dropSession(sessionID: string): void;
+    clear(): void;
+    snapshot(): {
+        jobs: BackgroundJobRecord[];
+        pendingCalls: Array<{
+            callID: string;
+            sessionID: string;
+            alias?: string;
+        }>;
+        agentCounter: Array<[string, number]>;
+        processedCompletions: string[];
+        injectedCompletionsSeen: string[];
+    };
+    restore(snapshot: {
+        jobs?: BackgroundJobRecord[];
+        pendingCalls?: Array<{
+            callID: string;
+            sessionID: string;
+            alias?: string;
+        }>;
+        agentCounter?: Array<[string, number]>;
+        processedCompletions?: string[];
+        injectedCompletionsSeen?: string[];
+    }): void;
+    get size(): number;
+}
+export declare const jobBoard: BackgroundJobBoard;