opencode-autognosis 1.0.0 → 2.0.0

package/dist/git-worktree.js

@@ -0,0 +1,384 @@
+import { tool } from "@opencode-ai/plugin";
+import { exec } from "node:child_process";
+import * as fs from "node:fs/promises";
+import * as fsSync from "node:fs";
+import * as path from "node:path";
+import { promisify } from "node:util";
+import * as crypto from "node:crypto";
+const execAsync = promisify(exec);
+const PROJECT_ROOT = process.cwd();
+const OPENCODE_DIR = path.join(PROJECT_ROOT, ".opencode");
+const WORKTREE_DIR = path.join(OPENCODE_DIR, "worktrees");
+// Internal logging
+function log(message, data) {
+    console.error(`[GitWorktree] ${message}`, data || '');
+}
+// =============================================================================
+// HELPERS
+// =============================================================================
+async function runCmd(cmd, cwd = PROJECT_ROOT, timeoutMs = 30000) {
+    try {
+        const { stdout, stderr } = await execAsync(cmd, {
+            cwd,
+            maxBuffer: 10 * 1024 * 1024,
+            timeout: timeoutMs
+        });
+        return { stdout: stdout.trim(), stderr: stderr.trim() };
+    }
+    catch (error) {
+        if (error.signal === 'SIGTERM' && error.code === undefined) {
+            return { stdout: "", stderr: `Command timed out after ${timeoutMs}ms`, error, timedOut: true };
+        }
+        return { stdout: "", stderr: error instanceof Error ? error.message : `${error}`, error };
+    }
+}
+async function ensureWorktreeDir() {
+    await fs.mkdir(WORKTREE_DIR, { recursive: true });
+}
+async function getGitState() {
+    const { stdout: head } = await runCmd("git rev-parse HEAD");
+    const { stdout: branch } = await runCmd("git rev-parse --abbrev-ref HEAD");
+    const { stdout: status } = await runCmd("git status --porcelain");
+    const { stdout: remotes } = await runCmd("git remote");
+    return {
+        head,
+        branch,
+        isDirty: status.length > 0,
+        statusLines: status.split('\n').filter(Boolean),
+        remotes: remotes.split('\n').filter(Boolean),
+        isMainBranch: branch === "main" || branch === "master"
+    };
+}
+async function discoverWorktrees() {
+    await ensureWorktreeDir();
+    try {
+        const worktrees = await fs.readdir(WORKTREE_DIR);
+        const results = [];
+        for (const worktree of worktrees) {
+            const worktreePath = path.join(WORKTREE_DIR, worktree);
+            const stat = await fs.stat(worktreePath);
+            if (stat.isDirectory()) {
+                const gitDir = path.join(worktreePath, ".git");
+                if (fsSync.existsSync(gitDir)) {
+                    const { stdout: branch } = await runCmd("git rev-parse --abbrev-ref HEAD", worktreePath);
+                    const { stdout: head } = await runCmd("git rev-parse HEAD", worktreePath);
+                    const { stdout: status } = await runCmd("git status --porcelain", worktreePath);
+                    results.push({
+                        name: worktree,
+                        path: worktreePath,
+                        branch,
+                        head,
+                        isDirty: status.length > 0,
+                        statusLines: status.split('\n').filter(Boolean)
+                    });
+                }
+            }
+        }
+        return results;
+    }
+    catch (error) {
+        return [];
+    }
+}
+// =============================================================================
+// AGENT CONTRACT INTEGRATION
+// =============================================================================
+const AGENT_USAGE_POLICY = `
+AGENT USAGE POLICY:
+- Use git.preflight before any repository operations
+- Create checkpoints with git.checkpoint_create for clean session starts
+- Work in integration branches, never directly on main/master
+- Validate all patches before application
+- Clean up worktrees after completion to avoid resource leaks
+`.trim();
+const WORKFLOW_PATTERNS = `
+STANDARD WORKFLOW:
+1. git.preflight -> Validate repository state
+2. git.checkpoint_create -> Create clean starting point
+3. Work in feature/integration branch
+4. git.validate_patch -> Verify changes before commit
+5. Clean up worktrees and finalize
+`.trim();
+// =============================================================================
+// GIT WORKTREE MANAGEMENT TOOLS
+// =============================================================================
+export function gitWorktreeTools() {
+    return {
+        git_preflight: tool({
+            description: `Validate repository state and check prerequisites for Git operations. ${AGENT_USAGE_POLICY} Returns comprehensive repository status including branch state, cleanliness, and available worktrees.`,
+            args: {
+                strict: tool.schema.boolean().optional().default(false).describe("Enable strict validation mode")
+            },
+            async execute({ strict }) {
+                log("Tool call: git_preflight", { strict });
+                try {
+                    const state = await getGitState();
+                    const worktrees = await discoverWorktrees();
+                    const issues = [];
+                    const warnings = [];
+                    // Check for dirty working directory
+                    if (state.isDirty) {
+                        if (strict) {
+                            issues.push("Working directory is dirty - commit or stash changes");
+                        }
+                        else {
+                            warnings.push("Working directory is dirty");
+                        }
+                    }
+                    // Check for main branch
+                    if (state.isMainBranch && state.isDirty) {
+                        issues.push("Never work directly on main/master branch with uncommitted changes");
+                    }
+                    // Check for worktree conflicts
+                    const conflictingWorktrees = worktrees.filter(w => w.branch === state.branch);
+                    if (conflictingWorktrees.length > 0) {
+                        warnings.push(`Branch '${state.branch}' is checked out in ${conflictingWorktrees.length} worktree(s)`);
+                    }
+                    // Check for git availability
+                    const { error: gitError } = await runCmd("git --version");
+                    if (gitError) {
+                        issues.push("Git is not available or not in PATH");
+                    }
+                    const result = {
+                        status: issues.length > 0 ? "FAILED" : warnings.length > 0 ? "WARNING" : "OK",
+                        repository: {
+                            head: state.head,
+                            branch: state.branch,
+                            isDirty: state.isDirty,
+                            isMainBranch: state.isMainBranch,
+                            statusLines: state.statusLines,
+                            remotes: state.remotes
+                        },
+                        worktrees: {
+                            discovered: worktrees,
+                            count: worktrees.length
+                        },
+                        validation: {
+                            issues,
+                            warnings,
+                            strict
+                        },
+                        workflow: WORKFLOW_PATTERNS
+                    };
+                    return JSON.stringify(result, null, 2);
+                }
+                catch (error) {
+                    return JSON.stringify({
+                        status: "ERROR",
+                        message: error instanceof Error ? error.message : `${error}`,
+                        workflow: WORKFLOW_PATTERNS
+                    }, null, 2);
+                }
+            }
+        }),
+        git_checkpoint_create: tool({
+            description: `Create a clean checkpoint for starting a new work session. ${AGENT_USAGE_POLICY} Creates a deterministic integration branch and optional worktree for isolated work.`,
+            args: {
+                branch_name: tool.schema.string().optional().describe("Custom branch name (auto-generated if not provided)"),
+                create_worktree: tool.schema.boolean().optional().default(true).describe("Create isolated worktree for the branch"),
+                message: tool.schema.string().optional().default("Agent checkpoint").describe("Checkpoint commit message")
+            },
+            async execute({ branch_name, create_worktree, message }) {
+                log("Tool call: git_checkpoint_create", { branch_name, create_worktree, message });
+                try {
+                    const state = await getGitState();
+                    // Generate branch name if not provided
+                    const targetBranch = branch_name || `agent-integration-${Date.now()}`;
+                    // Ensure we're on a clean state
+                    if (state.isDirty) {
+                        return JSON.stringify({
+                            status: "ERROR",
+                            message: "Cannot create checkpoint from dirty working directory. Commit or stash changes first.",
+                            current_state: state
+                        }, null, 2);
+                    }
+                    // Create and checkout new branch
+                    const { error: branchError } = await runCmd(`git checkout -b ${targetBranch}`);
+                    if (branchError) {
+                        return JSON.stringify({
+                            status: "ERROR",
+                            message: `Failed to create branch: ${branchError instanceof Error ? branchError.message : `${branchError}`}`,
+                            current_state: state
+                        }, null, 2);
+                    }
+                    // Create initial commit if needed
+                    const { stdout: log } = await runCmd("git log --oneline -1");
+                    if (!log || log.includes("Initial commit")) {
+                        await runCmd(`git commit --allow-empty -m "${message}"`);
+                    }
+                    let worktreePath = null;
+                    if (create_worktree) {
+                        await ensureWorktreeDir();
+                        worktreePath = path.join(WORKTREE_DIR, targetBranch.replace(/[^a-zA-Z0-9-_]/g, '-'));
+                        // Remove existing worktree if it exists
+                        if (fsSync.existsSync(worktreePath)) {
+                            const { error: removeError } = await runCmd(`git worktree remove ${worktreePath}`);
+                            if (removeError) {
+                                console.error("[GitWorktree] Warning: Failed to remove existing worktree", removeError);
+                            }
+                        }
+                        // Create new worktree
+                        const { error: worktreeError } = await runCmd(`git worktree add ${worktreePath} ${targetBranch}`);
+                        if (worktreeError) {
+                            return JSON.stringify({
+                                status: "WARNING",
+                                message: `Branch created but worktree failed: ${worktreeError instanceof Error ? worktreeError.message : `${worktreeError}`}`,
+                                checkpoint: {
+                                    branch: targetBranch,
+                                    head: state.head,
+                                    created_at: new Date().toISOString()
+                                }
+                            }, null, 2);
+                        }
+                    }
+                    const result = {
+                        status: "SUCCESS",
+                        checkpoint: {
+                            branch: targetBranch,
+                            head: state.head,
+                            created_at: new Date().toISOString(),
+                            message
+                        },
+                        worktree: worktreePath ? {
+                            path: worktreePath,
+                            branch: targetBranch
+                        } : null,
+                        next_steps: [
+                            `Work in branch: ${targetBranch}`,
+                            worktreePath ? `Use worktree: ${worktreePath}` : "Work in main repository",
+                            "Validate patches before applying",
+                            "Clean up worktree when done"
+                        ]
+                    };
+                    return JSON.stringify(result, null, 2);
+                }
+                catch (error) {
+                    return JSON.stringify({
+                        status: "ERROR",
+                        message: error instanceof Error ? error.message : `${error}`
+                    }, null, 2);
+                }
+            }
+        }),
+        git_worktree_status: tool({
+            description: "Discover and report status of all worktrees. Returns detailed information about active worktrees, their branches, and cleanliness.",
+            args: {
+                include_clean: tool.schema.boolean().optional().default(false).describe("Include clean worktrees in results")
+            },
+            async execute({ include_clean }) {
+                log("Tool call: git_worktree_status", { include_clean });
+                try {
+                    const worktrees = await discoverWorktrees();
+                    const state = await getGitState();
+                    let filteredWorktrees = worktrees;
+                    if (!include_clean) {
+                        filteredWorktrees = worktrees.filter(w => w.isDirty || w.branch === state.branch);
+                    }
+                    const result = {
+                        status: "OK",
+                        current_repository: {
+                            branch: state.branch,
+                            head: state.head,
+                            isDirty: state.isDirty
+                        },
+                        worktrees: {
+                            total: worktrees.length,
+                            filtered: filteredWorktrees.length,
+                            active: filteredWorktrees.map(w => ({
+                                name: w.name,
+                                path: w.path,
+                                branch: w.branch,
+                                head: w.head,
+                                isDirty: w.isDirty,
+                                status_summary: `${w.isDirty ? 'DIRTY' : 'CLEAN'} - ${w.branch}`
+                            }))
+                        },
+                        recommendations: [
+                            "Clean up unused worktrees to free resources",
+                            "Avoid multiple worktrees on the same branch",
+                            "Use git.checkpoint_create for new clean workspaces"
+                        ]
+                    };
+                    return JSON.stringify(result, null, 2);
+                }
+                catch (error) {
+                    return JSON.stringify({
+                        status: "ERROR",
+                        message: error instanceof Error ? error.message : `${error}`
+                    }, null, 2);
+                }
+            }
+        }),
+        git_worktree_cleanup: tool({
+            description: `Clean up worktrees to free resources. ${AGENT_USAGE_POLICY} Removes specified worktrees after ensuring no uncommitted changes will be lost.`,
+            args: {
+                worktree_names: tool.schema.array(tool.schema.string()).optional().describe("Specific worktree names to clean up (cleans all if not specified)"),
+                force: tool.schema.boolean().optional().default(false).describe("Force cleanup even with uncommitted changes (not recommended)")
+            },
+            async execute({ worktree_names, force }) {
+                log("Tool call: git_worktree_cleanup", { worktree_names, force });
+                try {
+                    const worktrees = await discoverWorktrees();
+                    let targetWorktrees = worktrees;
+                    if (worktree_names && worktree_names.length > 0) {
+                        targetWorktrees = worktrees.filter(w => worktree_names.includes(w.name));
+                        if (targetWorktrees.length === 0) {
+                            return JSON.stringify({
+                                status: "WARNING",
+                                message: "No matching worktrees found",
+                                requested: worktree_names,
+                                available: worktrees.map(w => w.name)
+                            }, null, 2);
+                        }
+                    }
+                    const cleanupResults = [];
+                    const warnings = [];
+                    for (const worktree of targetWorktrees) {
+                        if (worktree.isDirty && !force) {
+                            warnings.push(`Skipping dirty worktree: ${worktree.name} (${worktree.branch})`);
+                            continue;
+                        }
+                        try {
+                            // Remove worktree
+                            const { error: removeError } = await runCmd(`git worktree remove ${worktree.path}`);
+                            if (removeError) {
+                                warnings.push(`Failed to remove ${worktree.name}: ${removeError instanceof Error ? removeError.message : `${removeError}`}`);
+                                continue;
+                            }
+                            // Remove directory if it still exists
+                            if (fsSync.existsSync(worktree.path)) {
+                                await fs.rm(worktree.path, { recursive: true, force: true });
+                            }
+                            cleanupResults.push({
+                                name: worktree.name,
+                                path: worktree.path,
+                                branch: worktree.branch,
+                                status: "REMOVED"
+                            });
+                        }
+                        catch (error) {
+                            warnings.push(`Error cleaning up ${worktree.name}: ${error instanceof Error ? error.message : `${error}`}`);
+                        }
+                    }
+                    const result = {
+                        status: warnings.length > 0 ? "PARTIAL" : "SUCCESS",
+                        cleaned_up: cleanupResults,
+                        warnings,
+                        summary: {
+                            processed: targetWorktrees.length,
+                            removed: cleanupResults.length,
+                            warnings: warnings.length
+                        }
+                    };
+                    return JSON.stringify(result, null, 2);
+                }
+                catch (error) {
+                    return JSON.stringify({
+                        status: "ERROR",
+                        message: error instanceof Error ? error.message : `${error}`
+                    }, null, 2);
+                }
+            }
+        })
+    };
+}

package/dist/index.d.ts

@@ -1,3 +1,5 @@
-import { type Plugin } from "@opencode-ai/plugin";
-export declare const AutognosisPlugin: Plugin;
-export default AutognosisPlugin;
+export default function plugin(): {
+    tools: {
+        [key: string]: any;
+    };
+};

package/dist/index.js

@@ -1,235 +1,20 @@
-import { tool } from "@opencode-ai/plugin";
-import { exec } from "node:child_process";
-import * as fs from "node:fs/promises";
-import * as fsSync from "node:fs";
-import * as path from "node:path";
-import { promisify } from "node:util";
-import * as crypto from "node:crypto";
-const execAsync = promisify(exec);
-const PROJECT_ROOT = process.cwd();
-const OPENCODE_DIR = path.join(PROJECT_ROOT, ".opencode");
-const CACHE_DIR = path.join(OPENCODE_DIR, "cache");
-async function runCmd(cmd, cwd = PROJECT_ROOT, timeoutMs = 30000) {
-    try {
-        const { stdout, stderr } = await execAsync(cmd, {
-            cwd,
-            maxBuffer: 10 * 1024 * 1024,
-            timeout: timeoutMs
-        });
-        return { stdout: stdout.trim(), stderr: stderr.trim() };
-    }
-    catch (error) {
-        if (error.signal === 'SIGTERM' && error.code === undefined) {
-            return { stdout: "", stderr: `Command timed out after ${timeoutMs}ms`, error, timedOut: true };
-        }
-        return { stdout: "", stderr: error.message, error };
-    }
-}
-async function checkBinary(bin) {
-    const { error } = await runCmd(`${bin} --version`, PROJECT_ROOT, 5000);
-    return !error;
-}
-async function ensureCache() {
-    await fs.mkdir(CACHE_DIR, { recursive: true });
-}
-async function cleanCache() {
-    try {
-        const files = await fs.readdir(CACHE_DIR);
-        const now = Date.now();
-        const MAX_AGE = 7 * 24 * 60 * 60 * 1000;
-        let deleted = 0;
-        for (const file of files) {
-            const filePath = path.join(CACHE_DIR, file);
-            const stats = await fs.stat(filePath);
-            if (now - stats.mtimeMs > MAX_AGE) {
-                await fs.unlink(filePath);
-                deleted++;
-            }
-        }
-        return deleted;
-    }
-    catch (e) {
-        return 0;
-    }
-}
-async function maintainSymbolIndex() {
-    await ensureCache();
-    if (!(await checkBinary("ctags"))) {
-        return { rebuilt: false, status: "unavailable", reason: "ctags binary missing" };
-    }
-    const tagsFile = path.join(CACHE_DIR, "tags");
-    const fingerprintFile = path.join(CACHE_DIR, "tags.fingerprint");
-    const { stdout: head } = await runCmd("git rev-parse HEAD");
-    const { stdout: status } = await runCmd("git status --porcelain");
-    const currentFingerprint = `${head}\n${status}`;
-    let storedFingerprint = "";
-    try {
-        storedFingerprint = await fs.readFile(fingerprintFile, "utf-8");
-    }
-    catch (e) { }
-    if (currentFingerprint !== storedFingerprint || !fsSync.existsSync(tagsFile)) {
-        const { error, stderr } = await runCmd(`ctags -R -f ${tagsFile} --languages=TypeScript,JavaScript,Python,Go,Rust,C++,C .`, PROJECT_ROOT);
-        if (error) {
-            return { rebuilt: false, status: "failed", reason: stderr };
-        }
-        await fs.writeFile(fingerprintFile, currentFingerprint);
-        return { rebuilt: true, status: "ok" };
-    }
-    return { rebuilt: false, status: "ok" };
-}
-export const AutognosisPlugin = async (_ctx) => {
-    let pendingInitToken = null;
+import { systemTools } from "./system-tools.js";
+import { gitWorktreeTools } from "./git-worktree.js";
+import { testingTools } from "./testing-infrastructure.js";
+import { chunkCardsTools } from "./chunk-cards.js";
+import { activeSetTools } from "./activeset.js";
+import { moduleSummariesTools } from "./module-summaries.js";
+import { performanceTools } from "./performance-optimization.js";
+export default function plugin() {
     return {
-        tool: {
-            autognosis_init: tool({
-                description: "Initialize the Autognosis environment.",
-                args: {
-                    mode: tool.schema.enum(["plan", "apply"]).optional().default("plan"),
-                    token: tool.schema.string().optional()
-                },
-                async execute({ mode, token }) {
-                    if (mode === "plan") {
-                        const checks = { rg: await checkBinary("rg"), fd: await checkBinary("fd"), sg: await checkBinary("sg"), ctags: await checkBinary("ctags"), git: await checkBinary("git") };
-                        const actions = [];
-                        if (!fsSync.existsSync(CACHE_DIR))
-                            actions.push(`Create cache directory: ${CACHE_DIR}`);
-                        pendingInitToken = crypto.randomBytes(4).toString("hex");
-                        return JSON.stringify({
-                            status: "PLAN_READY",
-                            system_checks: checks,
-                            planned_actions: actions,
-                            confirm_token: pendingInitToken,
-                            instruction: "Call autognosis_init with mode='apply' and the confirm_token."
-                        }, null, 2);
-                    }
-                    else {
-                        if (!pendingInitToken || token !== pendingInitToken) {
-                            return JSON.stringify({ status: "ERROR", message: "Invalid token." });
-                        }
-                        await ensureCache();
-                        pendingInitToken = null;
-                        return JSON.stringify({ status: "SUCCESS", message: "Autognosis initialized." });
-                    }
-                }
-            }),
-            fast_search: tool({
-                description: "Fast search using rg and fd.",
-                args: {
-                    query: tool.schema.string(),
-                    mode: tool.schema.enum(["filename", "content"]).optional().default("filename"),
-                    path: tool.schema.string().optional().default(".")
-                },
-                async execute({ query, mode, path: searchPath }) {
-                    if (mode === "content") {
-                        const { stdout } = await runCmd(`rg -n --column "${query}" "${searchPath}"`);
-                        return stdout.split('\n').slice(0, 50).join('\n') || "No matches.";
-                    }
-                    else {
-                        const { stdout } = await runCmd(`fd "${query}" "${searchPath}"`);
-                        return stdout.split('\n').slice(0, 50).join('\n') || "No files.";
-                    }
-                }
-            }),
-            read_slice: tool({
-                description: "Read a specific slice of a file.",
-                args: {
-                    file: tool.schema.string(),
-                    start_line: tool.schema.number(),
-                    end_line: tool.schema.number()
-                },
-                async execute({ file, start_line, end_line }) {
-                    const { stdout, stderr } = await runCmd(`sed -n '${start_line},${end_line}p;${end_line + 1}q' "${file}"`);
-                    if (stderr)
-                        return `Error: ${stderr}`;
-                    return JSON.stringify({ file, start_line, end_line, content: stdout }, null, 2);
-                }
-            }),
-            symbol_query: tool({
-                description: "Query the symbol index.",
-                args: {
-                    symbol: tool.schema.string()
-                },
-                async execute({ symbol }) {
-                    const maint = await maintainSymbolIndex();
-                    if (maint.status === "unavailable")
-                        return JSON.stringify({ error: maint.reason });
-                    const tagsFile = path.join(CACHE_DIR, "tags");
-                    const { stdout: grepOut } = await runCmd(`grep -P "^${symbol}\t" "${tagsFile}"`);
-                    return JSON.stringify({ matches: grepOut.split('\n').filter(Boolean), metadata: maint }, null, 2);
-                }
-            }),
-            jump_to_symbol: tool({
-                description: "Jump to a symbol definition.",
-                args: {
-                    symbol: tool.schema.string()
-                },
-                async execute({ symbol }) {
-                    const maint = await maintainSymbolIndex();
-                    if (maint.status !== "ok")
-                        return JSON.stringify({ error: maint.reason });
-                    const tagsFile = path.join(CACHE_DIR, "tags");
-                    const { stdout: tagLine } = await runCmd(`grep -P "^${symbol}\t" "${tagsFile}" | head -n 1`);
-                    if (!tagLine)
-                        return JSON.stringify({ found: false, symbol });
-                    const file = tagLine.split('\t')[1];
-                    const { stdout: grepLine } = await runCmd(`grep -n "${symbol}" "${file}" | head -n 1`);
-                    const line = grepLine ? parseInt(grepLine.split(':')[0], 10) : 1;
-                    const start = Math.max(1, line - 5);
-                    const end = line + 15;
-                    const { stdout: slice } = await runCmd(`sed -n '${start},${end}p;${end + 1}q' "${file}"`);
-                    return JSON.stringify({ symbol, resolved_location: { file, line }, slice: { start, end, content: slice } }, null, 2);
-                }
-            }),
-            brief_fix_loop: tool({
-                description: "Action Planner.",
-                args: {
-                    symbol: tool.schema.string(),
-                    intent: tool.schema.string()
-                },
-                async execute({ symbol, intent }) {
-                    return JSON.stringify({ plan_id: `plan-${Date.now()}`, symbol, intent }, null, 2);
-                }
-            }),
-            prepare_patch: tool({
-                description: "Generate a .diff artifact.",
-                args: {
-                    message: tool.schema.string()
-                },
-                async execute({ message }) {
-                    await ensureCache();
-                    const patchPath = path.join(CACHE_DIR, `patch-${Date.now()}.diff`);
-                    const { stdout } = await runCmd("git diff");
-                    if (!stdout)
-                        return "No changes.";
-                    await fs.writeFile(patchPath, `// MSG: ${message}\n\n${stdout}`);
-                    return `Patch saved to ${patchPath}`;
-                }
-            }),
-            validate_patch: tool({
-                description: "Validate a patch.",
-                args: {
-                    patch_path: tool.schema.string()
-                },
-                async execute({ patch_path }) {
-                    const { error } = await runCmd(`git apply --check "${patch_path}"`);
-                    return error ? `FAILED: ${error.message}` : "SUCCESS.";
-                }
-            }),
-            finalize_plan: tool({
-                description: "Finalize a plan.",
-                args: {
-                    plan_id: tool.schema.string(),
-                    outcome: tool.schema.string()
-                },
-                async execute({ plan_id, outcome }) {
-                    await ensureCache();
-                    const report = { plan_id, outcome, time: new Date().toISOString() };
-                    await fs.appendFile(path.join(CACHE_DIR, "gaps.jsonl"), JSON.stringify(report) + "\n");
-                    const deleted = await cleanCache();
-                    return `Finalized. Deleted ${deleted} items.`;
-                }
-            })
-        }
+        tools: {
+            ...systemTools(),
+            ...gitWorktreeTools(),
+            ...testingTools(),
+            ...chunkCardsTools(),
+            ...activeSetTools(),
+            ...moduleSummariesTools(),
+            ...performanceTools(),
+        },
     };
-};
-export default AutognosisPlugin;
+}

package/dist/module-summaries.d.ts

@@ -0,0 +1,3 @@
+export declare function moduleSummariesTools(): {
+    [key: string]: any;
+};