opencode-akane 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 NaturaAurum
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,95 @@
+# Akane Agents
+
+Akane is a global OpenCode orchestration plugin draft.
+
+Current direction:
+
+- Keep OpenCode provider and auth infrastructure
+- Keep `oh-my-opencode` installed but neutralized
+- Drive a deterministic workflow across planning, review, implementation, and synthesis
+
+See [docs/session-context-20260306.md](/Users/taewoo.kim/Desktop/Projects/akane-agents/docs/session-context-20260306.md) for the current working context.
+
+## MVP scaffold
+
+This repository now contains the first MVP skeleton for the plugin:
+
+- `src/plugin.ts`: OpenCode plugin entry
+- `src/config.ts`: `~/.config/opencode/akane.json` loader with defaults
+- `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
+- `examples/akane.example.json`: example global Akane config
+
+## Local development
+
+```bash
+bun install
+bun run typecheck
+bun run build
+```
+
+The build emits `dist/index.js` as the package entrypoint and also keeps `dist/akane.js` for local file-based linking.
+
+## Package install
+
+For package-based installation, publish this repository to npm and add it to the OpenCode plugin array in `~/.config/opencode/opencode.json`:
+
+```json
+{
+  "$schema": "https://opencode.ai/config.json",
+  "plugin": [
+    "oh-my-opencode@latest",
+    "opencode-akane@0.1.0"
+  ]
+}
+```
+
+Akane still reads its runtime config from `~/.config/opencode/akane.json`.
+
+## Publish flow
+
+The package is prepared to publish from npm with:
+
+```bash
+bun install
+bun run typecheck
+bun run build
+npm publish
+```
+
+Useful checks before publishing:
+
+```bash
+bun run pack:check
+```
+
+Notes:
+
+- The current package name assumption is `opencode-akane`
+- The current license is `MIT`
+- If you later switch to a scoped package name, publish with `npm publish --access public`
+
+## Automated publishing
+
+This repository includes GitHub Actions workflows for CI and npm publishing:
+
+- `.github/workflows/ci.yml`: runs install, typecheck, build, and `npm pack --dry-run`
+- `.github/workflows/publish.yml`: publishes to npm when a tag like `v0.1.0` is pushed
+
+Recommended setup for public release:
+
+1. Make the GitHub repository public
+2. Publish `opencode-akane` once manually from your npm account, or reserve the package name
+3. In npm package settings, add a Trusted Publisher for:
+   - GitHub owner: `NaturaAurum`
+   - Repository: `akane-agents`
+   - Workflow filename: `publish.yml`
+4. Push a version tag that matches `package.json`, for example:
+
+```bash
+git tag v0.1.0
+git push origin main --tags
+```
+
+The publish workflow intentionally uses npm trusted publishing with GitHub OIDC instead of an `NPM_TOKEN`.

package/dist/akane.d.ts

@@ -0,0 +1 @@
+export { AkanePlugin as default, AkanePlugin } from "./plugin.js";

package/dist/akane.js

@@ -0,0 +1 @@
+export { AkanePlugin as default, AkanePlugin } from "./plugin.js";

package/dist/artifacts.d.ts

@@ -0,0 +1,38 @@
+import type { AkaneConfig, AkaneStageId, AkaneState, ArtifactWriteMode } from "./types.js";
+export declare function resolveProjectRoot(input: {
+    directory: string;
+    worktree?: string;
+    projectRoot?: string;
+}): string;
+export declare function resolveArtifactDir(projectRoot: string, config: AkaneConfig): string;
+export declare function resolveStatePath(projectRoot: string, config: AkaneConfig): string;
+export declare function resolveStageArtifactPath(projectRoot: string, config: AkaneConfig, stage: AkaneStageId): string;
+export declare function createInitialState(input: {
+    config: AkaneConfig;
+    configPath: string;
+    projectRoot: string;
+}): AkaneState;
+export declare function ensureArtifactLayout(input: {
+    projectRoot: string;
+    config: AkaneConfig;
+    configPath: string;
+    force?: boolean;
+}): Promise<{
+    artifactDir: string;
+    statePath: string;
+    state: AkaneState;
+    createdFiles: string[];
+}>;
+export declare function writeStageArtifact(input: {
+    projectRoot: string;
+    config: AkaneConfig;
+    configPath: string;
+    stage: AkaneStageId;
+    content: string;
+    mode: ArtifactWriteMode;
+}): Promise<{
+    artifactDir: string;
+    artifactPath: string;
+    statePath: string;
+    state: AkaneState;
+}>;

package/dist/artifacts.js

@@ -0,0 +1,144 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { AKANE_SERVICE_NAME, AKANE_STAGE_IDS, } from "./constants.js";
+function nowIso() {
+    return new Date().toISOString();
+}
+function stageTitle(stage) {
+    return stage
+        .split("-")
+        .map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1))
+        .join(" ");
+}
+function defaultStageTemplate(stage) {
+    return `# ${stageTitle(stage)}\n\nGenerated by ${AKANE_SERVICE_NAME}.\n`;
+}
+export function resolveProjectRoot(input) {
+    if (input.projectRoot && input.projectRoot.trim()) {
+        return path.resolve(input.projectRoot);
+    }
+    if (input.worktree && input.worktree.trim()) {
+        return path.resolve(input.worktree);
+    }
+    return path.resolve(input.directory);
+}
+export function resolveArtifactDir(projectRoot, config) {
+    if (path.isAbsolute(config.artifacts.dir)) {
+        return config.artifacts.dir;
+    }
+    return path.join(projectRoot, config.artifacts.dir);
+}
+export function resolveStatePath(projectRoot, config) {
+    return path.join(resolveArtifactDir(projectRoot, config), config.artifacts.stateFile);
+}
+export function resolveStageArtifactPath(projectRoot, config, stage) {
+    return path.join(resolveArtifactDir(projectRoot, config), config.artifacts.files[stage]);
+}
+export function createInitialState(input) {
+    const artifactDir = resolveArtifactDir(input.projectRoot, input.config);
+    const timestamp = nowIso();
+    const stages = Object.fromEntries(AKANE_STAGE_IDS.map((stage) => [
+        stage,
+        {
+            path: resolveStageArtifactPath(input.projectRoot, input.config, stage),
+            status: "pending",
+            updatedAt: null,
+        },
+    ]));
+    return {
+        version: input.config.version,
+        serviceName: input.config.serviceName,
+        configPath: input.configPath,
+        projectRoot: input.projectRoot,
+        artifactDir,
+        initializedAt: timestamp,
+        updatedAt: timestamp,
+        activeStage: null,
+        stageOrder: [...input.config.workflow.stageOrder],
+        stages,
+        roles: { ...input.config.roles },
+    };
+}
+async function readStateFile(statePath) {
+    try {
+        const raw = await readFile(statePath, "utf8");
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return null;
+        }
+        throw error;
+    }
+}
+async function writeStateFile(statePath, state) {
+    await writeFile(statePath, JSON.stringify(state, null, 2) + "\n", "utf8");
+}
+export async function ensureArtifactLayout(input) {
+    const artifactDir = resolveArtifactDir(input.projectRoot, input.config);
+    const statePath = resolveStatePath(input.projectRoot, input.config);
+    const createdFiles = [];
+    await mkdir(artifactDir, { recursive: true });
+    for (const stage of AKANE_STAGE_IDS) {
+        const artifactPath = resolveStageArtifactPath(input.projectRoot, input.config, stage);
+        try {
+            if (input.force) {
+                throw Object.assign(new Error("force"), { code: "ENOENT" });
+            }
+            await readFile(artifactPath, "utf8");
+        }
+        catch (error) {
+            if (error.code !== "ENOENT") {
+                throw error;
+            }
+            await writeFile(artifactPath, defaultStageTemplate(stage), "utf8");
+            createdFiles.push(artifactPath);
+        }
+    }
+    let state = await readStateFile(statePath);
+    if (!state || input.force) {
+        state = createInitialState({
+            config: input.config,
+            configPath: input.configPath,
+            projectRoot: input.projectRoot,
+        });
+        for (const stage of AKANE_STAGE_IDS) {
+            state.stages[stage].status = "initialized";
+            state.stages[stage].updatedAt = state.initializedAt;
+        }
+        await writeStateFile(statePath, state);
+        createdFiles.push(statePath);
+    }
+    return { artifactDir, statePath, state, createdFiles };
+}
+export async function writeStageArtifact(input) {
+    const ensured = await ensureArtifactLayout({
+        projectRoot: input.projectRoot,
+        config: input.config,
+        configPath: input.configPath,
+    });
+    const artifactPath = resolveStageArtifactPath(input.projectRoot, input.config, input.stage);
+    const previous = input.mode === "append"
+        ? await readFile(artifactPath, "utf8").catch((error) => error.code === "ENOENT" ? "" : Promise.reject(error))
+        : "";
+    const nextContent = input.mode === "append"
+        ? `${previous}${previous.endsWith("\n") || !previous ? "" : "\n"}${input.content}\n`
+        : `${input.content}${input.content.endsWith("\n") ? "" : "\n"}`;
+    await writeFile(artifactPath, nextContent, "utf8");
+    const state = ensured.state;
+    const timestamp = nowIso();
+    state.activeStage = input.stage;
+    state.updatedAt = timestamp;
+    state.stages[input.stage] = {
+        path: artifactPath,
+        status: "completed",
+        updatedAt: timestamp,
+    };
+    await writeStateFile(ensured.statePath, state);
+    return {
+        artifactDir: ensured.artifactDir,
+        artifactPath,
+        statePath: ensured.statePath,
+        state,
+    };
+}

package/dist/config.d.ts

@@ -0,0 +1,9 @@
+import type { AkaneConfig, LoadedAkaneConfig } from "./types.js";
+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 mergeAkaneConfig(base: AkaneConfig, overrides: DeepPartial<AkaneConfig>): AkaneConfig;
+export declare function loadAkaneConfig(configPath?: string): Promise<LoadedAkaneConfig>;
+export {};

package/dist/config.js

@@ -0,0 +1,132 @@
+import { readFile } 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";
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function expandHome(inputPath) {
+    if (inputPath === "~") {
+        return os.homedir();
+    }
+    if (inputPath.startsWith("~/")) {
+        return path.join(os.homedir(), inputPath.slice(2));
+    }
+    return inputPath;
+}
+export function defaultAkaneConfig() {
+    return {
+        version: 1,
+        serviceName: AKANE_SERVICE_NAME,
+        pluginOutputPath: DEFAULT_PLUGIN_OUTPUT_PATH,
+        globalConfigPath: DEFAULT_GLOBAL_CONFIG_PATH,
+        artifacts: {
+            dir: DEFAULT_ARTIFACT_DIR,
+            stateFile: DEFAULT_STATE_FILE,
+            files: { ...DEFAULT_STAGE_FILES },
+        },
+        workflow: {
+            stageOrder: [...DEFAULT_STAGE_ORDER],
+        },
+        roles: { ...DEFAULT_ROLE_MODELS },
+    };
+}
+function parseJsonFile(content, filePath) {
+    try {
+        return JSON.parse(content);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "unknown JSON parse error";
+        throw new Error(`Failed to parse Akane config at ${filePath}: ${message}`);
+    }
+}
+function normalizeRoles(input, fallback) {
+    if (!isRecord(input)) {
+        return { ...fallback };
+    }
+    const next = { ...fallback };
+    for (const role of Object.keys(fallback)) {
+        const candidate = input[role];
+        if (typeof candidate === "string" && candidate.trim()) {
+            next[role] = candidate.trim();
+        }
+    }
+    return next;
+}
+function normalizeFiles(input, fallback) {
+    if (!isRecord(input)) {
+        return { ...fallback };
+    }
+    const next = { ...fallback };
+    for (const stage of AKANE_STAGE_IDS) {
+        const candidate = input[stage];
+        if (typeof candidate === "string" && candidate.trim()) {
+            next[stage] = candidate.trim();
+        }
+    }
+    return next;
+}
+function normalizeStageOrder(input, fallback) {
+    if (!Array.isArray(input)) {
+        return [...fallback];
+    }
+    const values = input.filter((value) => typeof value === "string" &&
+        AKANE_STAGE_IDS.includes(value));
+    return values.length === AKANE_STAGE_IDS.length ? values : [...fallback];
+}
+export function mergeAkaneConfig(base, overrides) {
+    return {
+        version: typeof overrides.version === "number" ? overrides.version : base.version,
+        serviceName: typeof overrides.serviceName === "string" && overrides.serviceName.trim()
+            ? overrides.serviceName.trim()
+            : base.serviceName,
+        pluginOutputPath: typeof overrides.pluginOutputPath === "string" &&
+            overrides.pluginOutputPath.trim()
+            ? overrides.pluginOutputPath.trim()
+            : base.pluginOutputPath,
+        globalConfigPath: typeof overrides.globalConfigPath === "string" &&
+            overrides.globalConfigPath.trim()
+            ? overrides.globalConfigPath.trim()
+            : base.globalConfigPath,
+        artifacts: {
+            dir: isRecord(overrides.artifacts) &&
+                typeof overrides.artifacts.dir === "string" &&
+                overrides.artifacts.dir.trim()
+                ? overrides.artifacts.dir.trim()
+                : base.artifacts.dir,
+            stateFile: isRecord(overrides.artifacts) &&
+                typeof overrides.artifacts.stateFile === "string" &&
+                overrides.artifacts.stateFile.trim()
+                ? overrides.artifacts.stateFile.trim()
+                : base.artifacts.stateFile,
+            files: normalizeFiles(isRecord(overrides.artifacts) ? overrides.artifacts.files : undefined, base.artifacts.files),
+        },
+        workflow: {
+            stageOrder: normalizeStageOrder(isRecord(overrides.workflow) ? overrides.workflow.stageOrder : undefined, base.workflow.stageOrder),
+        },
+        roles: normalizeRoles(overrides.roles, base.roles),
+    };
+}
+export async function loadAkaneConfig(configPath = process.env.AKANE_CONFIG_PATH ?? DEFAULT_GLOBAL_CONFIG_PATH) {
+    const resolvedPath = expandHome(configPath);
+    const defaults = defaultAkaneConfig();
+    try {
+        const raw = await readFile(resolvedPath, "utf8");
+        const parsed = parseJsonFile(raw, resolvedPath);
+        return {
+            path: resolvedPath,
+            exists: true,
+            config: mergeAkaneConfig(defaults, parsed),
+        };
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return {
+                path: resolvedPath,
+                exists: false,
+                config: defaults,
+            };
+        }
+        throw error;
+    }
+}

package/dist/constants.d.ts

@@ -0,0 +1,26 @@
+export declare const AKANE_SERVICE_NAME = "Akane";
+export declare const DEFAULT_GLOBAL_CONFIG_PATH = "~/.config/opencode/akane.json";
+export declare const DEFAULT_PLUGIN_OUTPUT_PATH = "~/.config/opencode/plugins/akane.js";
+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_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";
+    readonly plan_reviewer: "openai/gpt-5.4";
+    readonly implementer: "openai/gpt-5.4";
+    readonly consultant_primary: "anthropic/claude-opus-4-6";
+    readonly consultant_secondary: "anthropic/claude-sonnet-4-6";
+    readonly reviewer_codex: "openai/gpt-5.4";
+    readonly reviewer_claude: "anthropic/claude-opus-4-6";
+    readonly synthesizer: "openai/gpt-5.4";
+};
+export declare const DEFAULT_STAGE_FILES: {
+    readonly plan: "plan.md";
+    readonly "plan-review": "plan-review.md";
+    readonly "implementation-context": "implementation-context.md";
+    readonly "review-codex": "review-codex.md";
+    readonly "review-claude": "review-claude.md";
+    readonly "final-synthesis": "final-synthesis.md";
+};
+export declare const DEFAULT_STAGE_ORDER: ("plan" | "plan-review" | "implementation-context" | "review-codex" | "review-claude" | "final-synthesis")[];

package/dist/constants.js

@@ -0,0 +1,42 @@
+export const AKANE_SERVICE_NAME = "Akane";
+export const DEFAULT_GLOBAL_CONFIG_PATH = "~/.config/opencode/akane.json";
+export const DEFAULT_PLUGIN_OUTPUT_PATH = "~/.config/opencode/plugins/akane.js";
+export const DEFAULT_ARTIFACT_DIR = ".opencode/akane";
+export const DEFAULT_STATE_FILE = "state.json";
+export const AKANE_STAGE_IDS = [
+    "plan",
+    "plan-review",
+    "implementation-context",
+    "review-codex",
+    "review-claude",
+    "final-synthesis",
+];
+export const AKANE_ROLE_IDS = [
+    "planner",
+    "plan_reviewer",
+    "implementer",
+    "consultant_primary",
+    "consultant_secondary",
+    "reviewer_codex",
+    "reviewer_claude",
+    "synthesizer",
+];
+export const DEFAULT_ROLE_MODELS = {
+    planner: "anthropic/claude-opus-4-6",
+    plan_reviewer: "openai/gpt-5.4",
+    implementer: "openai/gpt-5.4",
+    consultant_primary: "anthropic/claude-opus-4-6",
+    consultant_secondary: "anthropic/claude-sonnet-4-6",
+    reviewer_codex: "openai/gpt-5.4",
+    reviewer_claude: "anthropic/claude-opus-4-6",
+    synthesizer: "openai/gpt-5.4",
+};
+export const DEFAULT_STAGE_FILES = {
+    plan: "plan.md",
+    "plan-review": "plan-review.md",
+    "implementation-context": "implementation-context.md",
+    "review-codex": "review-codex.md",
+    "review-claude": "review-claude.md",
+    "final-synthesis": "final-synthesis.md",
+};
+export const DEFAULT_STAGE_ORDER = [...AKANE_STAGE_IDS];

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { AkanePlugin as default, AkanePlugin } from "./plugin.js";

package/dist/index.js

@@ -0,0 +1 @@
+export { AkanePlugin as default, AkanePlugin } from "./plugin.js";

package/dist/plugin.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from "@opencode-ai/plugin";
+export declare const AkanePlugin: Plugin;
+export default AkanePlugin;

package/dist/plugin.js

@@ -0,0 +1,20 @@
+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";
+export const AkanePlugin = async (input) => {
+    const configInfo = await loadAkaneConfig();
+    return {
+        tool: {
+            akane_init: createAkaneInitTool(configInfo),
+            akane_stage_artifact: createAkaneStageArtifactTool(configInfo),
+        },
+        "shell.env": async (_event, output) => {
+            const projectRoot = input.worktree || input.directory;
+            output.env.AKANE_PROJECT_ROOT = projectRoot;
+            output.env.AKANE_ARTIFACT_DIR = resolveArtifactDir(projectRoot, configInfo.config);
+            output.env.AKANE_CONFIG_PATH = configInfo.path;
+        },
+    };
+};
+export default AkanePlugin;

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

@@ -0,0 +1,12 @@
+import type { LoadedAkaneConfig } from "../types.js";
+export declare function createAkaneInitTool(configInfo: LoadedAkaneConfig): {
+    description: string;
+    args: {
+        force: import("zod").ZodDefault<import("zod").ZodBoolean>;
+        projectRoot: import("zod").ZodOptional<import("zod").ZodString>;
+    };
+    execute(args: {
+        force: boolean;
+        projectRoot?: string | undefined;
+    }, context: import("@opencode-ai/plugin/tool").ToolContext): Promise<string>;
+};

package/dist/tools/akane-init.js

@@ -0,0 +1,53 @@
+import { tool } from "@opencode-ai/plugin/tool";
+import { ensureArtifactLayout, resolveProjectRoot } from "../artifacts.js";
+export function createAkaneInitTool(configInfo) {
+    return tool({
+        description: "Initialize the per-project .opencode/akane workspace and create the stage artifact files.",
+        args: {
+            force: tool.schema
+                .boolean()
+                .default(false)
+                .describe("Recreate artifact files and state.json even when they already exist."),
+            projectRoot: tool.schema
+                .string()
+                .optional()
+                .describe("Optional project root override. Defaults to the current session worktree."),
+        },
+        async execute(args, context) {
+            const projectRoot = resolveProjectRoot({
+                directory: context.directory,
+                worktree: context.worktree,
+                projectRoot: args.projectRoot,
+            });
+            const result = await ensureArtifactLayout({
+                projectRoot,
+                config: configInfo.config,
+                configPath: configInfo.path,
+                force: args.force,
+            });
+            context.metadata({
+                title: "Akane initialized",
+                metadata: {
+                    projectRoot,
+                    artifactDir: result.artifactDir,
+                    configPath: configInfo.path,
+                    configFound: configInfo.exists,
+                    createdFiles: result.createdFiles,
+                },
+            });
+            const lines = [
+                `Initialized ${configInfo.config.serviceName} in ${projectRoot}.`,
+                `Artifact directory: ${result.artifactDir}`,
+                `State file: ${result.statePath}`,
+                `Config path: ${configInfo.path}${configInfo.exists ? "" : " (default config fallback)"}`,
+            ];
+            if (result.createdFiles.length > 0) {
+                lines.push(`Created files: ${result.createdFiles.length}`);
+            }
+            else {
+                lines.push("No files were recreated.");
+            }
+            return lines.join("\n");
+        },
+    });
+}

package/dist/tools/akane-stage-artifact.d.ts

@@ -0,0 +1,26 @@
+import type { LoadedAkaneConfig } from "../types.js";
+export declare function createAkaneStageArtifactTool(configInfo: LoadedAkaneConfig): {
+    description: string;
+    args: {
+        stage: 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";
+        }>;
+        content: import("zod").ZodString;
+        mode: import("zod").ZodDefault<import("zod").ZodEnum<{
+            append: "append";
+            replace: "replace";
+        }>>;
+        projectRoot: import("zod").ZodOptional<import("zod").ZodString>;
+    };
+    execute(args: {
+        stage: "plan" | "plan-review" | "implementation-context" | "review-codex" | "review-claude" | "final-synthesis";
+        content: string;
+        mode: "append" | "replace";
+        projectRoot?: string | undefined;
+    }, context: import("@opencode-ai/plugin/tool").ToolContext): Promise<string>;
+};

package/dist/tools/akane-stage-artifact.js

@@ -0,0 +1,55 @@
+import { tool } from "@opencode-ai/plugin/tool";
+import { AKANE_STAGE_IDS } from "../constants.js";
+import { resolveProjectRoot, writeStageArtifact } from "../artifacts.js";
+export function createAkaneStageArtifactTool(configInfo) {
+    return tool({
+        description: "Write deterministic stage artifacts into .opencode/akane and update Akane state.json.",
+        args: {
+            stage: tool.schema
+                .enum(AKANE_STAGE_IDS)
+                .describe("The workflow stage whose artifact file should be written."),
+            content: tool.schema
+                .string()
+                .describe("Markdown content to write into the selected stage artifact."),
+            mode: tool.schema
+                .enum(["replace", "append"])
+                .default("replace")
+                .describe("Replace the artifact content or append to the existing file."),
+            projectRoot: tool.schema
+                .string()
+                .optional()
+                .describe("Optional project root override. Defaults to the current session worktree."),
+        },
+        async execute(args, context) {
+            const projectRoot = resolveProjectRoot({
+                directory: context.directory,
+                worktree: context.worktree,
+                projectRoot: args.projectRoot,
+            });
+            const result = await writeStageArtifact({
+                projectRoot,
+                config: configInfo.config,
+                configPath: configInfo.path,
+                stage: args.stage,
+                content: args.content,
+                mode: args.mode,
+            });
+            context.metadata({
+                title: `Akane stage updated: ${args.stage}`,
+                metadata: {
+                    stage: args.stage,
+                    mode: args.mode,
+                    artifactPath: result.artifactPath,
+                    statePath: result.statePath,
+                    projectRoot,
+                },
+            });
+            return [
+                `Updated stage ${args.stage}.`,
+                `Artifact: ${result.artifactPath}`,
+                `State: ${result.statePath}`,
+                `Mode: ${args.mode}`,
+            ].join("\n");
+        },
+    });
+}

package/dist/types.d.ts

@@ -0,0 +1,46 @@
+import type { AKANE_ROLE_IDS, AKANE_STAGE_IDS, DEFAULT_ROLE_MODELS, DEFAULT_STAGE_FILES } from "./constants.js";
+export type AkaneStageId = (typeof AKANE_STAGE_IDS)[number];
+export type AkaneRoleId = (typeof AKANE_ROLE_IDS)[number];
+export type AkaneRoles = Record<AkaneRoleId, string>;
+export type AkaneStageFiles = Record<AkaneStageId, string>;
+export interface AkaneConfig {
+    version: number;
+    serviceName: string;
+    pluginOutputPath: string;
+    globalConfigPath: string;
+    artifacts: {
+        dir: string;
+        stateFile: string;
+        files: AkaneStageFiles;
+    };
+    workflow: {
+        stageOrder: AkaneStageId[];
+    };
+    roles: AkaneRoles;
+}
+export interface LoadedAkaneConfig {
+    path: string;
+    exists: boolean;
+    config: AkaneConfig;
+}
+export interface AkaneStageState {
+    path: string;
+    status: "pending" | "initialized" | "completed";
+    updatedAt: string | null;
+}
+export interface AkaneState {
+    version: number;
+    serviceName: string;
+    configPath: string;
+    projectRoot: string;
+    artifactDir: string;
+    initializedAt: string;
+    updatedAt: string;
+    activeStage: AkaneStageId | null;
+    stageOrder: AkaneStageId[];
+    stages: Record<AkaneStageId, AkaneStageState>;
+    roles: AkaneRoles;
+}
+export type ArtifactWriteMode = "append" | "replace";
+export type RoleModelDefaults = typeof DEFAULT_ROLE_MODELS;
+export type StageFileDefaults = typeof DEFAULT_STAGE_FILES;

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/examples/akane.example.json

@@ -0,0 +1,38 @@
+{
+  "version": 1,
+  "serviceName": "Akane",
+  "pluginOutputPath": "~/.config/opencode/plugins/akane.js",
+  "globalConfigPath": "~/.config/opencode/akane.json",
+  "artifacts": {
+    "dir": ".opencode/akane",
+    "stateFile": "state.json",
+    "files": {
+      "plan": "plan.md",
+      "plan-review": "plan-review.md",
+      "implementation-context": "implementation-context.md",
+      "review-codex": "review-codex.md",
+      "review-claude": "review-claude.md",
+      "final-synthesis": "final-synthesis.md"
+    }
+  },
+  "workflow": {
+    "stageOrder": [
+      "plan",
+      "plan-review",
+      "implementation-context",
+      "review-codex",
+      "review-claude",
+      "final-synthesis"
+    ]
+  },
+  "roles": {
+    "planner": "anthropic/claude-opus-4-6",
+    "plan_reviewer": "openai/gpt-5.4",
+    "implementer": "openai/gpt-5.4",
+    "consultant_primary": "anthropic/claude-opus-4-6",
+    "consultant_secondary": "anthropic/claude-sonnet-4-6",
+    "reviewer_codex": "openai/gpt-5.4",
+    "reviewer_claude": "anthropic/claude-opus-4-6",
+    "synthesizer": "openai/gpt-5.4"
+  }
+}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "opencode-akane",
+  "version": "0.1.0",
+  "description": "Akane orchestration plugin for OpenCode",
+  "license": "MIT",
+  "type": "module",
+  "keywords": [
+    "opencode",
+    "plugin",
+    "akane",
+    "automation"
+  ],
+  "homepage": "https://github.com/NaturaAurum/akane-agents#readme",
+  "bugs": {
+    "url": "https://github.com/NaturaAurum/akane-agents/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/NaturaAurum/akane-agents.git"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "examples/akane.example.json"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "clean": "rm -rf dist",
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "pack:check": "npm pack --dry-run",
+    "prepublishOnly": "bun run clean && bun run build && bun run typecheck"
+  },
+  "dependencies": {
+    "@opencode-ai/plugin": "1.2.20"
+  },
+  "devDependencies": {
+    "@types/node": "^24.12.0",
+    "typescript": "^5.9.3"
+  }
+}