opencode-akane 0.1.1 → 0.1.3

package/README.md

@@ -19,6 +19,13 @@ This repository now contains the first MVP skeleton for the plugin:
 - `src/artifacts.ts`: `.opencode/akane/` artifact and `state.json` helpers
 - `src/tools/akane-init.ts`: initializes the per-project workspace
 - `src/tools/akane-stage-artifact.ts`: writes stage artifacts deterministically
+- `src/workflow.ts`: child-session orchestration, stage prompts, and artifact handoff
+- `src/tools/akane-plan.ts`: planner stage
+- `src/tools/akane-plan-review.ts`: plan review stage
+- `src/tools/akane-implement.ts`: implementation stage
+- `src/tools/akane-review.ts`: review stage
+- `src/tools/akane-synthesize.ts`: final synthesis stage
+- `src/tools/akane-run.ts`: end-to-end MVP workflow runner
 - `examples/akane.example.json`: example global Akane config
 
 ## Local development
@@ -31,6 +38,24 @@ bun run build
 
 The build emits `dist/index.js` as the package entrypoint and also keeps `dist/akane.js` for local file-based linking.
 
+## Available tools
+
+Once the plugin is loaded in OpenCode, the current MVP exposes these tools:
+
+- `akane_init`
+- `akane_stage_artifact`
+- `akane_plan`
+- `akane_plan_review`
+- `akane_implement`
+- `akane_review`
+- `akane_synthesize`
+- `akane_run`
+
+Notes:
+
+- `akane_init` is optional because the stage tools lazily create `.opencode/akane/` on first use
+- `akane_run` is the main MVP entrypoint when you want to test the full workflow
+
 ## Package install
 
 For package-based installation, publish this repository to npm and add it to the OpenCode plugin array in `~/.config/opencode/opencode.json`:
@@ -40,12 +65,14 @@ For package-based installation, publish this repository to npm and add it to the
   "$schema": "https://opencode.ai/config.json",
   "plugin": [
     "oh-my-opencode@latest",
-    "opencode-akane@0.1.0"
+    "opencode-akane@latest"
   ]
 }
 ```
 
 Akane still reads its runtime config from `~/.config/opencode/akane.json`.
+If that file does not exist yet, the plugin now bootstraps it automatically on first load with the default config.
+You only need to edit it when you want to override the default role or artifact settings.
 
 ## Publish flow
 

package/dist/artifacts.d.ts

@@ -1,4 +1,4 @@
-import type { AkaneConfig, AkaneStageId, AkaneState, ArtifactWriteMode } from "./types.js";
+import type { AkaneConfig, AkaneStageId, AkaneStageState, AkaneState, ArtifactWriteMode } from "./types.js";
 export declare function resolveProjectRoot(input: {
     directory: string;
     worktree?: string;
@@ -30,6 +30,7 @@ export declare function writeStageArtifact(input: {
     stage: AkaneStageId;
     content: string;
     mode: ArtifactWriteMode;
+    details?: Partial<Omit<AkaneStageState, "path" | "status" | "updatedAt">>;
 }): Promise<{
     artifactDir: string;
     artifactPath: string;

package/dist/artifacts.js

@@ -133,6 +133,7 @@ export async function writeStageArtifact(input) {
         path: artifactPath,
         status: "completed",
         updatedAt: timestamp,
+        ...input.details,
     };
     await writeStateFile(ensured.statePath, state);
     return {

package/dist/config.d.ts

@@ -3,7 +3,7 @@ type DeepPartial<T> = {
     [K in keyof T]?: T[K] extends Array<infer U> ? U[] : T[K] extends Record<string, unknown> ? DeepPartial<T[K]> : T[K];
 };
 export declare function expandHome(inputPath: string): string;
-export declare function defaultAkaneConfig(): AkaneConfig;
+export declare function defaultAkaneConfig(configPath?: string): AkaneConfig;
 export declare function mergeAkaneConfig(base: AkaneConfig, overrides: DeepPartial<AkaneConfig>): AkaneConfig;
 export declare function loadAkaneConfig(configPath?: string): Promise<LoadedAkaneConfig>;
 export {};

package/dist/config.js

@@ -1,4 +1,4 @@
-import { readFile } from "node:fs/promises";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { AKANE_SERVICE_NAME, AKANE_STAGE_IDS, DEFAULT_ARTIFACT_DIR, DEFAULT_GLOBAL_CONFIG_PATH, DEFAULT_PLUGIN_OUTPUT_PATH, DEFAULT_ROLE_MODELS, DEFAULT_STAGE_FILES, DEFAULT_STAGE_ORDER, DEFAULT_STATE_FILE, } from "./constants.js";
@@ -14,12 +14,35 @@ export function expandHome(inputPath) {
     }
     return inputPath;
 }
-export function defaultAkaneConfig() {
+function formatAkaneConfig(config) {
+    return `${JSON.stringify(config, null, 2)}\n`;
+}
+async function readAkaneConfigFile(filePath) {
+    const raw = await readFile(filePath, "utf8");
+    return parseJsonFile(raw, filePath);
+}
+async function bootstrapAkaneConfigFile(filePath, config) {
+    await mkdir(path.dirname(filePath), { recursive: true });
+    try {
+        await writeFile(filePath, formatAkaneConfig(config), {
+            encoding: "utf8",
+            flag: "wx",
+        });
+        return true;
+    }
+    catch (error) {
+        if (error.code === "EEXIST") {
+            return false;
+        }
+        throw error;
+    }
+}
+export function defaultAkaneConfig(configPath = DEFAULT_GLOBAL_CONFIG_PATH) {
     return {
         version: 1,
         serviceName: AKANE_SERVICE_NAME,
         pluginOutputPath: DEFAULT_PLUGIN_OUTPUT_PATH,
-        globalConfigPath: DEFAULT_GLOBAL_CONFIG_PATH,
+        globalConfigPath: configPath,
         artifacts: {
             dir: DEFAULT_ARTIFACT_DIR,
             stateFile: DEFAULT_STATE_FILE,
@@ -109,10 +132,9 @@ export function mergeAkaneConfig(base, overrides) {
 }
 export async function loadAkaneConfig(configPath = process.env.AKANE_CONFIG_PATH ?? DEFAULT_GLOBAL_CONFIG_PATH) {
     const resolvedPath = expandHome(configPath);
-    const defaults = defaultAkaneConfig();
+    const defaults = defaultAkaneConfig(configPath);
     try {
-        const raw = await readFile(resolvedPath, "utf8");
-        const parsed = parseJsonFile(raw, resolvedPath);
+        const parsed = await readAkaneConfigFile(resolvedPath);
         return {
             path: resolvedPath,
             exists: true,
@@ -121,11 +143,33 @@ export async function loadAkaneConfig(configPath = process.env.AKANE_CONFIG_PATH
     }
     catch (error) {
         if (error.code === "ENOENT") {
-            return {
-                path: resolvedPath,
-                exists: false,
-                config: defaults,
-            };
+            try {
+                const created = await bootstrapAkaneConfigFile(resolvedPath, defaults);
+                if (!created) {
+                    const parsed = await readAkaneConfigFile(resolvedPath);
+                    return {
+                        path: resolvedPath,
+                        exists: true,
+                        config: mergeAkaneConfig(defaults, parsed),
+                    };
+                }
+                return {
+                    path: resolvedPath,
+                    exists: true,
+                    config: defaults,
+                };
+            }
+            catch (bootstrapError) {
+                const message = bootstrapError instanceof Error
+                    ? bootstrapError.message
+                    : "unknown bootstrap error";
+                console.warn(`Akane: failed to auto-create config at ${resolvedPath}: ${message}`);
+                return {
+                    path: resolvedPath,
+                    exists: false,
+                    config: defaults,
+                };
+            }
         }
         throw error;
     }

package/dist/constants.d.ts

@@ -4,6 +4,7 @@ export declare const DEFAULT_PLUGIN_OUTPUT_PATH = "~/.config/opencode/plugins/ak
 export declare const DEFAULT_ARTIFACT_DIR = ".opencode/akane";
 export declare const DEFAULT_STATE_FILE = "state.json";
 export declare const AKANE_STAGE_IDS: readonly ["plan", "plan-review", "implementation-context", "review-codex", "review-claude", "final-synthesis"];
+export declare const AKANE_TOOL_IDS: readonly ["akane_init", "akane_stage_artifact", "akane_plan", "akane_plan_review", "akane_implement", "akane_review", "akane_synthesize", "akane_run"];
 export declare const AKANE_ROLE_IDS: readonly ["planner", "plan_reviewer", "implementer", "consultant_primary", "consultant_secondary", "reviewer_codex", "reviewer_claude", "synthesizer"];
 export declare const DEFAULT_ROLE_MODELS: {
     readonly planner: "anthropic/claude-opus-4-6";

package/dist/constants.js

@@ -11,6 +11,16 @@ export const AKANE_STAGE_IDS = [
     "review-claude",
     "final-synthesis",
 ];
+export const AKANE_TOOL_IDS = [
+    "akane_init",
+    "akane_stage_artifact",
+    "akane_plan",
+    "akane_plan_review",
+    "akane_implement",
+    "akane_review",
+    "akane_synthesize",
+    "akane_run",
+];
 export const AKANE_ROLE_IDS = [
     "planner",
     "plan_reviewer",

package/dist/plugin.js

@@ -2,12 +2,24 @@ import { loadAkaneConfig } from "./config.js";
 import { resolveArtifactDir } from "./artifacts.js";
 import { createAkaneInitTool } from "./tools/akane-init.js";
 import { createAkaneStageArtifactTool } from "./tools/akane-stage-artifact.js";
+import { createAkanePlanTool } from "./tools/akane-plan.js";
+import { createAkanePlanReviewTool } from "./tools/akane-plan-review.js";
+import { createAkaneImplementTool } from "./tools/akane-implement.js";
+import { createAkaneReviewTool } from "./tools/akane-review.js";
+import { createAkaneSynthesizeTool } from "./tools/akane-synthesize.js";
+import { createAkaneRunTool } from "./tools/akane-run.js";
 export const AkanePlugin = async (input) => {
     const configInfo = await loadAkaneConfig();
     return {
         tool: {
             akane_init: createAkaneInitTool(configInfo),
             akane_stage_artifact: createAkaneStageArtifactTool(configInfo),
+            akane_plan: createAkanePlanTool(input, configInfo),
+            akane_plan_review: createAkanePlanReviewTool(input, configInfo),
+            akane_implement: createAkaneImplementTool(input, configInfo),
+            akane_review: createAkaneReviewTool(input, configInfo),
+            akane_synthesize: createAkaneSynthesizeTool(input, configInfo),
+            akane_run: createAkaneRunTool(input, configInfo),
         },
         "shell.env": async (_event, output) => {
             const projectRoot = input.worktree || input.directory;

package/dist/tools/akane-implement.d.ts

@@ -0,0 +1,15 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { LoadedAkaneConfig } from "../types.js";
+export declare function createAkaneImplementTool(pluginInput: PluginInput, configInfo: LoadedAkaneConfig): {
+    description: string;
+    args: {
+        task: import("zod").ZodOptional<import("zod").ZodString>;
+        notes: import("zod").ZodOptional<import("zod").ZodString>;
+        projectRoot: import("zod").ZodOptional<import("zod").ZodString>;
+    };
+    execute(args: {
+        task?: string | undefined;
+        notes?: string | undefined;
+        projectRoot?: string | undefined;
+    }, context: import("@opencode-ai/plugin/tool").ToolContext): Promise<string>;
+};

package/dist/tools/akane-implement.js

@@ -0,0 +1,53 @@
+import { tool } from "@opencode-ai/plugin/tool";
+import { executeImplementStage, resolveProjectRootFromArgs, } from "../workflow.js";
+export function createAkaneImplementTool(pluginInput, configInfo) {
+    return tool({
+        description: "Implement the approved Akane plan in the repository and write implementation-context.md.",
+        args: {
+            task: tool.schema
+                .string()
+                .optional()
+                .describe("Optional task restatement for the implementer stage."),
+            notes: tool.schema
+                .string()
+                .optional()
+                .describe("Optional additional implementation constraints."),
+            projectRoot: tool.schema
+                .string()
+                .optional()
+                .describe("Optional project root override. Defaults to the current session worktree."),
+        },
+        async execute(args, context) {
+            try {
+                const projectRoot = resolveProjectRootFromArgs({
+                    toolContext: context,
+                    projectRoot: args.projectRoot,
+                });
+                context.metadata({
+                    title: "Akane implement",
+                    metadata: {
+                        stage: "implementation-context",
+                        projectRoot,
+                    },
+                });
+                const result = await executeImplementStage({
+                    pluginInput,
+                    configInfo,
+                    toolContext: context,
+                    projectRoot,
+                    task: args.task,
+                    notes: args.notes,
+                });
+                return [
+                    `Created Akane implementation artifact.`,
+                    `Artifact: ${result.artifactPath}`,
+                    `Session: ${result.sessionID}`,
+                    `Model: ${result.model}`,
+                ].join("\n");
+            }
+            catch (error) {
+                return `Akane implement failed: ${error instanceof Error ? error.message : String(error)}`;
+            }
+        },
+    });
+}

package/dist/tools/akane-plan-review.d.ts

@@ -0,0 +1,15 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { LoadedAkaneConfig } from "../types.js";
+export declare function createAkanePlanReviewTool(pluginInput: PluginInput, configInfo: LoadedAkaneConfig): {
+    description: string;
+    args: {
+        task: import("zod").ZodOptional<import("zod").ZodString>;
+        notes: import("zod").ZodOptional<import("zod").ZodString>;
+        projectRoot: import("zod").ZodOptional<import("zod").ZodString>;
+    };
+    execute(args: {
+        task?: string | undefined;
+        notes?: string | undefined;
+        projectRoot?: string | undefined;
+    }, context: import("@opencode-ai/plugin/tool").ToolContext): Promise<string>;
+};

package/dist/tools/akane-plan-review.js

@@ -0,0 +1,53 @@
+import { tool } from "@opencode-ai/plugin/tool";
+import { executePlanReviewStage, resolveProjectRootFromArgs, } from "../workflow.js";
+export function createAkanePlanReviewTool(pluginInput, configInfo) {
+    return tool({
+        description: "Review the current Akane plan artifact and write plan-review.md using the configured review model.",
+        args: {
+            task: tool.schema
+                .string()
+                .optional()
+                .describe("Optional task restatement to include during review."),
+            notes: tool.schema
+                .string()
+                .optional()
+                .describe("Optional additional review constraints."),
+            projectRoot: tool.schema
+                .string()
+                .optional()
+                .describe("Optional project root override. Defaults to the current session worktree."),
+        },
+        async execute(args, context) {
+            try {
+                const projectRoot = resolveProjectRootFromArgs({
+                    toolContext: context,
+                    projectRoot: args.projectRoot,
+                });
+                context.metadata({
+                    title: "Akane plan review",
+                    metadata: {
+                        stage: "plan-review",
+                        projectRoot,
+                    },
+                });
+                const result = await executePlanReviewStage({
+                    pluginInput,
+                    configInfo,
+                    toolContext: context,
+                    projectRoot,
+                    task: args.task,
+                    notes: args.notes,
+                });
+                return [
+                    `Created Akane plan review.`,
+                    `Artifact: ${result.artifactPath}`,
+                    `Session: ${result.sessionID}`,
+                    `Model: ${result.model}`,
+                ].join("\n");
+            }
+            catch (error) {
+                return `Akane plan review failed: ${error instanceof Error ? error.message : String(error)}`;
+            }
+        },
+    });
+}

package/dist/tools/akane-plan.d.ts

@@ -0,0 +1,15 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { LoadedAkaneConfig } from "../types.js";
+export declare function createAkanePlanTool(pluginInput: PluginInput, configInfo: LoadedAkaneConfig): {
+    description: string;
+    args: {
+        task: import("zod").ZodString;
+        notes: import("zod").ZodOptional<import("zod").ZodString>;
+        projectRoot: import("zod").ZodOptional<import("zod").ZodString>;
+    };
+    execute(args: {
+        task: string;
+        notes?: string | undefined;
+        projectRoot?: string | undefined;
+    }, context: import("@opencode-ai/plugin/tool").ToolContext): Promise<string>;
+};

package/dist/tools/akane-plan.js

@@ -0,0 +1,50 @@
+import { tool } from "@opencode-ai/plugin/tool";
+import { executePlanStage, resolveProjectRootFromArgs, } from "../workflow.js";
+export function createAkanePlanTool(pluginInput, configInfo) {
+    return tool({
+        description: "Create the Akane plan artifact for a task by running the planner role in a child OpenCode session.",
+        args: {
+            task: tool.schema.string().describe("The task or change request to plan."),
+            notes: tool.schema
+                .string()
+                .optional()
+                .describe("Optional additional constraints or context for the plan."),
+            projectRoot: tool.schema
+                .string()
+                .optional()
+                .describe("Optional project root override. Defaults to the current session worktree."),
+        },
+        async execute(args, context) {
+            try {
+                const projectRoot = resolveProjectRootFromArgs({
+                    toolContext: context,
+                    projectRoot: args.projectRoot,
+                });
+                context.metadata({
+                    title: "Akane plan",
+                    metadata: {
+                        stage: "plan",
+                        projectRoot,
+                    },
+                });
+                const result = await executePlanStage({
+                    pluginInput,
+                    configInfo,
+                    toolContext: context,
+                    projectRoot,
+                    task: args.task,
+                    notes: args.notes,
+                });
+                return [
+                    `Created Akane plan.`,
+                    `Artifact: ${result.artifactPath}`,
+                    `Session: ${result.sessionID}`,
+                    `Model: ${result.model}`,
+                ].join("\n");
+            }
+            catch (error) {
+                return `Akane plan failed: ${error instanceof Error ? error.message : String(error)}`;
+            }
+        },
+    });
+}

package/dist/tools/akane-review.d.ts

@@ -0,0 +1,21 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { LoadedAkaneConfig } from "../types.js";
+export declare function createAkaneReviewTool(pluginInput: PluginInput, configInfo: LoadedAkaneConfig): {
+    description: string;
+    args: {
+        reviewer: import("zod").ZodDefault<import("zod").ZodEnum<{
+            codex: "codex";
+            claude: "claude";
+            both: "both";
+        }>>;
+        task: import("zod").ZodOptional<import("zod").ZodString>;
+        notes: import("zod").ZodOptional<import("zod").ZodString>;
+        projectRoot: import("zod").ZodOptional<import("zod").ZodString>;
+    };
+    execute(args: {
+        reviewer: "codex" | "claude" | "both";
+        task?: string | undefined;
+        notes?: string | undefined;
+        projectRoot?: string | undefined;
+    }, context: import("@opencode-ai/plugin/tool").ToolContext): Promise<string>;
+};

package/dist/tools/akane-review.js

@@ -0,0 +1,57 @@
+import { tool } from "@opencode-ai/plugin/tool";
+import { executeReviewStage, resolveProjectRootFromArgs, reviewSelectionLabel, } from "../workflow.js";
+export function createAkaneReviewTool(pluginInput, configInfo) {
+    return tool({
+        description: "Run the Akane review stage. By default this runs both Codex and Claude reviews in parallel.",
+        args: {
+            reviewer: tool.schema
+                .enum(["codex", "claude", "both"])
+                .default("both")
+                .describe("Which reviewer to run. 'both' runs both review artifacts in parallel."),
+            task: tool.schema
+                .string()
+                .optional()
+                .describe("Optional task restatement for the reviewers."),
+            notes: tool.schema
+                .string()
+                .optional()
+                .describe("Optional additional review constraints."),
+            projectRoot: tool.schema
+                .string()
+                .optional()
+                .describe("Optional project root override. Defaults to the current session worktree."),
+        },
+        async execute(args, context) {
+            try {
+                const projectRoot = resolveProjectRootFromArgs({
+                    toolContext: context,
+                    projectRoot: args.projectRoot,
+                });
+                context.metadata({
+                    title: "Akane review",
+                    metadata: {
+                        stage: "review",
+                        reviewer: args.reviewer,
+                        projectRoot,
+                    },
+                });
+                const result = await executeReviewStage({
+                    pluginInput,
+                    configInfo,
+                    toolContext: context,
+                    projectRoot,
+                    reviewer: args.reviewer,
+                    task: args.task,
+                    notes: args.notes,
+                });
+                return [
+                    `Created Akane review artifact(s): ${reviewSelectionLabel(result.requested)}.`,
+                    ...result.results.map((item) => `- ${item.stage}: ${item.artifactPath} (${item.model})`),
+                ].join("\n");
+            }
+            catch (error) {
+                return `Akane review failed: ${error instanceof Error ? error.message : String(error)}`;
+            }
+        },
+    });
+}

package/dist/tools/akane-run.d.ts

@@ -0,0 +1,24 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { LoadedAkaneConfig } from "../types.js";
+export declare function createAkaneRunTool(pluginInput: PluginInput, configInfo: LoadedAkaneConfig): {
+    description: string;
+    args: {
+        task: import("zod").ZodString;
+        notes: import("zod").ZodOptional<import("zod").ZodString>;
+        throughStage: import("zod").ZodDefault<import("zod").ZodEnum<{
+            plan: "plan";
+            "plan-review": "plan-review";
+            "implementation-context": "implementation-context";
+            "review-codex": "review-codex";
+            "review-claude": "review-claude";
+            "final-synthesis": "final-synthesis";
+        }>>;
+        projectRoot: import("zod").ZodOptional<import("zod").ZodString>;
+    };
+    execute(args: {
+        task: string;
+        throughStage: "plan" | "plan-review" | "implementation-context" | "review-codex" | "review-claude" | "final-synthesis";
+        notes?: string | undefined;
+        projectRoot?: string | undefined;
+    }, context: import("@opencode-ai/plugin/tool").ToolContext): Promise<string>;
+};

package/dist/tools/akane-run.js

@@ -0,0 +1,66 @@
+import { tool } from "@opencode-ai/plugin/tool";
+import { executeRunWorkflow, resolveProjectRootFromArgs, } from "../workflow.js";
+import { AKANE_STAGE_IDS } from "../constants.js";
+export function createAkaneRunTool(pluginInput, configInfo) {
+    return tool({
+        description: "Run the Akane MVP workflow from planning through synthesis, writing artifacts at each stage.",
+        args: {
+            task: tool.schema.string().describe("The task or change request to run through Akane."),
+            notes: tool.schema
+                .string()
+                .optional()
+                .describe("Optional additional constraints or context for the workflow."),
+            throughStage: tool.schema
+                .enum(AKANE_STAGE_IDS)
+                .default("final-synthesis")
+                .describe("Optional stop point for partial workflow runs."),
+            projectRoot: tool.schema
+                .string()
+                .optional()
+                .describe("Optional project root override. Defaults to the current session worktree."),
+        },
+        async execute(args, context) {
+            try {
+                const projectRoot = resolveProjectRootFromArgs({
+                    toolContext: context,
+                    projectRoot: args.projectRoot,
+                });
+                context.metadata({
+                    title: "Akane run",
+                    metadata: {
+                        stage: "workflow",
+                        throughStage: args.throughStage,
+                        projectRoot,
+                    },
+                });
+                const result = await executeRunWorkflow({
+                    pluginInput,
+                    configInfo,
+                    toolContext: context,
+                    projectRoot,
+                    task: args.task,
+                    notes: args.notes,
+                    throughStage: args.throughStage,
+                });
+                return [
+                    `Completed Akane workflow through ${args.throughStage}.`,
+                    `Stages: ${result.completedStages.join(", ")}`,
+                    `Plan: ${result.plan.artifactPath}`,
+                    ...(result.planReview ? [`Plan review: ${result.planReview.artifactPath}`] : []),
+                    ...(result.implementation
+                        ? [`Implementation: ${result.implementation.artifactPath}`]
+                        : []),
+                    ...(result.reviews
+                        ? result.reviews.map((review) => `${review.stage}: ${review.artifactPath}`)
+                        : []),
+                    ...(result.synthesis
+                        ? [`Final synthesis: ${result.synthesis.artifactPath}`]
+                        : []),
+                ].join("\n");
+            }
+            catch (error) {
+                return `Akane workflow failed: ${error instanceof Error ? error.message : String(error)}`;
+            }
+        },
+    });
+}

package/dist/tools/akane-synthesize.d.ts

@@ -0,0 +1,15 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { LoadedAkaneConfig } from "../types.js";
+export declare function createAkaneSynthesizeTool(pluginInput: PluginInput, configInfo: LoadedAkaneConfig): {
+    description: string;
+    args: {
+        task: import("zod").ZodOptional<import("zod").ZodString>;
+        notes: import("zod").ZodOptional<import("zod").ZodString>;
+        projectRoot: import("zod").ZodOptional<import("zod").ZodString>;
+    };
+    execute(args: {
+        task?: string | undefined;
+        notes?: string | undefined;
+        projectRoot?: string | undefined;
+    }, context: import("@opencode-ai/plugin/tool").ToolContext): Promise<string>;
+};