@opencode-ai/core 0.0.0-dev-17471

package/dist/types/session/usage.d.ts

@@ -0,0 +1,13 @@
+export * as SessionUsage from "./usage.js";
+import type { Usage } from "@opencode-ai/ai";
+import { Money } from "@opencode-ai/schema/money";
+import type { TokenUsage } from "@opencode-ai/schema/token-usage";
+import type { Model } from "../model.js";
+export declare const tokens: (usage: Usage | undefined) => TokenUsage.Info;
+export declare function calculateCost(costs: Model.Info["cost"], usage: TokenUsage.Info): number & import("effect/Brand").Brand<"Money.USD">;
+export type Recorded = {
+    readonly tokens: TokenUsage.Info;
+    readonly cost: Money.USD;
+};
+export declare const record: (usage: Usage | undefined, costs: Model.Info["cost"]) => Recorded;
+export declare const add: (a: Recorded, b: Recorded) => Recorded;

package/dist/types/session.d.ts

@@ -0,0 +1,329 @@
+export * as Session from "./session.js";
+export * from "./session/schema.js";
+import { Effect, Schema, Context, Stream } from "effect";
+import { ListAnchor } from "@opencode-ai/schema/session";
+import { Model } from "./model.js";
+import { Location } from "./location.js";
+import { SessionMessage } from "./session/message.js";
+import { PromptInput } from "@opencode-ai/schema/prompt-input";
+import { SessionSchema } from "./session/schema.js";
+import { AbsolutePath } from "./schema.js";
+import { Agent } from "./agent.js";
+import { SessionRunner } from "./session/runner/index.js";
+import { ForkEmptyError, MessageDecodeError, NotFoundError } from "./session/error.js";
+import { SessionEvent } from "./session/event.js";
+import { SessionInbox } from "./session/inbox.js";
+import { SessionGenerate } from "./session/generate.js";
+import { Snapshot } from "./snapshot.js";
+import { SessionRevert } from "./session/revert.js";
+import { Session } from "@opencode-ai/schema/session";
+import type { EventLog } from "@opencode-ai/schema/event-log";
+import { Event } from "@opencode-ai/schema/event";
+import { Skill } from "./skill.js";
+import { Command } from "./command.js";
+export { ListAnchor };
+export declare const ListInput: Schema.Union<readonly [Schema.Struct<{
+    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    readonly workspaceID: Schema.optional<Schema.brand<Schema.String, "Workspace.ID"> & {
+        ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+        create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+    }>;
+    readonly search: Schema.optional<Schema.String>;
+    readonly limit: Schema.optional<Schema.Int>;
+    readonly order: Schema.optional<Schema.Literals<readonly ["asc", "desc"]>>;
+    readonly parentID: Schema.optional<Schema.NullOr<Schema.brand<Schema.String, "SessionID"> & {
+        create: () => string & import("effect/Brand").Brand<"SessionID">;
+        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+    }>>;
+    readonly anchor: Schema.optional<Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "SessionID"> & {
+            create: () => string & import("effect/Brand").Brand<"SessionID">;
+            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+        };
+        readonly time: Schema.Finite;
+        readonly direction: Schema.Literals<readonly ["previous", "next"]>;
+    }>>;
+}>, Schema.Struct<{
+    readonly project: Schema.brand<Schema.String, "Project.ID"> & {
+        global: string & import("effect/Brand").Brand<"Project.ID">;
+    };
+    readonly subpath: Schema.optional<Schema.brand<Schema.String, "RelativePath">>;
+    readonly workspaceID: Schema.optional<Schema.brand<Schema.String, "Workspace.ID"> & {
+        ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+        create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+    }>;
+    readonly search: Schema.optional<Schema.String>;
+    readonly limit: Schema.optional<Schema.Int>;
+    readonly order: Schema.optional<Schema.Literals<readonly ["asc", "desc"]>>;
+    readonly parentID: Schema.optional<Schema.NullOr<Schema.brand<Schema.String, "SessionID"> & {
+        create: () => string & import("effect/Brand").Brand<"SessionID">;
+        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+    }>>;
+    readonly anchor: Schema.optional<Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "SessionID"> & {
+            create: () => string & import("effect/Brand").Brand<"SessionID">;
+            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+        };
+        readonly time: Schema.Finite;
+        readonly direction: Schema.Literals<readonly ["previous", "next"]>;
+    }>>;
+}>, Schema.Struct<{
+    workspaceID: Schema.optional<Schema.brand<Schema.String, "Workspace.ID"> & {
+        ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+        create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+    }>;
+    search: Schema.optional<Schema.String>;
+    limit: Schema.optional<Schema.Int>;
+    order: Schema.optional<Schema.Literals<readonly ["asc", "desc"]>>;
+    parentID: Schema.optional<Schema.NullOr<Schema.brand<Schema.String, "SessionID"> & {
+        create: () => string & import("effect/Brand").Brand<"SessionID">;
+        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+    }>>;
+    anchor: Schema.optional<Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "SessionID"> & {
+            create: () => string & import("effect/Brand").Brand<"SessionID">;
+            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+        };
+        readonly time: Schema.Finite;
+        readonly direction: Schema.Literals<readonly ["previous", "next"]>;
+    }>>;
+}>]>;
+export type ListInput = typeof ListInput.Type;
+type CreateBaseInput = {
+    id?: SessionSchema.ID;
+    title?: string;
+    agent?: Agent.ID;
+    model?: Model.Ref;
+};
+type CreateInput = CreateBaseInput & ({
+    location: Location.Ref;
+    parentID?: never;
+} | {
+    parentID: SessionSchema.ID;
+    location?: never;
+});
+type CompactInput = {
+    id?: SessionMessage.ID;
+    sessionID: SessionSchema.ID;
+    delivery?: SessionInbox.Delivery;
+};
+type ForkInput = {
+    sessionID: SessionSchema.ID;
+    boundary: Session.ForkRequestBoundary;
+};
+export { MessageDecodeError, NotFoundError };
+declare const PromptConflictError_base: Schema.Class<PromptConflictError, Schema.TaggedStruct<"Session.PromptConflictError", {
+    readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+        create: () => string & import("effect/Brand").Brand<"SessionID">;
+        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+    };
+    readonly messageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
+        fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class PromptConflictError extends PromptConflictError_base {
+}
+declare const SyntheticConflictError_base: Schema.Class<SyntheticConflictError, Schema.TaggedStruct<"Session.SyntheticConflictError", {
+    readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+        create: () => string & import("effect/Brand").Brand<"SessionID">;
+        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+    };
+    readonly inputID: Schema.brand<Schema.String, "Session.Message.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
+        fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class SyntheticConflictError extends SyntheticConflictError_base {
+}
+declare const AttachmentError_base: Schema.Class<AttachmentError, Schema.TaggedStruct<"Session.AttachmentError", {
+    readonly uri: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class AttachmentError extends AttachmentError_base {
+}
+declare const CompactionConflictError_base: Schema.Class<CompactionConflictError, Schema.TaggedStruct<"Session.CompactionConflictError", {
+    readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+        create: () => string & import("effect/Brand").Brand<"SessionID">;
+        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+    };
+    readonly inputID: Schema.brand<Schema.String, "Session.Message.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
+        fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class CompactionConflictError extends CompactionConflictError_base {
+}
+declare const BusyError_base: Schema.Class<BusyError, Schema.TaggedStruct<"Session.BusyError", {
+    readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+        create: () => string & import("effect/Brand").Brand<"SessionID">;
+        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class BusyError extends BusyError_base {
+}
+declare const InboxConflictError_base: Schema.Class<InboxConflictError, Schema.TaggedStruct<"Session.InboxConflictError", {
+    readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+        create: () => string & import("effect/Brand").Brand<"SessionID">;
+        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+    };
+    readonly inboxID: Schema.brand<Schema.String, "Session.Message.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
+        fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class InboxConflictError extends InboxConflictError_base {
+}
+type InboxItemRef = {
+    readonly sessionID: SessionSchema.ID;
+    readonly inboxID: SessionMessage.ID;
+};
+declare const SkillNotFoundError_base: Schema.Class<SkillNotFoundError, Schema.TaggedStruct<"Session.SkillNotFoundError", {
+    readonly skill: Schema.brand<Schema.String, "Skill.ID">;
+}>, import("effect/Cause").YieldableError>;
+export declare class SkillNotFoundError extends SkillNotFoundError_base {
+}
+declare const DestinationNotFoundError_base: Schema.Class<DestinationNotFoundError, Schema.TaggedStruct<"Session.DestinationNotFoundError", {
+    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+}>, import("effect/Cause").YieldableError>;
+export declare class DestinationNotFoundError extends DestinationNotFoundError_base {
+}
+declare const DestinationNotDirectoryError_base: Schema.Class<DestinationNotDirectoryError, Schema.TaggedStruct<"Session.DestinationNotDirectoryError", {
+    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+}>, import("effect/Cause").YieldableError>;
+export declare class DestinationNotDirectoryError extends DestinationNotDirectoryError_base {
+}
+export declare const MessageNotFoundError: typeof SessionRevert.MessageNotFoundError;
+export type MessageNotFoundError = SessionRevert.MessageNotFoundError;
+export interface Interface {
+    readonly list: (input?: ListInput) => Effect.Effect<{
+        readonly data: SessionSchema.Info[];
+    }>;
+    readonly create: (input: CreateInput) => Effect.Effect<SessionSchema.Info, NotFoundError>;
+    readonly fork: (input: ForkInput) => Effect.Effect<SessionSchema.Info, NotFoundError | MessageNotFoundError | ForkEmptyError>;
+    readonly get: (sessionID: SessionSchema.ID) => Effect.Effect<SessionSchema.Info, NotFoundError>;
+    readonly remove: (sessionID: SessionSchema.ID) => Effect.Effect<void, NotFoundError>;
+    readonly messages: (input: {
+        sessionID: SessionSchema.ID;
+        limit?: number;
+        order?: "asc" | "desc";
+        cursor?: {
+            id: SessionMessage.ID;
+            direction: "previous" | "next";
+        };
+    }) => Effect.Effect<SessionMessage.Info[], NotFoundError | MessageDecodeError>;
+    readonly message: (input: {
+        sessionID: SessionSchema.ID;
+        messageID: SessionMessage.ID;
+    }) => Effect.Effect<SessionMessage.Info | undefined>;
+    readonly context: (sessionID: SessionSchema.ID) => Effect.Effect<SessionMessage.Info[], NotFoundError | MessageDecodeError>;
+    /**
+     * Durable admitted session work not yet visible in projected history,
+     * ordered by admission. Includes unpromoted user and synthetic inputs and
+     * unhandled compaction barriers.
+     */
+    readonly inbox: (sessionID: SessionSchema.ID) => Effect.Effect<SessionInbox.Info[], NotFoundError>;
+    readonly cancelInbox: (input: InboxItemRef) => Effect.Effect<void, NotFoundError | InboxConflictError>;
+    readonly steerInbox: (input: InboxItemRef) => Effect.Effect<void, NotFoundError | InboxConflictError>;
+    readonly queueInbox: (input: InboxItemRef) => Effect.Effect<void, NotFoundError | InboxConflictError>;
+    /**
+     * Durable, ordered session log read. Replays durable session bus after
+     * the exclusive `after` cursor, emits a `Synced` marker at the captured
+     * replay watermark, then continues live when `follow` is set.
+     * The marker's seq may exceed the last emitted event because other durable
+     * bus share the aggregate's sequence space.
+     */
+    readonly log: (input: {
+        sessionID: SessionSchema.ID;
+        after?: number;
+        follow?: boolean;
+    }) => Stream.Stream<SessionEvent.DurableEvent | EventLog.Synced, NotFoundError>;
+    readonly switchAgent: (input: {
+        sessionID: SessionSchema.ID;
+        agent: Agent.ID;
+    }) => Effect.Effect<void, NotFoundError>;
+    readonly switchModel: (input: {
+        sessionID: SessionSchema.ID;
+        model: Model.Ref;
+    }) => Effect.Effect<void, NotFoundError>;
+    readonly rename: (input: {
+        sessionID: SessionSchema.ID;
+        title: string;
+    }) => Effect.Effect<void, NotFoundError>;
+    readonly move: (input: {
+        sessionID: SessionSchema.ID;
+        directory: AbsolutePath;
+        workspaceID?: Location.Ref["workspaceID"];
+        delivery?: SessionInbox.Delivery;
+    }) => Effect.Effect<void, NotFoundError | DestinationNotFoundError | DestinationNotDirectoryError>;
+    readonly prompt: (input: {
+        id?: SessionMessage.ID;
+        sessionID: SessionSchema.ID;
+        text: string;
+        files?: PromptInput.Prompt["files"];
+        agents?: PromptInput.Prompt["agents"];
+        skills?: PromptInput.Prompt["skills"];
+        metadata?: Record<string, unknown>;
+        delivery?: SessionInbox.Delivery;
+        resume?: boolean;
+    }) => Effect.Effect<SessionInbox.User, NotFoundError | PromptConflictError | AttachmentError | SkillNotFoundError>;
+    /** Generates text from current Session context without admitting input or mutating history. */
+    readonly generate: (input: {
+        sessionID: SessionSchema.ID;
+        prompt: string;
+    }) => Effect.Effect<string, NotFoundError | SessionGenerate.Error>;
+    readonly command: (input: {
+        id?: SessionMessage.ID;
+        sessionID: SessionSchema.ID;
+        command: string;
+        arguments?: string;
+        agent?: Agent.ID;
+        model?: Model.Ref;
+        files?: PromptInput.Prompt["files"];
+        agents?: PromptInput.Prompt["agents"];
+        skills?: PromptInput.Prompt["skills"];
+        delivery?: SessionInbox.Delivery;
+        resume?: boolean;
+    }) => Effect.Effect<SessionInbox.User, NotFoundError | PromptConflictError | AttachmentError | SkillNotFoundError | Command.NotFoundError | Command.EvaluationError>;
+    readonly shell: (input: {
+        id?: Event.ID;
+        sessionID: SessionSchema.ID;
+        command: string;
+    }) => Effect.Effect<void, NotFoundError>;
+    readonly skill: (input: {
+        id?: SessionMessage.ID;
+        sessionID: SessionSchema.ID;
+        skill: Skill.ID;
+        resume?: boolean;
+    }) => Effect.Effect<void, NotFoundError | SkillNotFoundError>;
+    readonly compact: (input: CompactInput) => Effect.Effect<SessionInbox.Compaction, NotFoundError | CompactionConflictError>;
+    readonly wait: (id: SessionSchema.ID) => Effect.Effect<void, NotFoundError>;
+    readonly active: Effect.Effect<ReadonlySet<SessionSchema.ID>>;
+    readonly background: (sessionID: SessionSchema.ID) => Effect.Effect<void, NotFoundError>;
+    readonly resume: (sessionID: SessionSchema.ID) => Effect.Effect<void, NotFoundError | SessionRunner.RunError>;
+    readonly interrupt: (sessionID: SessionSchema.ID, options?: {
+        readonly continue?: boolean;
+    }) => Effect.Effect<void>;
+    readonly synthetic: (input: {
+        id?: SessionMessage.ID;
+        sessionID: SessionSchema.ID;
+        text: string;
+        description?: string;
+        metadata?: Record<string, unknown>;
+        delivery?: SessionInbox.Delivery;
+        resume?: boolean;
+    }) => Effect.Effect<SessionInbox.Synthetic, NotFoundError | SyntheticConflictError>;
+    readonly revert: {
+        readonly stage: (input: {
+            sessionID: SessionSchema.ID;
+            messageID: SessionMessage.ID;
+            files?: boolean;
+        }) => Effect.Effect<Session.Revert, NotFoundError | MessageNotFoundError | BusyError | Snapshot.Error>;
+        readonly clear: (sessionID: SessionSchema.ID) => Effect.Effect<void, NotFoundError | BusyError | Snapshot.Error>;
+        readonly commit: (sessionID: SessionSchema.ID) => Effect.Effect<void, NotFoundError | BusyError>;
+    };
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/Session", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const node: import("@opencode-ai/util/effect/layer-node").Node<Service, never, import("@opencode-ai/util/effect/layer-node").Tag<"global">>;

package/dist/types/shell/parse.d.ts

@@ -0,0 +1,11 @@
+export * as ShellParse from "./parse.js";
+import { Effect } from "effect";
+export declare const scan: (command: string, shell: string, cwd: string, options?: {
+    portable?: boolean;
+} | undefined) => Effect.Effect<{
+    commands: {
+        resource: string;
+        save: string;
+    }[];
+    directories: string[];
+}, Error, never>;

package/dist/types/shell/parser-wasm.bun.d.ts

@@ -0,0 +1,5 @@
+export declare const shellParserWasm: {
+    runtime: any;
+    bash: any;
+    powershell: any;
+};

package/dist/types/shell/parser-wasm.node.d.ts

@@ -0,0 +1,5 @@
+export declare const shellParserWasm: {
+    runtime: string;
+    bash: string;
+    powershell: string;
+};

package/dist/types/shell/parser-wasm.workerd.d.ts

@@ -0,0 +1,5 @@
+export declare const shellParserWasm: {
+    runtime: string;
+    bash: string;
+    powershell: string;
+};

package/dist/types/shell/select.d.ts

@@ -0,0 +1,25 @@
+export * as ShellSelect from "./select.js";
+import { Schema } from "effect";
+export type Item = {
+    path: string;
+    name: string;
+    acceptable: boolean;
+};
+export declare const Options: Schema.Struct<{
+    readonly gitbash: Schema.optional<Schema.String>;
+}>;
+export type Options = typeof Options.Type;
+export declare function gitbash(options?: Options, bin?: string): string | undefined;
+export declare function name(file: string): string;
+export declare function login(file: string): boolean;
+export declare function ps(file: string): boolean;
+export declare function args(file: string, command: string): string[];
+export declare function preferred(configShell?: string, options?: Options, bin?: string): string;
+export declare namespace preferred {
+    var reset: () => void;
+}
+export declare function acceptable(configShell?: string, options?: Options, bin?: string): string;
+export declare namespace acceptable {
+    var reset: () => void;
+}
+export declare function list(options?: Options, bin?: string): Promise<Item[]>;

package/dist/types/shell.d.ts

@@ -0,0 +1,44 @@
+export * as Shell from "./shell.js";
+import { Context, Effect, Layer, Schema } from "effect";
+import { Shell } from "@opencode-ai/schema/shell";
+import { AppProcess } from "@opencode-ai/util/process";
+import { Config } from "./config.js";
+import { Bus } from "./bus.js";
+import { Environment } from "./environment/index.js";
+import { Location } from "./location.js";
+import { Global } from "@opencode-ai/util/global";
+import { ShellSelect } from "./shell/select.js";
+import type { ShellCreateBefore } from "@opencode-ai/plugin/effect/shell";
+import { PluginHooks } from "./plugin/hooks.js";
+declare const NotFoundError_base: Schema.Class<NotFoundError, Schema.TaggedStruct<"Shell.NotFoundError", {
+    readonly id: Schema.brand<Schema.String, "Shell.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Shell.ID">;
+        ascending: (id?: string) => string & import("effect/Brand").Brand<"Shell.ID">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class NotFoundError extends NotFoundError_base {
+}
+/**
+ * Location-owned non-interactive shell command process service.
+ *
+ * Each `create` spawns one shell command, captures combined stdout/stderr to a
+ * file, and returns an ID. Clients poll `get` for status and `output` for
+ * file-backed output by cursor. No session, message, or permission state lives
+ * here; callers (e.g. `ShellTool`) own that association and store the shell ID.
+ */
+export interface Interface {
+    readonly name: () => Effect.Effect<string>;
+    readonly create: <E = never, R = never>(input: Shell.CreateInput, before?: (input: ShellCreateBefore) => Effect.Effect<void, E, R>) => Effect.Effect<Shell.Info, E | AppProcess.AppProcessError, R>;
+    readonly list: () => Effect.Effect<Shell.Info[]>;
+    readonly get: (id: Shell.ID) => Effect.Effect<Shell.Info, NotFoundError>;
+    readonly wait: (id: Shell.ID) => Effect.Effect<Shell.Info, NotFoundError>;
+    readonly timeout: (id: Shell.ID, duration: number) => Effect.Effect<Shell.Info, NotFoundError>;
+    readonly output: (id: Shell.ID, input?: Shell.OutputInput) => Effect.Effect<Shell.Output, NotFoundError>;
+    readonly remove: (id: Shell.ID) => Effect.Effect<void, NotFoundError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/Shell", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const layer: (options?: ShellSelect.Options) => Layer.Layer<Service, never, Global.Service | Bus.Service | Location.Service | Config.Service | Environment.Service | PluginHooks.Service>;
+export declare function configured(options?: ShellSelect.Options): import("@opencode-ai/util/effect/layer-node").Node<Service, never, import("@opencode-ai/util/effect/layer-node").Tag<"location">>;
+export declare const node: import("@opencode-ai/util/effect/layer-node").Node<Service, never, import("@opencode-ai/util/effect/layer-node").Tag<"location">>;

package/dist/types/skill/discovery.d.ts

@@ -0,0 +1,10 @@
+export * as SkillDiscovery from "./discovery.js";
+import { Context, Effect } from "effect";
+import { AbsolutePath } from "../schema.js";
+export interface Interface {
+    readonly pull: (url: string) => Effect.Effect<AbsolutePath[]>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/SkillDiscovery", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const node: import("@opencode-ai/util/effect/layer-node").Node<Service, never, import("@opencode-ai/util/effect/layer-node").Tag<"global">>;

package/dist/types/skill/instructions.d.ts

@@ -0,0 +1,11 @@
+export * as SkillInstructions from "./instructions.js";
+import { Context, Effect } from "effect";
+import { Agent } from "../agent.js";
+import { Instructions } from "../instructions/index.js";
+export interface Interface {
+    readonly load: (agent: Agent.Selection) => Effect.Effect<Instructions.List>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/SkillInstructions", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const node: import("@opencode-ai/util/effect/layer-node").Node<Service, never, import("@opencode-ai/util/effect/layer-node").Tag<"location">>;

package/dist/types/skill.d.ts

@@ -0,0 +1,83 @@
+export * as Skill from "./skill.js";
+import { Context, Effect, Types } from "effect";
+import { Skill } from "@opencode-ai/schema/skill";
+import { Agent } from "./agent.js";
+import { State } from "./state.js";
+export declare const DirectorySource: import("effect/Schema").Struct<{
+    readonly type: import("effect/Schema").tag<"directory">;
+    readonly path: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
+}>;
+export type DirectorySource = Skill.DirectorySource;
+export declare const UrlSource: import("effect/Schema").Struct<{
+    readonly type: import("effect/Schema").tag<"url">;
+    readonly url: import("effect/Schema").String;
+}>;
+export type UrlSource = Skill.UrlSource;
+export declare const EmbeddedSource: import("effect/Schema").Struct<{
+    readonly type: import("effect/Schema").tag<"embedded">;
+    readonly skill: import("effect/Schema").suspend<import("effect/Schema").Struct<{
+        readonly id: import("effect/Schema").brand<import("effect/Schema").String, "Skill.ID">;
+        readonly name: import("effect/Schema").brand<import("effect/Schema").String, "Skill.Name">;
+        readonly description: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").String>>, import("effect/Schema").optionalKey<import("effect/Schema").String>, never, never>;
+        readonly slash: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Boolean>>, import("effect/Schema").optionalKey<import("effect/Schema").Boolean>, never, never>;
+        readonly autoinvoke: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Boolean>>, import("effect/Schema").optionalKey<import("effect/Schema").Boolean>, never, never>;
+        readonly location: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
+        readonly content: import("effect/Schema").String;
+    }>>;
+}>;
+export type EmbeddedSource = Skill.EmbeddedSource;
+export declare const Source: import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+    readonly type: import("effect/Schema").tag<"directory">;
+    readonly path: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
+}>, import("effect/Schema").Struct<{
+    readonly type: import("effect/Schema").tag<"url">;
+    readonly url: import("effect/Schema").String;
+}>, import("effect/Schema").Struct<{
+    readonly type: import("effect/Schema").tag<"embedded">;
+    readonly skill: import("effect/Schema").suspend<import("effect/Schema").Struct<{
+        readonly id: import("effect/Schema").brand<import("effect/Schema").String, "Skill.ID">;
+        readonly name: import("effect/Schema").brand<import("effect/Schema").String, "Skill.Name">;
+        readonly description: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").String>>, import("effect/Schema").optionalKey<import("effect/Schema").String>, never, never>;
+        readonly slash: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Boolean>>, import("effect/Schema").optionalKey<import("effect/Schema").Boolean>, never, never>;
+        readonly autoinvoke: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Boolean>>, import("effect/Schema").optionalKey<import("effect/Schema").Boolean>, never, never>;
+        readonly location: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
+        readonly content: import("effect/Schema").String;
+    }>>;
+}>]> & {
+    equals: (a: Skill.Source, b: Skill.Source) => boolean;
+    key: (source: Skill.Source) => string;
+};
+export type Source = typeof Source.Type;
+export declare const Info: import("effect/Schema").Struct<{
+    readonly id: import("effect/Schema").brand<import("effect/Schema").String, "Skill.ID">;
+    readonly name: import("effect/Schema").brand<import("effect/Schema").String, "Skill.Name">;
+    readonly description: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").String>>, import("effect/Schema").optionalKey<import("effect/Schema").String>, never, never>;
+    readonly slash: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Boolean>>, import("effect/Schema").optionalKey<import("effect/Schema").Boolean>, never, never>;
+    readonly autoinvoke: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Boolean>>, import("effect/Schema").optionalKey<import("effect/Schema").Boolean>, never, never>;
+    readonly location: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
+    readonly content: import("effect/Schema").String;
+}>;
+export type Info = Skill.Info;
+export declare const ID: import("effect/Schema").brand<import("effect/Schema").String, "Skill.ID">;
+export type ID = Skill.ID;
+export declare const Name: import("effect/Schema").brand<import("effect/Schema").String, "Skill.Name">;
+export type Name = Skill.Name;
+export { Event } from "@opencode-ai/schema/skill";
+export declare const available: (skills: ReadonlyArray<Info>, agent: Agent.Info) => Skill.Info[];
+export declare const toModelOutput: (skill: Info, files: ReadonlyArray<string>) => string;
+export type Data = {
+    skills: Map<ID, Types.DeepMutable<Info>>;
+};
+export type Draft = {
+    list: () => readonly Types.DeepMutable<Info>[];
+    add: (skill: Info) => void;
+    update: (id: string, update: (skill: Types.DeepMutable<Info>) => void) => void;
+    remove: (id: string) => void;
+};
+export interface Interface extends State.Transformable<Draft> {
+    readonly list: () => Effect.Effect<Info[]>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/Skill", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const node: import("@opencode-ai/util/effect/layer-node").Node<Service, never, import("@opencode-ai/util/effect/layer-node").Tag<"location">>;

package/dist/types/snapshot.d.ts

@@ -0,0 +1,53 @@
+export * as Snapshot from "./snapshot.js";
+import { Context, Effect, Layer, Schema } from "effect";
+import { File } from "./file.js";
+import { RelativePath } from "./schema.js";
+import { ID } from "@opencode-ai/schema/snapshot";
+export { ID };
+declare const Error_base: Schema.Class<Error, Schema.TaggedStruct<"Snapshot.Error", {
+    readonly operation: Schema.Literals<readonly ["capture", "files", "diff", "restore"]>;
+    readonly message: Schema.String;
+    readonly cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+export declare class Error extends Error_base {
+}
+export interface CompareInput {
+    readonly from: ID;
+    readonly to: ID;
+}
+export interface DiffInput extends CompareInput {
+    readonly context?: number;
+    readonly paths?: readonly RelativePath[];
+}
+export interface RestoreInput {
+    /** Paths are relative to the project root. */
+    readonly files: ReadonlyMap<RelativePath, ID>;
+}
+export interface Interface {
+    /**
+     * Capture the current Location-scoped filesystem state as a content-addressed
+     * tree. Returns `undefined` when snapshots are disabled, unsupported, or the
+     * best-effort capture fails.
+     */
+    readonly capture: () => Effect.Effect<ID | undefined>;
+    /**
+     * List project-relative paths changed between two captured trees without
+     * loading file contents or generating patches.
+     */
+    readonly files: (input: CompareInput) => Effect.Effect<readonly RelativePath[], Error>;
+    /**
+     * Generate structured per-file diffs between two captured trees. `context`
+     * controls unchanged lines around each unified diff hunk.
+     */
+    readonly diff: (input: DiffInput) => Effect.Effect<readonly File.Diff[], Error>;
+    /**
+     * Restore selected project-relative paths from their associated trees. A path
+     * absent from its selected tree is removed; paths outside the map are untouched.
+     */
+    readonly restore: (input: RestoreInput) => Effect.Effect<void, Error>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/Snapshot", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const node: import("@opencode-ai/util/effect/layer-node").Node<Service, never, import("@opencode-ai/util/effect/layer-node").Tag<"location">>;
+export declare const noopLayer: Layer.Layer<Service, never, never>;