oh-my-opencode-serverlocal 0.1.0

package/dist/utils/agent-variant.d.ts

@@ -0,0 +1,23 @@
+import { type PluginConfig } from '../config';
+/**
+ * Normalizes an agent name by trimming whitespace and removing the optional @ prefix.
+ *
+ * @param agentName - The agent name to normalize (e.g., "@oracle" or "oracle")
+ * @returns The normalized agent name without @ prefix and trimmed of whitespace
+ *
+ * @example
+ * normalizeAgentName("@oracle") // returns "oracle"
+ * normalizeAgentName("  explore  ") // returns "explore"
+ */
+export declare function normalizeAgentName(agentName: string): string;
+/**
+ * Resolve a runtime-provided agent name to an internal agent name.
+ *
+ * Supports:
+ * - internal names (e.g. "oracle")
+ * - @-prefixed names (e.g. "@oracle")
+ * - displayName aliases (e.g. "advisor" -> "oracle")
+ */
+export declare function resolveRuntimeAgentName(config: PluginConfig | undefined, agentName: string): string;
+export type DisplayNameMentionRewriter = (text: string) => string;
+export declare function createDisplayNameMentionRewriter(config: PluginConfig | undefined): DisplayNameMentionRewriter;

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

@@ -0,0 +1,113 @@
+import type { BackgroundJobStore } from './background-job-store';
+import { type TaskOutputState } from './task';
+export interface ContextFile {
+    path: string;
+    lineCount: number;
+    lineNumbers?: number[];
+    lastReadAt: number;
+}
+export type BackgroundJobState = TaskOutputState | 'reconciled';
+export interface BackgroundJobRecord {
+    taskID: string;
+    parentSessionID: string;
+    agent: string;
+    description: string;
+    objective?: string;
+    state: BackgroundJobState;
+    timedOut: boolean;
+    recoverableAfterLiveBusy: boolean;
+    statusUncertain: boolean;
+    cancellationRequested: boolean;
+    terminalUnreconciled: boolean;
+    launchedAt: number;
+    lastLaunchedAt: number;
+    updatedAt: number;
+    lastLiveBusyAt?: number;
+    completedAt?: number;
+    resultSummary?: string;
+    lastStatusError?: string;
+    alias: string;
+    lastUsedAt: number;
+    terminalState?: TaskOutputState;
+    contextFiles: ContextFile[];
+    totalErrors?: number;
+    timeoutCount?: number;
+    lastErrorAt?: number;
+}
+export interface BackgroundJobBoardOptions {
+    maxReusablePerAgent?: number;
+    readContextMinLines?: number;
+    readContextMaxFiles?: number;
+}
+export interface BackgroundJobLaunchInput {
+    taskID: string;
+    parentSessionID: string;
+    agent: string;
+    description?: string;
+    objective?: string;
+    now?: number;
+}
+export interface BackgroundJobStatusInput {
+    taskID: string;
+    state: TaskOutputState;
+    timedOut?: boolean;
+    statusUncertain?: boolean;
+    resultSummary?: string;
+    lastStatusError?: string;
+    now?: number;
+}
+type TerminalStateListener = (taskID: string) => void;
+export declare class BackgroundJobBoard implements BackgroundJobStore {
+    private readonly jobs;
+    private readonly counters;
+    private terminalStateListeners;
+    private readonly maxReusablePerAgent;
+    private readonly readContextMinLines;
+    private readonly readContextMaxFiles;
+    constructor(options?: BackgroundJobBoardOptions);
+    addTerminalStateListener(listener: TerminalStateListener): void;
+    removeTerminalStateListener(listener: TerminalStateListener): void;
+    setTerminalStateListener(listener?: TerminalStateListener): void;
+    private notifyTerminalStateListeners;
+    registerLaunch(input: BackgroundJobLaunchInput): BackgroundJobRecord;
+    updateStatus(input: BackgroundJobStatusInput): BackgroundJobRecord | undefined;
+    updateFromStatusOutput(output: string): BackgroundJobRecord | undefined;
+    markRunningFromLiveSession(taskID: string, now?: number): BackgroundJobRecord | undefined;
+    markReconciled(taskID: string, now?: number): BackgroundJobRecord | undefined;
+    markCancelled(taskID: string, reason?: string, now?: number, options?: {
+        force?: boolean;
+    }): BackgroundJobRecord | undefined;
+    get(taskID: string): BackgroundJobRecord | undefined;
+    field<K extends keyof BackgroundJobRecord>(taskID: string, key: K): BackgroundJobRecord[K] | undefined;
+    isRunning(taskID: string): boolean;
+    isTerminalUnreconciled(taskID: string): boolean;
+    getResultSummary(taskID: string): string | undefined;
+    getLastLiveBusyAt(taskID: string): number | undefined;
+    getParentSessionID(taskID: string): string | undefined;
+    getState(taskID: string): BackgroundJobState | undefined;
+    resolve(parentSessionID: string, taskIDOrAlias: string): BackgroundJobRecord | undefined;
+    resolveReusable(parentSessionID: string, taskIDOrAlias: string, agent?: string): BackgroundJobRecord | undefined;
+    resolveRecoverable(parentSessionID: string, taskIDOrAlias: string, agent?: string): BackgroundJobRecord | undefined;
+    markUsed(parentSessionID: string, key: string, now?: number): void;
+    taskIDs(): Set<string>;
+    addContext(taskID: string, files: ContextFile[]): void;
+    list(parentSessionID?: string): BackgroundJobRecord[];
+    hasRunning(parentSessionID: string): boolean;
+    hasTerminalUnreconciled(parentSessionID: string): boolean;
+    hasConvergenceSignals(taskID: string, threshold?: number): boolean;
+    formatForPrompt(parentSessionID: string, _now?: number): string | undefined;
+    clearParent(parentSessionID: string): void;
+    drop(taskID: string): void;
+    deferIfRunning(_sessionId: string): boolean;
+    retryDeferredClose(_sessionId: string): boolean;
+    clearDeferredClose(_sessionId: string): void;
+    private trimReusable;
+    private formatReusableJob;
+    private nextAlias;
+}
+export declare function deriveTaskSessionLabel(input: {
+    description?: string;
+    prompt?: string;
+    agentType: string;
+}): string;
+export {};

package/dist/utils/background-job-coordinator.d.ts

@@ -0,0 +1,72 @@
+import type { BackgroundJobBoard, BackgroundJobLaunchInput, BackgroundJobRecord, BackgroundJobStatusInput, ContextFile } from './background-job-board';
+import type { BackgroundJobStore } from './background-job-store';
+import type { TaskOutputState } from './task';
+type TerminalStateListener = (taskID: string) => void;
+/**
+ * BackgroundJobCoordinator owns the lifecycle policy for background jobs.
+ * It sits between the board and its consumers, providing:
+ * - Subscription interface for terminal state notifications (replaces fire-and-forget)
+ * - Lifecycle policy: determines when jobs are terminal, when closes should be deferred
+ * - Single-writer contract: coordinator is the sole writer to the board
+ *
+ * The board's guards prevent silent overwrites. The coordinator adds:
+ * - Centralized notification with guaranteed delivery
+ * - Re-checks board state before notifying (handles races)
+ */
+export declare class BackgroundJobCoordinator implements BackgroundJobStore {
+    private readonly board;
+    private terminalStateListeners;
+    private readonly deferredIdleCloses;
+    constructor(board: BackgroundJobBoard);
+    addTerminalStateListener(listener: TerminalStateListener): void;
+    removeTerminalStateListener(listener: TerminalStateListener): void;
+    /**
+     * Handle terminal state from board. Re-checks board state to handle races.
+     * This is the centralized lifecycle policy.
+     */
+    private handleTerminalState;
+    /**
+     * Evaluate close policy. Returns true if session should close now.
+     * Mutates deferred state: adds to deferred set if running, removes if not.
+     */
+    deferIfRunning(sessionId: string): boolean;
+    /**
+     * Retry closing a deferred session. Called when a background job completes.
+     * Returns true if the session should now close.
+     */
+    retryDeferredClose(sessionId: string): boolean;
+    /**
+     * Clear deferred close state for a session being deleted.
+     */
+    clearDeferredClose(sessionId: string): void;
+    registerLaunch(input: BackgroundJobLaunchInput): BackgroundJobRecord;
+    updateStatus(input: BackgroundJobStatusInput): BackgroundJobRecord | undefined;
+    updateFromStatusOutput(output: string): BackgroundJobRecord | undefined;
+    markRunningFromLiveSession(taskID: string, now?: number): BackgroundJobRecord | undefined;
+    markReconciled(taskID: string, now?: number): BackgroundJobRecord | undefined;
+    markCancelled(taskID: string, reason?: string, now?: number, options?: {
+        force?: boolean;
+    }): BackgroundJobRecord | undefined;
+    get(taskID: string): BackgroundJobRecord | undefined;
+    field<K extends keyof BackgroundJobRecord>(taskID: string, key: K): BackgroundJobRecord[K] | undefined;
+    isRunning(taskID: string): boolean;
+    isTerminalUnreconciled(taskID: string): boolean;
+    getResultSummary(taskID: string): string | undefined;
+    getLastLiveBusyAt(taskID: string): number | undefined;
+    getParentSessionID(taskID: string): string | undefined;
+    getState(taskID: string): TaskOutputState | 'reconciled' | undefined;
+    resolve(parentSessionID: string, taskIDOrAlias: string): BackgroundJobRecord | undefined;
+    resolveReusable(parentSessionID: string, taskIDOrAlias: string, agent?: string): BackgroundJobRecord | undefined;
+    resolveRecoverable(parentSessionID: string, taskIDOrAlias: string, agent?: string): BackgroundJobRecord | undefined;
+    markUsed(parentSessionID: string, key: string, now?: number): void;
+    taskIDs(): Set<string>;
+    addContext(taskID: string, files: ContextFile[]): void;
+    list(parentSessionID?: string): BackgroundJobRecord[];
+    hasRunning(parentSessionID: string): boolean;
+    hasTerminalUnreconciled(parentSessionID: string): boolean;
+    hasConvergenceSignals(taskID: string, threshold?: number): boolean;
+    formatForPrompt(parentSessionID: string, now?: number): string | undefined;
+    clearParent(parentSessionID: string): void;
+    drop(taskID: string): void;
+}
+export {};

package/dist/utils/background-job-store.d.ts

@@ -0,0 +1,46 @@
+import type { BackgroundJobLaunchInput, BackgroundJobRecord, BackgroundJobStatusInput, ContextFile } from './background-job-board';
+import type { TaskOutputState } from './task';
+/**
+ * Unified interface for background job operations.
+ * Both BackgroundJobBoard and BackgroundJobCoordinator satisfy this.
+ *
+ * ponytail: single interface, both board and coordinator implement it.
+ */
+export interface BackgroundJobStore {
+    registerLaunch(input: BackgroundJobLaunchInput): BackgroundJobRecord;
+    updateStatus(input: BackgroundJobStatusInput): BackgroundJobRecord | undefined;
+    updateFromStatusOutput(output: string): BackgroundJobRecord | undefined;
+    markRunningFromLiveSession(taskID: string, now?: number): BackgroundJobRecord | undefined;
+    markReconciled(taskID: string, now?: number): BackgroundJobRecord | undefined;
+    markCancelled(taskID: string, reason?: string, now?: number, options?: {
+        force?: boolean;
+    }): BackgroundJobRecord | undefined;
+    clearParent(parentSessionID: string): void;
+    drop(taskID: string): void;
+    addContext(taskID: string, files: ContextFile[]): void;
+    markUsed(parentSessionID: string, key: string, now?: number): void;
+    get(taskID: string): BackgroundJobRecord | undefined;
+    field<K extends keyof BackgroundJobRecord>(taskID: string, key: K): BackgroundJobRecord[K] | undefined;
+    isRunning(taskID: string): boolean;
+    isTerminalUnreconciled(taskID: string): boolean;
+    getResultSummary(taskID: string): string | undefined;
+    getLastLiveBusyAt(taskID: string): number | undefined;
+    getParentSessionID(taskID: string): string | undefined;
+    getState(taskID: string): TaskOutputState | 'reconciled' | undefined;
+    resolve(parentSessionID: string, taskIDOrAlias: string): BackgroundJobRecord | undefined;
+    resolveReusable(parentSessionID: string, taskIDOrAlias: string, agent?: string): BackgroundJobRecord | undefined;
+    resolveRecoverable(parentSessionID: string, taskIDOrAlias: string, agent?: string): BackgroundJobRecord | undefined;
+    taskIDs(): Set<string>;
+    list(parentSessionID?: string): BackgroundJobRecord[];
+    hasRunning(parentSessionID: string): boolean;
+    hasTerminalUnreconciled(parentSessionID: string): boolean;
+    hasConvergenceSignals(taskID: string, threshold?: number): boolean;
+    formatForPrompt(parentSessionID: string, now?: number): string | undefined;
+    /** Evaluate close policy. Returns true if session should close now.
+     *  Mutates deferred state: adds to deferred set if running, removes if not. */
+    deferIfRunning(sessionId: string): boolean;
+    /** Retry closing a deferred session. Returns true if session should now close. */
+    retryDeferredClose(sessionId: string): boolean;
+    /** Clear deferred close state for a session being deleted. */
+    clearDeferredClose(sessionId: string): void;
+}

package/dist/utils/compat.d.ts

@@ -0,0 +1,29 @@
+import type { ChildProcess } from 'node:child_process';
+export interface CrossSpawnResult {
+    proc: ChildProcess;
+    /** Collects all stdout into a string */
+    stdout: () => Promise<string>;
+    /** Collects all stderr into a string */
+    stderr: () => Promise<string>;
+    /** Resolves when process exits with exit code */
+    exited: Promise<number>;
+    /** Kill the process */
+    kill: (signal?: NodeJS.Signals | number) => boolean;
+    /** Current exit code or null if running */
+    get exitCode(): number | null;
+}
+/**
+ * Cross-runtime spawn that works in both Bun and Node.js.
+ * API mimics Bun.spawn but uses node:child_process internally.
+ */
+export declare function crossSpawn(command: string[], options?: {
+    stdout?: 'pipe' | 'inherit' | 'ignore';
+    stderr?: 'pipe' | 'inherit' | 'ignore';
+    stdin?: 'pipe' | 'inherit' | 'ignore';
+    cwd?: string;
+    env?: Record<string, string | undefined>;
+}): CrossSpawnResult;
+/**
+ * Cross-runtime file write that works in both Bun and Node.js.
+ */
+export declare function crossWrite(path: string, data: ArrayBuffer | Buffer | string): Promise<void>;

package/dist/utils/councillor-models.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Pure helpers for councillor model fallback chains.
+ *
+ * Kept free of any schema/validation library import so that runtime consumers
+ * (e.g. `CouncilManager`) can resolve a councillor's ordered model chain
+ * without pulling in zod or the config schema module.
+ */
+/** A single model in a councillor fallback chain, with optional variant. */
+export type CouncillorModelEntry = {
+    id: string;
+    variant?: string;
+};
+/**
+ * Flatten a councillor model config into an ordered list of model entries.
+ *
+ * Accepts either a single "provider/model" string or an ordered fallback
+ * chain (array of strings and/or `{ id, variant }` entries). Entries that
+ * don't carry their own variant fall back to the shared `fallbackVariant`.
+ */
+export declare function normalizeCouncillorModels(model: string | Array<string | CouncillorModelEntry>, fallbackVariant?: string): CouncillorModelEntry[];

package/dist/utils/env.d.ts

@@ -0,0 +1,3 @@
+export declare const PLUGIN_DISABLE_ENV = "OH_MY_OPENCODE_SLIM_DISABLE";
+export declare function isTruthyEnvValue(value: string | undefined): boolean;
+export declare function isPluginDisabledByEnv(env?: NodeJS.ProcessEnv): boolean;

package/dist/utils/escape-html.d.ts

@@ -0,0 +1 @@
+export declare function escapeHtml(value: string): string;

package/dist/utils/frontmatter.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Parse `---` delimited frontmatter from a string.
+ * Handles both `\n` and `\r\n` line endings.
+ * Returns null if no frontmatter is found.
+ */
+export declare function parseFrontmatter(content: string): Record<string, string> | null;

package/dist/utils/guards.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Shared type guard: checks if a value is a non-null object.
+ */
+export declare function isRecord(value: unknown): value is Record<string, unknown>;

package/dist/utils/index.d.ts

@@ -0,0 +1,10 @@
+export * from './agent-variant';
+export * from './background-job-board';
+export * from './background-job-coordinator';
+export * from './background-job-store';
+export * from './internal-initiator';
+export { initLogger, log } from './logger';
+export * from './polling';
+export * from './session';
+export * from './task';
+export { extractZip } from './zip-extractor';

package/dist/utils/internal-initiator.d.ts

@@ -0,0 +1,11 @@
+export declare const SLIM_INTERNAL_INITIATOR_MARKER = "<!-- SLIM_INTERNAL_INITIATOR -->";
+export declare const INTERNAL_INITIATOR_METADATA_KEY = "oh-my-opencode-slim.internalInitiator";
+export declare function createInternalAgentTextPart(text: string): {
+    type: 'text';
+    text: string;
+    synthetic: true;
+    metadata: {
+        'oh-my-opencode-slim.internalInitiator': true;
+    };
+};
+export declare function isInternalInitiatorPart(part: unknown): boolean;

package/dist/utils/logger.d.ts

@@ -0,0 +1,6 @@
+export declare function initLogger(sessionId: string): void;
+/** @internal Reset logger state for testing */
+export declare function resetLogger(): void;
+/** @internal Wait for queued log writes in tests. */
+export declare function flushLoggerForTesting(): Promise<void>;
+export declare function log(message: string, data?: unknown): void;

package/dist/utils/polling.d.ts

@@ -0,0 +1,21 @@
+export interface PollOptions {
+    pollInterval?: number;
+    maxPollTime?: number;
+    stableThreshold?: number;
+    signal?: AbortSignal;
+}
+export interface PollResult<T> {
+    success: boolean;
+    data?: T;
+    timedOut?: boolean;
+    aborted?: boolean;
+}
+/**
+ * Generic polling utility that waits for a condition to be met.
+ * Returns when the condition is satisfied or timeout/abort occurs.
+ */
+export declare function pollUntilStable<T>(fetchFn: () => Promise<T>, isStable: (current: T, previous: T | null, stableCount: number) => boolean, opts?: PollOptions): Promise<PollResult<T>>;
+/**
+ * Simple delay utility
+ */
+export declare function delay(ms: number): Promise<void>;

package/dist/utils/session.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Shared session utilities for council and background managers.
+ */
+import type { PluginInput } from '@opencode-ai/plugin';
+type OpencodeClient = PluginInput['client'];
+export declare const SESSION_ABORT_TIMEOUT_MS = 1000;
+export declare class OperationTimeoutError extends Error {
+    constructor(message: string);
+}
+export declare function withTimeout<T>(operation: Promise<T>, timeoutMs: number, message: string): Promise<T>;
+export declare function abortSessionWithTimeout(client: OpencodeClient, sessionId: string, timeoutMs?: number): Promise<void>;
+/**
+ * Extract the short model label from a "provider/model" string.
+ * E.g. "openai/gpt-5.6-luna" → "gpt-5.6-luna"
+ */
+export declare function shortModelLabel(model: string): string;
+export type PromptBody = {
+    messageID?: string;
+    model?: {
+        providerID: string;
+        modelID: string;
+    };
+    agent?: string;
+    noReply?: boolean;
+    system?: string;
+    tools?: {
+        [key: string]: boolean;
+    };
+    parts: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    variant?: string;
+};
+/**
+ * Parse a model reference string into provider and model IDs.
+ * @param model - Model string in format "provider/model"
+ * @returns Object with providerID and modelID, or null if invalid
+ */
+export declare function parseModelReference(model: string): {
+    providerID: string;
+    modelID: string;
+} | null;
+/**
+ * Send a prompt to a session with optional timeout.
+ * If timeout is exceeded, the session is aborted and an error is thrown.
+ * @param client - OpenCode client instance
+ * @param args - Arguments for session.prompt()
+ * @param timeoutMs - Timeout in milliseconds (0 = no timeout)
+ * @throws Error if timeout is exceeded
+ */
+export declare function promptWithTimeout(client: OpencodeClient, args: Parameters<OpencodeClient['session']['prompt']>[0], timeoutMs: number, signal?: AbortSignal): Promise<void>;
+/**
+ * Result of extracting session content.
+ * `empty` is true when the assistant produced zero text content -
+ * the provider returned an empty response (e.g. rate-limited silently).
+ */
+export interface SessionExtractionResult {
+    text: string;
+    empty: boolean;
+}
+/**
+ * Extract the result text from a session.
+ * Collects all assistant messages and concatenates their text parts.
+ * @param client - OpenCode client instance
+ * @param sessionId - Session ID to extract from
+ * @param options - Optional: `includeReasoning` (default true) controls whether
+ *                  reasoning/chain-of-thought parts are included.
+ * @returns Object with extracted text and an `empty` flag for zero-content detection
+ */
+export declare function extractSessionResult(client: OpencodeClient, sessionId: string, options?: {
+    directory?: string;
+    includeReasoning?: boolean;
+}): Promise<SessionExtractionResult>;
+export {};

package/dist/utils/subagent-depth.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Tracks subagent spawn depth to prevent excessive nesting.
+ *
+ * Depth 0 = root session (user's main conversation)
+ * Depth 1 = agent spawned by root (e.g., explorer, council)
+ * Depth 2 = agent spawned by depth-1 agent (e.g., councillor spawned by council)
+ * Depth 3 = agent spawned by depth-2 agent (max depth by default)
+ *
+ * When max depth is exceeded, the spawn is blocked.
+ */
+export declare class SubagentDepthTracker {
+    private depthBySession;
+    private readonly _maxDepth;
+    constructor(maxDepth?: number);
+    /** Maximum allowed depth. */
+    get maxDepth(): number;
+    /**
+     * Get the current depth of a session.
+     * Root sessions (not tracked) have depth 0.
+     */
+    getDepth(sessionId: string): number;
+    /**
+     * Register a child session and check if the spawn is allowed.
+     * @returns true if allowed, false if max depth exceeded
+     */
+    registerChild(parentSessionId: string, childSessionId: string): boolean;
+    /**
+     * Clean up session tracking when a session is deleted.
+     */
+    cleanup(sessionId: string): void;
+    /**
+     * Clean up all tracking data.
+     */
+    cleanupAll(): void;
+}

package/dist/utils/system-collapse.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Collapse a system message array into a single element by joining all
+ * entries with double-newline separators. Mutates the array in-place so
+ * that callers holding a reference to the original array see the change.
+ */
+export declare function collapseSystemInPlace(system: string[]): void;

package/dist/utils/task.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Parse Task tool output to recover a session/task ID for resumption.
+ */
+export type TaskOutputState = 'running' | 'completed' | 'error' | 'cancelled';
+export interface TaskLaunchOutput {
+    taskID: string;
+    state: 'running';
+    result?: string;
+}
+export interface TaskStatusOutput {
+    taskID: string;
+    state: TaskOutputState;
+    timedOut: boolean;
+    result?: string;
+}
+export declare function parseTaskIdFromTaskOutput(output: string): string | undefined;
+export declare function parseTaskLaunchOutput(output: string): TaskLaunchOutput | undefined;
+export declare function parseTaskStatusOutput(output: string): TaskStatusOutput | undefined;
+export declare function parseTaskStateFromOutput(output: string): TaskOutputState | undefined;
+export declare function parseTaskResultFromOutput(output: string): string | undefined;

package/dist/utils/zip-extractor.d.ts

@@ -0,0 +1 @@
+export declare function extractZip(archivePath: string, destDir: string): Promise<void>;

package/package.json

@@ -0,0 +1,108 @@
+{
+  "name": "oh-my-opencode-serverlocal",
+  "version": "0.1.0",
+  "description": "Custom serverlocal fork of oh-my-opencode-slim — fully owned, custom prompts + commands, dist synced via opencode-dotfiles",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./tui": {
+      "import": "./dist/tui.js",
+      "types": "./dist/tui.d.ts"
+    }
+  },
+  "bin": {
+    "oh-my-opencode-serverlocal": "./dist/cli/index.js"
+  },
+  "type": "module",
+  "license": "MIT",
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "ai",
+    "agents",
+    "orchestration",
+    "serverlocal",
+    "fork",
+    "claude",
+    "gpt",
+    "gemini"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Darthph0enix7/oh-my-opencode-serverlocal"
+  },
+  "bugs": {
+    "url": "https://github.com/Darthph0enix7/oh-my-opencode-serverlocal/issues"
+  },
+  "homepage": "https://github.com/Darthph0enix7/oh-my-opencode-serverlocal#readme",
+  "files": [
+    "dist",
+    "src/companion/companion-manifest.json",
+    "src/skills",
+    "oh-my-opencode-slim.schema.json",
+    "README.md",
+    "README.zh-CN.md",
+    "README.ja-JP.md",
+    "README.ko-KR.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "clean:dist": "bun -e \"import { rmSync } from 'node:fs'; rmSync('dist', { recursive: true, force: true })\"",
+    "build:plugin": "bun build src/index.ts src/tui.ts --outdir dist --target node --format esm --external @ast-grep/napi --external @opencode-ai/plugin --external @opencode-ai/plugin/* --external @opencode-ai/sdk --external @opencode-ai/sdk/* --external @opentui/core --external @opentui/solid --external jsdom --external zod",
+    "build:cli": "bun build src/cli/index.ts --outdir dist/cli --target node --format esm --external @ast-grep/napi --external @opencode-ai/plugin --external @opencode-ai/plugin/* --external @opencode-ai/sdk --external @opencode-ai/sdk/* --external jsdom --external zod",
+    "build": "bun run clean:dist && bun run build:plugin && bun run build:cli && tsc --emitDeclarationOnly && bun run generate-schema",
+    "prepare": "bun run build",
+    "contributors:add": "all-contributors add",
+    "contributors:check": "all-contributors check",
+    "contributors:generate": "all-contributors generate",
+    "generate-schema": "bun run scripts/generate-schema.ts",
+    "verify:release": "bun run scripts/verify-release-artifact.ts",
+    "verify:host-smoke": "bun run scripts/verify-opencode-host-smoke.ts",
+    "typecheck": "tsc --noEmit",
+    "test": "bun test",
+    "lint": "biome lint .",
+    "format": "biome format . --write",
+    "check": "biome check --write .",
+    "check:ci": "biome check .",
+    "dev": "bun run build && opencode",
+    "prepublishOnly": "bun run build",
+    "release:patch": "npm version patch && git push --follow-tags && npm publish",
+    "release:minor": "npm version minor && git push --follow-tags && npm publish",
+    "release:major": "npm version major && git push --follow-tags && npm publish",
+    "release:beta": "npm version premajor --preid beta && git push --follow-tags && npm publish --tag beta",
+    "release:beta:next": "npm version prerelease --preid beta && git push --follow-tags && npm publish --tag beta"
+  },
+  "dependencies": {
+    "@ast-grep/cli": "^0.42.1",
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@mozilla/readability": "^0.6.0",
+    "@opencode-ai/plugin": "^1.3.17",
+    "@opencode-ai/sdk": "^1.3.17",
+    "jsdom": "^26.1.0",
+    "lru-cache": "^11.3.3",
+    "turndown": "^7.2.4"
+  },
+  "optionalDependencies": {
+    "@opentui/solid": "^0.1.97"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "2.4.11",
+    "@types/jsdom": "^21.1.7",
+    "@types/node": "^24.6.1",
+    "@types/turndown": "^5.0.6",
+    "all-contributors-cli": "^6.26.1",
+    "bun-types": "1.3.12",
+    "typescript": "^5.9.3",
+    "zod": "^4.3.6"
+  },
+  "peerDependencies": {
+    "zod": "^4.0.0"
+  },
+  "trustedDependencies": [
+    "@ast-grep/cli"
+  ]
+}

package/src/companion/companion-manifest.json

@@ -0,0 +1,12 @@
+{
+  "version": "0.1.3",
+  "tag": "companion-v0.1.3",
+  "repo": "alvinunreal/oh-my-opencode-slim",
+  "checksums": {
+    "oh-my-opencode-slim-companion-v0.1.3-aarch64-apple-darwin.tar.gz": "b4885f9b1900c02376e5f8f5ae6f3b8a89d26f7514b03f836d7e3d618164a0ed",
+    "oh-my-opencode-slim-companion-v0.1.3-aarch64-unknown-linux-gnu.tar.gz": "ed7cffc583e1eaa78c9bea702e6b6aa3bbc5bb4d881713fb2050237ba6b7aca5",
+    "oh-my-opencode-slim-companion-v0.1.3-x86_64-apple-darwin.tar.gz": "98d8ea7c7bc4415b18e0d4c524adb4eb9a84c872919840fdc021f0f50c61f808",
+    "oh-my-opencode-slim-companion-v0.1.3-x86_64-pc-windows-msvc.zip": "9316a49bf01f3b4fb1ce2d62edfc46094e73bb153d6ce023fb7df085afcf77bd",
+    "oh-my-opencode-slim-companion-v0.1.3-x86_64-unknown-linux-gnu.tar.gz": "33f5fd4b6c80155a019391e5efb13904ca9531ba8dd8c6cba30a161f1b07b764"
+  }
+}