@opencode/core 0.0.0-reserved → 2.0.0

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

@@ -0,0 +1,13 @@
+export * as SessionUsage from "./usage.js";
+import type { Usage } from "@opencode/ai";
+import { Money } from "@opencode/schema/money";
+import type { TokenUsage } from "@opencode/schema/token-usage";
+import type { Model } from "@opencode/schema/model";
+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,229 @@
+export * as Session from "./session.js";
+export * from "./session/schema.js";
+import { Effect, Schema, Context, Stream } from "effect";
+import { ListAnchor } from "@opencode/schema/session";
+import { Model } from "@opencode/schema/model";
+import { Location } from "./location.js";
+import { SessionMessage } from "./session/message.js";
+import { PromptInput } from "@opencode/schema/prompt-input";
+import { SessionSchema } from "./session/schema.js";
+import { Agent } from "@opencode/schema/agent";
+import type { Permission } from "@opencode/schema/permission";
+import { SessionRunner } from "./session/runner/index.js";
+import { SessionStore } from "./session/store.js";
+import { AttachmentError, BusyError, CompactionConflictError, ForkEmptyError, InboxConflictError, MessageDecodeError, MessageNotFoundError, NotFoundError, PromptConflictError, SkillNotFoundError, SyntheticConflictError } from "./session/error.js";
+import { Node } from "@opencode/util/effect/app-node";
+import { LayerNode } from "@opencode/util/effect/layer-node";
+import { SessionEvent } from "./session/event.js";
+import { SessionInbox } from "./session/inbox.js";
+import { SessionGenerate } from "./session/generate.js";
+import { SessionMove, DestinationNotFoundError, DestinationNotDirectoryError, DestinationUnavailableError } from "./session/move.js";
+import { Snapshot } from "./snapshot.js";
+import { Session } from "./session/session.js";
+import type { EventLog } from "@opencode/schema/event-log";
+import type { Command } from "./command.js";
+import { SessionEnvironment } from "./session/environment.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 = SessionStore.ListInput;
+type CreateBaseInput = {
+    id?: SessionSchema.ID;
+    title?: string;
+    agent?: Agent.ID;
+    model?: Model.Ref;
+    metadata?: SessionSchema.Metadata;
+    permissions?: Permission.Ruleset;
+};
+type CreateInput = CreateBaseInput & ({
+    location: Location.Ref;
+    parentID?: never;
+} | {
+    parentID: SessionSchema.ID;
+    location?: never;
+});
+type CompactInput = Parameters<Session.Handle["compact"]>[0] & {
+    sessionID: SessionSchema.ID;
+};
+type ForkInput = {
+    sessionID: SessionSchema.ID;
+    boundary: SessionSchema.ForkRequestBoundary;
+};
+export { AttachmentError, BusyError, CompactionConflictError, InboxConflictError, MessageDecodeError, MessageNotFoundError, NotFoundError, PromptConflictError, SkillNotFoundError, SyntheticConflictError, };
+type InboxItemRef = {
+    readonly sessionID: SessionSchema.ID;
+    readonly inboxID: SessionMessage.ID;
+};
+export { DestinationNotFoundError, DestinationNotDirectoryError, DestinationUnavailableError };
+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 environment: (input: {
+        readonly sessionID: SessionSchema.ID;
+        readonly variables?: SessionEnvironment.Variables;
+    }) => Effect.Effect<SessionEnvironment.Variables | undefined, NotFoundError>;
+    readonly view: (input: {
+        sessionID: SessionSchema.ID;
+        idle: number;
+    }) => Effect.Effect<void, NotFoundError>;
+    readonly remove: (sessionID: SessionSchema.ID) => Effect.Effect<void, NotFoundError>;
+    readonly messages: (input: SessionStore.MessagesInput) => 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 setPermissions: (input: {
+        sessionID: SessionSchema.ID;
+        permissions: Permission.Ruleset;
+    }) => Effect.Effect<void, NotFoundError>;
+    readonly move: SessionMove.Interface["move"];
+    readonly prompt: (input: Parameters<Session.Handle["prompt"]>[0] & {
+        sessionID: SessionSchema.ID;
+    }) => ReturnType<Session.Handle["prompt"]>;
+    /** 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: {
+        sessionID: SessionSchema.ID;
+        command: string;
+        text: string;
+        files?: PromptInput.Prompt["files"];
+        agents?: PromptInput.Prompt["agents"];
+        skills?: PromptInput.Prompt["skills"];
+        delivery?: SessionInbox.Delivery;
+    }) => Effect.Effect<void, NotFoundError | Command.NotFoundError | Command.ExecutionError>;
+    readonly shell: (input: Parameters<Session.Handle["shell"]>[0] & {
+        sessionID: SessionSchema.ID;
+    }) => ReturnType<Session.Handle["shell"]>;
+    readonly skill: (input: Parameters<Session.Handle["skill"]>[0] & {
+        sessionID: SessionSchema.ID;
+    }) => ReturnType<Session.Handle["skill"]>;
+    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<boolean>;
+    readonly synthetic: (input: Parameters<Session.Handle["synthetic"]>[0] & {
+        sessionID: SessionSchema.ID;
+    }) => ReturnType<Session.Handle["synthetic"]>;
+    readonly revert: {
+        readonly stage: (input: {
+            sessionID: SessionSchema.ID;
+            messageID: SessionMessage.ID;
+            files?: boolean;
+        }) => Effect.Effect<SessionSchema.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: LayerNode.Provider<Service, never, typeof Node.tags.values.global>;

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

@@ -0,0 +1,13 @@
+export * as ShellParse from "./parse.js";
+import { Effect } from "effect";
+export type Result = {
+    commands: Array<{
+        resource: string;
+        save: string;
+    }>;
+    directories: string[];
+};
+export declare const scan: (command: string, shell: string, cwd: string, options?: {
+    portable?: boolean;
+} | undefined) => Effect.Effect<Result, Error, never>;
+export declare const scanPortable: (command: string, shell: string, cwd: string) => Effect.Effect<Result, 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/result.d.ts

@@ -0,0 +1,54 @@
+export * as ShellResult from "./result.js";
+import type { Shell } from "@opencode/schema/shell";
+export type Result = {
+    info: Shell.Info;
+    capture: {
+        output: string;
+        truncated: boolean;
+    } | undefined;
+};
+type Output = {
+    output: string;
+    truncated: boolean;
+    exit?: number;
+    timeout?: boolean;
+};
+export declare const unavailable: Shell.Output;
+export declare function output(result: Result): Output;
+export declare function notice(output: Pick<Output, "exit" | "timeout">): string | undefined;
+export declare function metadata(output: Output): {
+    timeout?: boolean | undefined;
+    exit?: number | undefined;
+    truncated: boolean;
+};
+export declare function notification(input: {
+    shellID: string;
+    jobID?: string;
+    command: string;
+    state: "completed" | "cancelled" | "error";
+    text: string;
+    output?: Output;
+}): {
+    text: string;
+    metadata: {
+        timeout?: boolean | undefined;
+        exit?: number | undefined;
+        truncated?: boolean | undefined;
+        state: "cancelled" | "error" | "completed";
+        jobID?: string | undefined;
+        source: string;
+        shellID: string;
+    };
+};
+export declare function userNotification(result: Result): {
+    text: string;
+    metadata: {
+        timeout?: boolean | undefined;
+        exit?: number | undefined;
+        truncated?: boolean | undefined;
+        state: "cancelled" | "error" | "completed";
+        jobID?: string | undefined;
+        source: string;
+        shellID: string;
+    };
+};

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

@@ -0,0 +1,20 @@
+export * as ShellScan from "./scan.js";
+export type OpaqueReason = "command-substitution" | "compound-command" | "dynamic-command-name" | "dynamic-execution" | "heredoc" | "invalid-redirect" | "invalid-structure" | "unterminated-escape" | "unterminated-quote";
+type Command = {
+    resource: string;
+    words: string[];
+    rawWords: string[];
+    wordEnds?: number[];
+    statementHead?: true;
+    declaration?: true;
+    redirectWordCount?: number;
+};
+export type Result = {
+    kind: "scanned";
+    commands: Command[];
+} | {
+    kind: "opaque";
+    reason: OpaqueReason;
+};
+export declare function scan(input: string): Result;
+export declare function scanPowerShell(input: string): Result;

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

@@ -0,0 +1,39 @@
+export * as ShellSelect from "./select.js";
+import { Context, Effect, Schema } from "effect";
+import { State } from "../state.js";
+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 type Editor = {
+    configure: (shell: string) => void;
+};
+export type ResolveInput = {
+    priority: "config" | "compat";
+};
+export interface Interface extends State.Transformable<Editor> {
+    readonly resolve: (input: ResolveInput) => Effect.Effect<string>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/ShellSelect", Interface>;
+export declare class Service extends Service_base {
+}
+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 environment(bin?: string, filter?: {
+    compatible?: boolean;
+}): string;
+export declare function resolve(input: ResolveInput, configShell?: string, options?: Options, bin?: string): string;
+export declare namespace resolve {
+    var reset: () => void;
+}
+export declare function list(options?: Options, bin?: string): Promise<Item[]>;
+export declare function configured(options?: Options): import("@opencode/util/effect/layer-node").Provider<Service, never, import("@opencode/util/effect/layer-node").Tag<"location">>;
+export declare const node: import("@opencode/util/effect/layer-node").Provider<Service, never, import("@opencode/util/effect/layer-node").Tag<"location">>;

package/dist/types/shell.d.ts

@@ -0,0 +1,44 @@
+export * as Shell from "./shell.js";
+import { Context, Duration, Effect, Schema } from "effect";
+import { Shell } from "@opencode/schema/shell";
+import { AppProcess } from "@opencode/util/process";
+import { FSUtil } from "@opencode/util/fs-util";
+import { Global } from "@opencode/util/global";
+import type { ShellCreateBefore } from "@opencode/plugin/effect/shell";
+import { ShellResult } from "./shell/result.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 {
+}
+export declare const RETENTION: Duration.Duration;
+export declare const DIRECTORY = "shell";
+type CreateInput = Shell.CreateInput & {
+    shell?: string;
+};
+/**
+ * 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 create: <E = never, R = never>(input: 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 result: (started: Shell.Info) => Effect.Effect<ShellResult.Result>;
+    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 cleanup: () => Effect.Effect<void, never, Global.Service | FSUtil.Service>;
+export declare const node: import("@opencode/util/effect/layer-node").Provider<Service, never, import("@opencode/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/util/effect/layer-node").Provider<Service, never, import("@opencode/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/util/effect/layer-node").Provider<Service, never, import("@opencode/util/effect/layer-node").Tag<"location">>;

package/dist/types/skill.d.ts

@@ -0,0 +1,90 @@
+export * as Skill from "./skill.js";
+import type { FSUtil } from "@opencode/util/fs-util";
+import { Context, Effect, Types } from "effect";
+import type { Agent } from "@opencode/schema/agent";
+import { Skill } from "@opencode/schema/skill";
+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 = Skill.Source;
+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/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 declare const prepare: (fs: FSUtil.Interface, skill: Skill.Info) => Effect.Effect<{
+    directory: string;
+    output: string;
+}, FSUtil.Error, never>;
+export type Data = {
+    skills: Map<ID, Types.DeepMutable<Info>>;
+};
+export type Editor = {
+    list: () => readonly Types.DeepMutable<Info>[];
+    get: (id: string) => Types.DeepMutable<Info> | undefined;
+    add: (skill: Info) => void;
+    update: (id: string, update: (skill: Types.DeepMutable<Info>) => void) => void;
+    remove: (id: string) => void;
+};
+export interface Interface extends State.Transformable<Editor> {
+    readonly get: (id: ID) => Effect.Effect<Info | undefined>;
+    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/util/effect/layer-node").Provider<Service, never, import("@opencode/util/effect/layer-node").Tag<"location">>;

package/dist/types/snapshot.d.ts

@@ -0,0 +1,57 @@
+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/schema/snapshot";
+import { State } from "./state.js";
+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 type Editor = {
+    configure: (enabled: boolean) => void;
+};
+export interface Interface extends State.Transformable<Editor> {
+    /**
+     * 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/util/effect/layer-node").Provider<Service, never, import("@opencode/util/effect/layer-node").Tag<"location">>;
+export declare const noopLayer: Layer.Layer<Service, never, never>;