@opencode-ai/core 0.0.0-beta-18593 → 0.0.0-beta-18684

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

@@ -0,0 +1,232 @@
+export * as Session from "./session.js";
+import { DateTime, Effect, Layer, Scope } from "effect";
+import type { Agent } from "@opencode-ai/schema/agent";
+import type { Model } from "@opencode-ai/schema/model";
+import { Event } from "@opencode-ai/schema/event";
+import { Bus } from "../bus.js";
+import { Location } from "../location.js";
+import { PluginSupervisor } from "../plugin/supervisor-service.js";
+import { Shell } from "../shell.js";
+import { BusyError, CompactionConflictError, InboxConflictError, MessageIncompleteError, MessageNotAssistantError, MessageNotFoundError, MessageToolIncompleteError, NotFoundError, PromptConflictError, SyntheticConflictError } from "./error.js";
+import { SessionExecution } from "./execution.js";
+import { SessionInbox } from "./inbox.js";
+import { SessionMessage } from "./message.js";
+import { SessionPrompt } from "./prompt.js";
+import { SessionRevert } from "./revert.js";
+import { SessionSchema } from "./schema.js";
+import { SessionStore } from "./store.js";
+export type Services = PluginSupervisor.Service | SessionPrompt.Service | SessionRevert.Service | Shell.Service;
+type PromptRequest = SessionPrompt.Input & {
+    id?: SessionMessage.ID;
+    resume?: boolean;
+};
+/**
+ * Build once in the host Scope: `const sessions = yield* Session.make(servicesFor)`.
+ * Use `sessions.forSession(id)` for handles that share host services and reload current state.
+ */
+export declare const make: (servicesFor: (ref: Location.Ref) => Layer.Layer<Services>) => Effect.Effect<{
+    forSession: (sessionID: SessionSchema.ID) => {
+        id: string & import("effect/Brand").Brand<"SessionID">;
+        get: () => Effect.Effect<SessionSchema.Info, NotFoundError, never>;
+        message: (messageID: string & import("effect/Brand").Brand<"Session.Message.ID">) => Effect.Effect<SessionMessage.Info | undefined, never, never>;
+        updateMessage: (input: {
+            readonly messageID: SessionMessage.ID;
+            readonly content: readonly SessionMessage.AssistantContent[];
+        }) => Effect.Effect<SessionMessage.Assistant, NotFoundError | MessageNotFoundError | MessageNotAssistantError | MessageIncompleteError | MessageToolIncompleteError | BusyError, never>;
+        view: (input: {
+            idle: number;
+        }) => Effect.Effect<void, NotFoundError, never>;
+        rename: (input: {
+            title: string;
+        }) => Effect.Effect<void, NotFoundError, never>;
+        switchAgent: (input: {
+            agent: Agent.ID;
+        }) => Effect.Effect<void, NotFoundError, never>;
+        switchModel: (input: {
+            model: Model.Ref;
+        }) => Effect.Effect<void, NotFoundError, never>;
+        inbox: () => Effect.Effect<({
+            readonly type: "user";
+            readonly payload: {
+                readonly text: string;
+                readonly metadata?: {
+                    readonly [x: string]: unknown;
+                } | undefined;
+                readonly files?: readonly {
+                    readonly source: {
+                        readonly type: "inline";
+                    } | {
+                        readonly type: "uri";
+                        readonly uri: string;
+                    };
+                    readonly data: string;
+                    readonly mime: string;
+                    readonly name?: string | undefined;
+                    readonly description?: string | undefined;
+                    readonly mention?: {
+                        readonly start: number;
+                        readonly end: number;
+                        readonly text: string;
+                    } | undefined;
+                }[] | undefined;
+                readonly agents?: readonly {
+                    readonly name: string;
+                    readonly mention?: {
+                        readonly start: number;
+                        readonly end: number;
+                        readonly text: string;
+                    } | undefined;
+                }[] | undefined;
+                readonly skills?: readonly {
+                    readonly name: string & import("effect/Brand").Brand<"Skill.Name">;
+                    readonly id: string & import("effect/Brand").Brand<"Skill.ID">;
+                    readonly text?: string | undefined;
+                    readonly mention?: {
+                        readonly start: number;
+                        readonly end: number;
+                        readonly text: string;
+                    } | undefined;
+                }[] | undefined;
+            };
+            readonly delivery: "steer" | "queue";
+            readonly id: string & import("effect/Brand").Brand<"Session.Message.ID">;
+            readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
+            readonly timeCreated: DateTime.Utc;
+        } | {
+            readonly type: "synthetic";
+            readonly payload: {
+                readonly text: string;
+                readonly description?: string | undefined;
+                readonly metadata?: {
+                    readonly [x: string]: unknown;
+                } | undefined;
+            };
+            readonly delivery: "steer" | "queue";
+            readonly id: string & import("effect/Brand").Brand<"Session.Message.ID">;
+            readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
+            readonly timeCreated: DateTime.Utc;
+        } | {
+            readonly type: "compaction";
+            readonly payload: {};
+            readonly delivery: "steer" | "queue";
+            readonly id: string & import("effect/Brand").Brand<"Session.Message.ID">;
+            readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
+            readonly timeCreated: DateTime.Utc;
+        } | {
+            readonly type: "move";
+            readonly payload: {
+                readonly location: {
+                    readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
+                    readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
+                };
+                readonly projectID: string & import("effect/Brand").Brand<"Project.ID">;
+                readonly subpath?: (string & import("effect/Brand").Brand<"RelativePath">) | undefined;
+            };
+            readonly delivery: "steer" | "queue";
+            readonly id: string & import("effect/Brand").Brand<"Session.Message.ID">;
+            readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
+            readonly timeCreated: DateTime.Utc;
+        })[], NotFoundError, never>;
+        prompt: (input: PromptRequest) => Effect.Effect<{
+            readonly type: "user";
+            readonly payload: {
+                readonly text: string;
+                readonly metadata?: {
+                    readonly [x: string]: unknown;
+                } | undefined;
+                readonly files?: readonly {
+                    readonly source: {
+                        readonly type: "inline";
+                    } | {
+                        readonly type: "uri";
+                        readonly uri: string;
+                    };
+                    readonly data: string;
+                    readonly mime: string;
+                    readonly name?: string | undefined;
+                    readonly description?: string | undefined;
+                    readonly mention?: {
+                        readonly start: number;
+                        readonly end: number;
+                        readonly text: string;
+                    } | undefined;
+                }[] | undefined;
+                readonly agents?: readonly {
+                    readonly name: string;
+                    readonly mention?: {
+                        readonly start: number;
+                        readonly end: number;
+                        readonly text: string;
+                    } | undefined;
+                }[] | undefined;
+                readonly skills?: readonly {
+                    readonly name: string & import("effect/Brand").Brand<"Skill.Name">;
+                    readonly id: string & import("effect/Brand").Brand<"Skill.ID">;
+                    readonly text?: string | undefined;
+                    readonly mention?: {
+                        readonly start: number;
+                        readonly end: number;
+                        readonly text: string;
+                    } | undefined;
+                }[] | undefined;
+            };
+            readonly delivery: "steer" | "queue";
+            readonly id: string & import("effect/Brand").Brand<"Session.Message.ID">;
+            readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
+            readonly timeCreated: DateTime.Utc;
+        }, NotFoundError | PromptConflictError | import("./error.js").AttachmentError | import("./error.js").SkillNotFoundError, never>;
+        synthetic: (input: {
+            id?: SessionMessage.ID;
+            text: string;
+            description?: string;
+            metadata?: Record<string, unknown>;
+            delivery?: SessionInbox.Delivery;
+            resume?: boolean;
+        }) => Effect.Effect<{
+            readonly type: "synthetic";
+            readonly payload: {
+                readonly text: string;
+                readonly description?: string | undefined;
+                readonly metadata?: {
+                    readonly [x: string]: unknown;
+                } | undefined;
+            };
+            readonly delivery: "steer" | "queue";
+            readonly id: string & import("effect/Brand").Brand<"Session.Message.ID">;
+            readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
+            readonly timeCreated: DateTime.Utc;
+        }, NotFoundError | SyntheticConflictError, never>;
+        shell: (input: {
+            id?: Event.ID;
+            command: string;
+        }) => Effect.Effect<void, NotFoundError, never>;
+        compact: (input: {
+            id?: SessionMessage.ID;
+            delivery?: SessionInbox.Delivery;
+        }) => Effect.Effect<{
+            readonly type: "compaction";
+            readonly payload: {};
+            readonly delivery: "steer" | "queue";
+            readonly id: string & import("effect/Brand").Brand<"Session.Message.ID">;
+            readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
+            readonly timeCreated: DateTime.Utc;
+        }, NotFoundError | CompactionConflictError, never>;
+        wait: () => Effect.Effect<void, NotFoundError, never>;
+        resume: () => Effect.Effect<void, NotFoundError | import("./runner/index.js").RunError, never>;
+        interrupt: (options?: {
+            readonly continue?: boolean;
+        } | undefined) => Effect.Effect<boolean, never, never>;
+        cancelInbox: (inboxID: string & import("effect/Brand").Brand<"Session.Message.ID">) => Effect.Effect<void, NotFoundError | InboxConflictError, never>;
+        steerInbox: (inboxID: string & import("effect/Brand").Brand<"Session.Message.ID">) => Effect.Effect<void, NotFoundError | InboxConflictError, never>;
+        queueInbox: (inboxID: string & import("effect/Brand").Brand<"Session.Message.ID">) => Effect.Effect<void, NotFoundError | InboxConflictError, never>;
+        revert: {
+            stage: (input: {
+                messageID: SessionMessage.ID;
+                files?: boolean;
+            }) => Effect.Effect<SessionSchema.Revert, NotFoundError | MessageNotFoundError | BusyError | import("../snapshot.js").Error, never>;
+            clear: () => Effect.Effect<void, NotFoundError | BusyError | import("../snapshot.js").Error, never>;
+            commit: () => Effect.Effect<void, NotFoundError | BusyError, never>;
+        };
+    };
+}, never, Scope.Scope | Bus.Service | SessionInbox.Service | SessionStore.Service | SessionExecution.Service>;
+export type Handle = ReturnType<Effect.Success<ReturnType<typeof make>>["forSession"]>;

package/dist/types/session/subagent-completion.d.ts

@@ -0,0 +1,10 @@
+export * as SubagentCompletion from "./subagent-completion.js";
+import { Effect } from "effect";
+import type { Job } from "../job.js";
+import type { Session } from "../session.js";
+export declare const deliver: (sessions: Pick<Session.Interface, "synthetic">, jobs: Pick<Job.Interface, "completeBackground">, input: Pick<Job.Info, "status" | "output" | "error" | "notificationID"> & {
+    recovery: Extract<Job.Recovery, {
+        kind: "subagent";
+    }>;
+    resume?: boolean;
+}) => Effect.Effect<void, Session.NotFoundError | Session.SyntheticConflictError, never>;

package/dist/types/session.d.ts

@@ -10,15 +10,13 @@ import { SessionSchema } from "./session/schema.js";
 import { AbsolutePath } from "./schema.js";
 import { Agent } from "@opencode-ai/schema/agent";
 import { SessionRunner } from "./session/runner/index.js";
-import { ForkEmptyError, MessageDecodeError, NotFoundError } from "./session/error.js";
+import { AttachmentError, BusyError, CompactionConflictError, ForkEmptyError, InboxConflictError, MessageDecodeError, MessageIncompleteError, MessageNotAssistantError, MessageNotFoundError, MessageToolIncompleteError, NotFoundError, PromptConflictError, SkillNotFoundError, SyntheticConflictError } 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 { Session } from "./session/session.js";
 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";
 import { SessionEnvironment } from "./session/environment.js";
@@ -104,123 +102,18 @@ type CreateInput = CreateBaseInput & ({
     parentID: SessionSchema.ID;
     location?: never;
 });
-type CompactInput = {
-    id?: SessionMessage.ID;
+type CompactInput = Parameters<Session.Handle["compact"]>[0] & {
     sessionID: SessionSchema.ID;
-    delivery?: SessionInbox.Delivery;
 };
 type ForkInput = {
     sessionID: SessionSchema.ID;
-    boundary: Session.ForkRequestBoundary;
+    boundary: SessionSchema.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">;
-    };
-}>, 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">;
-    };
-}>, 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;
-}>, 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">;
-    };
-}>, 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">;
-    };
-}>, Cause.YieldableError>;
-export declare class BusyError extends BusyError_base {
-}
-declare const MessageNotAssistantError_base: Schema.Class<MessageNotAssistantError, Schema.TaggedStruct<"Session.MessageNotAssistantError", {
-    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">;
-    };
-}>, Cause.YieldableError>;
-export declare class MessageNotAssistantError extends MessageNotAssistantError_base {
-}
-declare const MessageIncompleteError_base: Schema.Class<MessageIncompleteError, Schema.TaggedStruct<"Session.MessageIncompleteError", {
-    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">;
-    };
-}>, Cause.YieldableError>;
-export declare class MessageIncompleteError extends MessageIncompleteError_base {
-}
-declare const MessageToolIncompleteError_base: Schema.Class<MessageToolIncompleteError, Schema.TaggedStruct<"Session.MessageToolIncompleteError", {
-    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">;
-    };
-}>, Cause.YieldableError>;
-export declare class MessageToolIncompleteError extends MessageToolIncompleteError_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">;
-    };
-}>, Cause.YieldableError>;
-export declare class InboxConflictError extends InboxConflictError_base {
-}
+export { AttachmentError, BusyError, CompactionConflictError, InboxConflictError, MessageDecodeError, MessageIncompleteError, MessageNotAssistantError, MessageNotFoundError, MessageToolIncompleteError, NotFoundError, PromptConflictError, SkillNotFoundError, SyntheticConflictError, };
 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">;
-}>, 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">;
 }>, Cause.YieldableError>;
@@ -236,8 +129,6 @@ declare const DestinationUnavailableError_base: Schema.Class<DestinationUnavaila
 }>, Cause.YieldableError>;
 export declare class DestinationUnavailableError extends DestinationUnavailableError_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[];
@@ -267,11 +158,9 @@ export interface Interface {
         sessionID: SessionSchema.ID;
         messageID: SessionMessage.ID;
     }) => Effect.Effect<SessionMessage.Info | undefined>;
-    readonly updateMessage: (input: {
+    readonly updateMessage: (input: Parameters<Session.Handle["updateMessage"]>[0] & {
         readonly sessionID: SessionSchema.ID;
-        readonly messageID: SessionMessage.ID;
-        readonly content: readonly SessionMessage.AssistantContent[];
-    }) => Effect.Effect<SessionMessage.Assistant, NotFoundError | MessageNotFoundError | BusyError | MessageNotAssistantError | MessageIncompleteError | MessageToolIncompleteError>;
+    }) => ReturnType<Session.Handle["updateMessage"]>;
     readonly context: (sessionID: SessionSchema.ID) => Effect.Effect<SessionMessage.Info[], NotFoundError | MessageDecodeError>;
     /**
      * Durable admitted session work not yet visible in projected history,
@@ -312,17 +201,9 @@ export interface Interface {
         workspaceID?: Location.Ref["workspaceID"];
         delivery?: SessionInbox.Delivery;
     }) => Effect.Effect<void, NotFoundError | DestinationNotFoundError | DestinationNotDirectoryError | DestinationUnavailableError>;
-    readonly prompt: (input: {
-        id?: SessionMessage.ID;
+    readonly prompt: (input: Parameters<Session.Handle["prompt"]>[0] & {
         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>;
+    }) => ReturnType<Session.Handle["prompt"]>;
     /** Generates text from current Session context without admitting input or mutating history. */
     readonly generate: (input: {
         sessionID: SessionSchema.ID;
@@ -337,11 +218,9 @@ export interface Interface {
         skills?: PromptInput.Prompt["skills"];
         delivery?: SessionInbox.Delivery;
     }) => Effect.Effect<void, NotFoundError | Command.NotFoundError | Command.ExecutionError>;
-    readonly shell: (input: {
-        id?: Event.ID;
+    readonly shell: (input: Parameters<Session.Handle["shell"]>[0] & {
         sessionID: SessionSchema.ID;
-        command: string;
-    }) => Effect.Effect<void, NotFoundError>;
+    }) => ReturnType<Session.Handle["shell"]>;
     readonly skill: (input: {
         id?: SessionMessage.ID;
         sessionID: SessionSchema.ID;
@@ -356,21 +235,15 @@ export interface Interface {
     readonly interrupt: (sessionID: SessionSchema.ID, options?: {
         readonly continue?: boolean;
     }) => Effect.Effect<boolean>;
-    readonly synthetic: (input: {
-        id?: SessionMessage.ID;
+    readonly synthetic: (input: Parameters<Session.Handle["synthetic"]>[0] & {
         sessionID: SessionSchema.ID;
-        text: string;
-        description?: string;
-        metadata?: Record<string, unknown>;
-        delivery?: SessionInbox.Delivery;
-        resume?: boolean;
-    }) => Effect.Effect<SessionInbox.Synthetic, NotFoundError | SyntheticConflictError>;
+    }) => ReturnType<Session.Handle["synthetic"]>;
     readonly revert: {
         readonly stage: (input: {
             sessionID: SessionSchema.ID;
             messageID: SessionMessage.ID;
             files?: boolean;
-        }) => Effect.Effect<Session.Revert, NotFoundError | MessageNotFoundError | BusyError | Snapshot.Error>;
+        }) => 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>;
     };

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

@@ -0,0 +1,54 @@
+export * as ShellResult from "./result.js";
+import type { Shell } from "@opencode-ai/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.d.ts

@@ -5,6 +5,7 @@ import { AppProcess } from "@opencode-ai/util/process";
 import { FSUtil } from "@opencode-ai/util/fs-util";
 import { Global } from "@opencode-ai/util/global";
 import type { ShellCreateBefore } from "@opencode-ai/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">;
@@ -31,6 +32,7 @@ export interface Interface {
     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>;

package/dist/types/skill.d.ts

@@ -1,8 +1,8 @@
 export * as Skill from "./skill.js";
 import type { FSUtil } from "@opencode-ai/util/fs-util";
 import { Context, Effect, Types } from "effect";
+import type { Agent } from "@opencode-ai/schema/agent";
 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">;

package/dist/types/vcs.d.ts

@@ -1,12 +1,18 @@
 export * as Vcs from "./vcs.js";
-import { Context, Effect } from "effect";
+import { Cause, Context, Effect, Schema } from "effect";
 import type { VcsDraft } from "@opencode-ai/plugin/effect/vcs";
 import { FileDiff } from "@opencode-ai/schema/file-diff";
-import { BranchList, FileStatus, Info, Mode } from "@opencode-ai/schema/vcs";
+import { Base, BranchList, FileStatus, Info, Mode } from "@opencode-ai/schema/vcs";
 import { State } from "./state.js";
-export { BranchList, FileStatus, Info, Mode };
+export { Base, BranchList, FileStatus, Info, Mode };
+declare const DiffError_base: Schema.Class<DiffError, Schema.TaggedStruct<"Vcs.DiffError", {
+    readonly message: Schema.String;
+}>, Cause.YieldableError>;
+export declare class DiffError extends DiffError_base {
+}
 export interface DiffOptions {
     readonly context?: number;
+    readonly base?: string;
 }
 export interface BranchOptions {
     readonly search?: string;
@@ -14,11 +20,13 @@ export interface BranchOptions {
 }
 export interface Adapter {
     readonly info: () => Effect.Effect<Info>;
+    readonly base?: () => Effect.Effect<Base | null, DiffError>;
     readonly branches: (options?: BranchOptions) => Effect.Effect<BranchList>;
     readonly status: () => Effect.Effect<FileStatus[]>;
-    readonly diff: (mode: Mode, options?: DiffOptions) => Effect.Effect<FileDiff.Info[]>;
+    readonly diff: (mode: Mode, options?: DiffOptions) => Effect.Effect<FileDiff.Info[], DiffError>;
 }
 export interface Interface extends Adapter, State.Transformable<VcsDraft> {
+    readonly base: () => Effect.Effect<Base | null, DiffError>;
 }
 declare const Service_base: Context.ServiceClass<Service, "@opencode/Vcs", Interface>;
 export declare class Service extends Service_base {

package/dist/util/array.js

@@ -1,4 +1,4 @@
-import"../chunks/persistent-pty-rvfvac9x.js";
+import"../chunks/state-rvfvac9x.js";
 
 // src/util/array.ts
 function findLast(items, predicate) {

package/dist/util/error.js

@@ -1,7 +1,7 @@
 import {
   NamedError
-} from "../chunks/persistent-pty-hzeg9cfr.js";
-import"../chunks/persistent-pty-rvfvac9x.js";
+} from "../chunks/state-hzeg9cfr.js";
+import"../chunks/state-rvfvac9x.js";
 export {
   NamedError
 };

package/dist/util/identifier.js

@@ -1,4 +1,4 @@
-import"../chunks/persistent-pty-rvfvac9x.js";
+import"../chunks/state-rvfvac9x.js";
 
 // src/util/identifier.ts
 import * as Identifier from "@opencode-ai/schema/identifier";

package/dist/util/iife.js

@@ -1,7 +1,7 @@
 import {
   iife
-} from "../chunks/persistent-pty-ehj9csmv.js";
-import"../chunks/persistent-pty-rvfvac9x.js";
+} from "../chunks/state-ehj9csmv.js";
+import"../chunks/state-rvfvac9x.js";
 export {
   iife
 };

package/dist/util/lazy.js

@@ -1,7 +1,7 @@
 import {
   lazy
-} from "../chunks/persistent-pty-8w9tzfz1.js";
-import"../chunks/persistent-pty-rvfvac9x.js";
+} from "../chunks/state-8w9tzfz1.js";
+import"../chunks/state-rvfvac9x.js";
 export {
   lazy
 };

package/dist/util/process-lock-ffi.bun.js

@@ -1,4 +1,4 @@
-import"../chunks/persistent-pty-rvfvac9x.js";
+import"../chunks/state-rvfvac9x.js";
 
 // src/util/process-lock-ffi.bun.ts
 import { dlopen, read } from "bun:ffi";

package/dist/util/process-lock-ffi.node.js

@@ -1,4 +1,4 @@
-import"../chunks/persistent-pty-rvfvac9x.js";
+import"../chunks/state-rvfvac9x.js";
 
 // src/util/process-lock-ffi.node.ts
 import { dlopen, getInt32 } from "node:ffi";