@opencode/core 2.0.32 → 2.1.0

package/dist/types/tool/runtime.d.ts

@@ -3,7 +3,6 @@ import { Tool } from "@opencode/schema/tool";
 import { Effect } from "effect";
 export declare const definition: (tool: Tool.Info<any, any>) => ToolDefinition;
 export declare const execute: (tool: Tool.Info<any, any>, input: unknown, context: Tool.Context) => Effect.Effect<{
-    metadata?: Readonly<Record<string, any>> | undefined;
     output: any;
     content: ({
         readonly type: "text";
@@ -14,6 +13,7 @@ export declare const execute: (tool: Tool.Info<any, any>, input: unknown, contex
         readonly mime: string;
         readonly name?: string | undefined;
     })[];
+    metadata?: Readonly<Record<string, any>> | undefined;
 }, Tool.Error, never>;
 export declare const normalizeContent: (value: string | ReadonlyArray<Tool.Content> | undefined, output?: unknown) => ({
     readonly type: "text";

package/dist/types/util/error.d.ts

@@ -23,12 +23,13 @@ export declare abstract class NamedError extends Error {
             message: string;
             stack?: string;
             cause?: unknown;
-            readonly "~effect/Runtime/errorExitCode"?: number;
-            readonly "~effect/Runtime/errorReported"?: boolean;
             readonly "~effect/ErrorReporter/ignore"?: boolean;
             readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
             readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+            readonly "~effect/Runtime/errorExitCode"?: number;
+            readonly "~effect/Runtime/errorReported"?: boolean;
         };
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
         readonly Schema: Schema.Struct<{
             readonly name: Schema.Literal<Name>;
             readonly data: DataSchema;
@@ -39,6 +40,11 @@ export declare abstract class NamedError extends Error {
         }>;
         readonly tag: Name;
         isInstance(input: unknown): input is InstanceType</*elided*/ any>;
+        isError(error: unknown): error is Error;
+        isError(value: unknown): value is Error;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        stackTraceLimit: number;
         hasName(error: unknown, name: string): boolean;
         create<Name_1 extends string, Fields extends Schema.Struct.Fields>(name: Name_1, fields: Fields): ReturnType<typeof NamedError.createSchemaClass<Name_1, Schema.Struct<Fields>>>;
         create<Name_1 extends string, DataSchema_1 extends Schema.Top>(name: Name_1, data: DataSchema_1): ReturnType<typeof NamedError.createSchemaClass<Name_1, DataSchema_1>>;
@@ -70,12 +76,13 @@ export declare abstract class NamedError extends Error {
                 message: string;
                 stack?: string;
                 cause?: unknown;
-                readonly "~effect/Runtime/errorExitCode"?: number;
-                readonly "~effect/Runtime/errorReported"?: boolean;
                 readonly "~effect/ErrorReporter/ignore"?: boolean;
                 readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
                 readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+                readonly "~effect/Runtime/errorExitCode"?: number;
+                readonly "~effect/Runtime/errorReported"?: boolean;
             };
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
             readonly Schema: Schema.Struct<{
                 readonly name: Schema.Literal<"UnknownError">;
                 readonly data: Schema.Struct<{
@@ -114,28 +121,23 @@ export declare abstract class NamedError extends Error {
                 message: string;
                 stack?: string;
                 cause?: unknown;
-                readonly "~effect/Runtime/errorExitCode"?: number;
-                readonly "~effect/Runtime/errorReported"?: boolean;
                 readonly "~effect/ErrorReporter/ignore"?: boolean;
                 readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
                 readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+                readonly "~effect/Runtime/errorExitCode"?: number;
+                readonly "~effect/Runtime/errorReported"?: boolean;
             };
+            isError(error: unknown): error is Error;
+            isError(value: unknown): value is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            stackTraceLimit: number;
             hasName(error: unknown, name: string): boolean;
             create<Name_1 extends string, Fields extends Schema.Struct.Fields>(name: Name_1, fields: Fields): ReturnType<typeof NamedError.createSchemaClass<Name_1, Schema.Struct<Fields>>>;
             create<Name_1 extends string, DataSchema_1 extends Schema.Top>(name: Name_1, data: DataSchema_1): ReturnType<typeof NamedError.createSchemaClass<Name_1, DataSchema_1>>;
             createSchemaClass<Name extends string, DataSchema extends Schema.Top>(name: Name, data: DataSchema): /*elided*/ any;
             readonly Unknown: /*elided*/ any;
-            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
-            stackTraceLimit: number;
-            isError(value: unknown): value is Error;
         };
-        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
-        stackTraceLimit: number;
-        isError(value: unknown): value is Error;
     };
     static readonly Unknown: {
         new (data: {
@@ -164,12 +166,13 @@ export declare abstract class NamedError extends Error {
             message: string;
             stack?: string;
             cause?: unknown;
-            readonly "~effect/Runtime/errorExitCode"?: number;
-            readonly "~effect/Runtime/errorReported"?: boolean;
             readonly "~effect/ErrorReporter/ignore"?: boolean;
             readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
             readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+            readonly "~effect/Runtime/errorExitCode"?: number;
+            readonly "~effect/Runtime/errorReported"?: boolean;
         };
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
         readonly Schema: Schema.Struct<{
             readonly name: Schema.Literal<"UnknownError">;
             readonly data: Schema.Struct<{
@@ -208,12 +211,17 @@ export declare abstract class NamedError extends Error {
             message: string;
             stack?: string;
             cause?: unknown;
-            readonly "~effect/Runtime/errorExitCode"?: number;
-            readonly "~effect/Runtime/errorReported"?: boolean;
             readonly "~effect/ErrorReporter/ignore"?: boolean;
             readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
             readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+            readonly "~effect/Runtime/errorExitCode"?: number;
+            readonly "~effect/Runtime/errorReported"?: boolean;
         };
+        isError(error: unknown): error is Error;
+        isError(value: unknown): value is Error;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        stackTraceLimit: number;
         hasName(error: unknown, name: string): boolean;
         create<Name extends string, Fields extends Schema.Struct.Fields>(name: Name, fields: Fields): ReturnType<typeof NamedError.createSchemaClass<Name, Schema.Struct<Fields>>>;
         create<Name extends string, DataSchema extends Schema.Top>(name: Name, data: DataSchema): ReturnType<typeof NamedError.createSchemaClass<Name, DataSchema>>;
@@ -232,12 +240,13 @@ export declare abstract class NamedError extends Error {
                 message: string;
                 stack?: string;
                 cause?: unknown;
-                readonly "~effect/Runtime/errorExitCode"?: number;
-                readonly "~effect/Runtime/errorReported"?: boolean;
                 readonly "~effect/ErrorReporter/ignore"?: boolean;
                 readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
                 readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+                readonly "~effect/Runtime/errorExitCode"?: number;
+                readonly "~effect/Runtime/errorReported"?: boolean;
             };
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
             readonly Schema: Schema.Struct<{
                 readonly name: Schema.Literal<Name>;
                 readonly data: DataSchema;
@@ -248,22 +257,17 @@ export declare abstract class NamedError extends Error {
             }>;
             readonly tag: Name;
             isInstance(input: unknown): input is InstanceType</*elided*/ any>;
+            isError(error: unknown): error is Error;
+            isError(value: unknown): value is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            stackTraceLimit: number;
             hasName(error: unknown, name: string): boolean;
             create<Name_1 extends string, Fields extends Schema.Struct.Fields>(name: Name_1, fields: Fields): ReturnType<typeof NamedError.createSchemaClass<Name_1, Schema.Struct<Fields>>>;
             create<Name_1 extends string, DataSchema_1 extends Schema.Top>(name: Name_1, data: DataSchema_1): ReturnType<typeof NamedError.createSchemaClass<Name_1, DataSchema_1>>;
             createSchemaClass<Name extends string, DataSchema extends Schema.Top>(name: Name, data: DataSchema): /*elided*/ any;
             readonly Unknown: /*elided*/ any;
-            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
-            stackTraceLimit: number;
-            isError(value: unknown): value is Error;
         };
         readonly Unknown: /*elided*/ any;
-        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
-        stackTraceLimit: number;
-        isError(value: unknown): value is Error;
     };
 }

package/dist/types/v1/config/agent.d.ts

@@ -15,7 +15,7 @@ export declare const Info: Schema.decodeTo<Schema.toType<Schema.StructWithRest<S
     readonly color: Schema.optional<Schema.Union<readonly [Schema.String, Schema.Literals<readonly ["primary", "secondary", "accent", "success", "warning", "error", "info"]>]>>;
     readonly steps: Schema.optional<Schema.Int>;
     readonly maxSteps: Schema.optional<Schema.Int>;
-    readonly permission: Schema.optional<Schema.decodeTo<Schema.decodeTo<Schema.$Array<Schema.Tuple<readonly [Schema.String, Schema.Codec<"allow" | "deny" | "ask" | readonly (readonly [string, "allow" | "deny" | "ask"])[], object | "allow" | "deny" | "ask", never, never>]>>, Schema.ObjectKeyword, never, never>, Schema.Union<readonly [Schema.Literals<readonly ["ask", "allow", "deny"]>, Schema.ObjectKeyword]>, never, never>>;
+    readonly permission: Schema.optional<Schema.decodeTo<Schema.decodeTo<Schema.$Array<Schema.Tuple<readonly [Schema.String, Schema.Codec<"allow" | "ask" | "deny" | readonly (readonly [string, "allow" | "ask" | "deny"])[], "allow" | "ask" | "deny" | object, never, never>]>>, Schema.ObjectKeyword, never, never>, Schema.Union<readonly [Schema.Literals<readonly ["ask", "allow", "deny"]>, Schema.ObjectKeyword]>, never, never>>;
 }>, readonly [Schema.$Record<Schema.String, Schema.Any>]>>, Schema.StructWithRest<Schema.Struct<{
     readonly model: Schema.optional<Schema.String>;
     readonly variant: Schema.optional<Schema.String>;
@@ -31,6 +31,6 @@ export declare const Info: Schema.decodeTo<Schema.toType<Schema.StructWithRest<S
     readonly color: Schema.optional<Schema.Union<readonly [Schema.String, Schema.Literals<readonly ["primary", "secondary", "accent", "success", "warning", "error", "info"]>]>>;
     readonly steps: Schema.optional<Schema.Int>;
     readonly maxSteps: Schema.optional<Schema.Int>;
-    readonly permission: Schema.optional<Schema.decodeTo<Schema.decodeTo<Schema.$Array<Schema.Tuple<readonly [Schema.String, Schema.Codec<"allow" | "deny" | "ask" | readonly (readonly [string, "allow" | "deny" | "ask"])[], object | "allow" | "deny" | "ask", never, never>]>>, Schema.ObjectKeyword, never, never>, Schema.Union<readonly [Schema.Literals<readonly ["ask", "allow", "deny"]>, Schema.ObjectKeyword]>, never, never>>;
+    readonly permission: Schema.optional<Schema.decodeTo<Schema.decodeTo<Schema.$Array<Schema.Tuple<readonly [Schema.String, Schema.Codec<"allow" | "ask" | "deny" | readonly (readonly [string, "allow" | "ask" | "deny"])[], "allow" | "ask" | "deny" | object, never, never>]>>, Schema.ObjectKeyword, never, never>, Schema.Union<readonly [Schema.Literals<readonly ["ask", "allow", "deny"]>, Schema.ObjectKeyword]>, never, never>>;
 }>, readonly [Schema.$Record<Schema.String, Schema.Any>]>, never, never>;
 export type Info = Schema.Schema.Type<typeof Info>;

package/dist/types/v1/config/error.d.ts

@@ -4,22 +4,22 @@ import { NamedError } from "../../util/error.js";
 export declare const InvalidError: {
     new (data: {
         readonly path: string;
-        readonly message?: string | undefined;
         readonly issues?: readonly {
             readonly [x: string]: unknown;
             readonly message: string;
             readonly path: readonly string[];
         }[] | undefined;
+        readonly message?: string | undefined;
     }, options?: ErrorOptions): {
         readonly name: "ConfigInvalidError";
         readonly data: {
             readonly path: string;
-            readonly message?: string | undefined;
             readonly issues?: readonly {
                 readonly [x: string]: unknown;
                 readonly message: string;
                 readonly path: readonly string[];
             }[] | undefined;
+            readonly message?: string | undefined;
         };
         schema(): Schema.Struct<{
             readonly name: Schema.Literal<"ConfigInvalidError">;
@@ -36,23 +36,24 @@ export declare const InvalidError: {
             name: "ConfigInvalidError";
             data: {
                 readonly path: string;
-                readonly message?: string | undefined;
                 readonly issues?: readonly {
                     readonly [x: string]: unknown;
                     readonly message: string;
                     readonly path: readonly string[];
                 }[] | undefined;
+                readonly message?: string | undefined;
             };
         };
         message: string;
         stack?: string;
         cause?: unknown;
-        readonly "~effect/Runtime/errorExitCode"?: number;
-        readonly "~effect/Runtime/errorReported"?: boolean;
         readonly "~effect/ErrorReporter/ignore"?: boolean;
         readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
         readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+        readonly "~effect/Runtime/errorExitCode"?: number;
+        readonly "~effect/Runtime/errorReported"?: boolean;
     };
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
     readonly Schema: Schema.Struct<{
         readonly name: Schema.Literal<"ConfigInvalidError">;
         readonly data: Schema.Struct<{
@@ -80,12 +81,12 @@ export declare const InvalidError: {
         readonly name: "ConfigInvalidError";
         readonly data: {
             readonly path: string;
-            readonly message?: string | undefined;
             readonly issues?: readonly {
                 readonly [x: string]: unknown;
                 readonly message: string;
                 readonly path: readonly string[];
             }[] | undefined;
+            readonly message?: string | undefined;
         };
         schema(): Schema.Struct<{
             readonly name: Schema.Literal<"ConfigInvalidError">;
@@ -102,23 +103,28 @@ export declare const InvalidError: {
             name: "ConfigInvalidError";
             data: {
                 readonly path: string;
-                readonly message?: string | undefined;
                 readonly issues?: readonly {
                     readonly [x: string]: unknown;
                     readonly message: string;
                     readonly path: readonly string[];
                 }[] | undefined;
+                readonly message?: string | undefined;
             };
         };
         message: string;
         stack?: string;
         cause?: unknown;
-        readonly "~effect/Runtime/errorExitCode"?: number;
-        readonly "~effect/Runtime/errorReported"?: boolean;
         readonly "~effect/ErrorReporter/ignore"?: boolean;
         readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
         readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+        readonly "~effect/Runtime/errorExitCode"?: number;
+        readonly "~effect/Runtime/errorReported"?: boolean;
     };
+    isError(error: unknown): error is Error;
+    isError(value: unknown): value is Error;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    stackTraceLimit: number;
     hasName(error: unknown, name: string): boolean;
     create<Name extends string, Fields extends Schema.Struct.Fields>(name: Name, fields: Fields): ReturnType<typeof NamedError.createSchemaClass<Name, Schema.Struct<Fields>>>;
     create<Name extends string, DataSchema extends Schema.Top>(name: Name, data: DataSchema): ReturnType<typeof NamedError.createSchemaClass<Name, DataSchema>>;
@@ -137,12 +143,13 @@ export declare const InvalidError: {
             message: string;
             stack?: string;
             cause?: unknown;
-            readonly "~effect/Runtime/errorExitCode"?: number;
-            readonly "~effect/Runtime/errorReported"?: boolean;
             readonly "~effect/ErrorReporter/ignore"?: boolean;
             readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
             readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+            readonly "~effect/Runtime/errorExitCode"?: number;
+            readonly "~effect/Runtime/errorReported"?: boolean;
         };
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
         readonly Schema: Schema.Struct<{
             readonly name: Schema.Literal<Name>;
             readonly data: DataSchema;
@@ -153,6 +160,11 @@ export declare const InvalidError: {
         }>;
         readonly tag: Name;
         isInstance(input: unknown): input is InstanceType</*elided*/ any>;
+        isError(error: unknown): error is Error;
+        isError(value: unknown): value is Error;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        stackTraceLimit: number;
         hasName(error: unknown, name: string): boolean;
         create<Name_1 extends string, Fields extends Schema.Struct.Fields>(name: Name_1, fields: Fields): ReturnType<typeof NamedError.createSchemaClass<Name_1, Schema.Struct<Fields>>>;
         create<Name_1 extends string, DataSchema_1 extends Schema.Top>(name: Name_1, data: DataSchema_1): ReturnType<typeof NamedError.createSchemaClass<Name_1, DataSchema_1>>;
@@ -184,12 +196,13 @@ export declare const InvalidError: {
                 message: string;
                 stack?: string;
                 cause?: unknown;
-                readonly "~effect/Runtime/errorExitCode"?: number;
-                readonly "~effect/Runtime/errorReported"?: boolean;
                 readonly "~effect/ErrorReporter/ignore"?: boolean;
                 readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
                 readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+                readonly "~effect/Runtime/errorExitCode"?: number;
+                readonly "~effect/Runtime/errorReported"?: boolean;
             };
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
             readonly Schema: Schema.Struct<{
                 readonly name: Schema.Literal<"UnknownError">;
                 readonly data: Schema.Struct<{
@@ -228,28 +241,23 @@ export declare const InvalidError: {
                 message: string;
                 stack?: string;
                 cause?: unknown;
-                readonly "~effect/Runtime/errorExitCode"?: number;
-                readonly "~effect/Runtime/errorReported"?: boolean;
                 readonly "~effect/ErrorReporter/ignore"?: boolean;
                 readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
                 readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+                readonly "~effect/Runtime/errorExitCode"?: number;
+                readonly "~effect/Runtime/errorReported"?: boolean;
             };
+            isError(error: unknown): error is Error;
+            isError(value: unknown): value is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            stackTraceLimit: number;
             hasName(error: unknown, name: string): boolean;
             create<Name_1 extends string, Fields extends Schema.Struct.Fields>(name: Name_1, fields: Fields): ReturnType<typeof NamedError.createSchemaClass<Name_1, Schema.Struct<Fields>>>;
             create<Name_1 extends string, DataSchema_1 extends Schema.Top>(name: Name_1, data: DataSchema_1): ReturnType<typeof NamedError.createSchemaClass<Name_1, DataSchema_1>>;
             createSchemaClass<Name extends string, DataSchema extends Schema.Top>(name: Name, data: DataSchema): /*elided*/ any;
             readonly Unknown: /*elided*/ any;
-            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
-            stackTraceLimit: number;
-            isError(value: unknown): value is Error;
         };
-        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
-        stackTraceLimit: number;
-        isError(value: unknown): value is Error;
     };
     readonly Unknown: {
         new (data: {
@@ -278,12 +286,13 @@ export declare const InvalidError: {
             message: string;
             stack?: string;
             cause?: unknown;
-            readonly "~effect/Runtime/errorExitCode"?: number;
-            readonly "~effect/Runtime/errorReported"?: boolean;
             readonly "~effect/ErrorReporter/ignore"?: boolean;
             readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
             readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+            readonly "~effect/Runtime/errorExitCode"?: number;
+            readonly "~effect/Runtime/errorReported"?: boolean;
         };
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
         readonly Schema: Schema.Struct<{
             readonly name: Schema.Literal<"UnknownError">;
             readonly data: Schema.Struct<{
@@ -322,12 +331,17 @@ export declare const InvalidError: {
             message: string;
             stack?: string;
             cause?: unknown;
-            readonly "~effect/Runtime/errorExitCode"?: number;
-            readonly "~effect/Runtime/errorReported"?: boolean;
             readonly "~effect/ErrorReporter/ignore"?: boolean;
             readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
             readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+            readonly "~effect/Runtime/errorExitCode"?: number;
+            readonly "~effect/Runtime/errorReported"?: boolean;
         };
+        isError(error: unknown): error is Error;
+        isError(value: unknown): value is Error;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        stackTraceLimit: number;
         hasName(error: unknown, name: string): boolean;
         create<Name extends string, Fields extends Schema.Struct.Fields>(name: Name, fields: Fields): ReturnType<typeof NamedError.createSchemaClass<Name, Schema.Struct<Fields>>>;
         create<Name extends string, DataSchema extends Schema.Top>(name: Name, data: DataSchema): ReturnType<typeof NamedError.createSchemaClass<Name, DataSchema>>;
@@ -346,12 +360,13 @@ export declare const InvalidError: {
                 message: string;
                 stack?: string;
                 cause?: unknown;
-                readonly "~effect/Runtime/errorExitCode"?: number;
-                readonly "~effect/Runtime/errorReported"?: boolean;
                 readonly "~effect/ErrorReporter/ignore"?: boolean;
                 readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
                 readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+                readonly "~effect/Runtime/errorExitCode"?: number;
+                readonly "~effect/Runtime/errorReported"?: boolean;
             };
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
             readonly Schema: Schema.Struct<{
                 readonly name: Schema.Literal<Name>;
                 readonly data: DataSchema;
@@ -362,27 +377,17 @@ export declare const InvalidError: {
             }>;
             readonly tag: Name;
             isInstance(input: unknown): input is InstanceType</*elided*/ any>;
+            isError(error: unknown): error is Error;
+            isError(value: unknown): value is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            stackTraceLimit: number;
             hasName(error: unknown, name: string): boolean;
             create<Name_1 extends string, Fields extends Schema.Struct.Fields>(name: Name_1, fields: Fields): ReturnType<typeof NamedError.createSchemaClass<Name_1, Schema.Struct<Fields>>>;
             create<Name_1 extends string, DataSchema_1 extends Schema.Top>(name: Name_1, data: DataSchema_1): ReturnType<typeof NamedError.createSchemaClass<Name_1, DataSchema_1>>;
             createSchemaClass<Name extends string, DataSchema extends Schema.Top>(name: Name, data: DataSchema): /*elided*/ any;
             readonly Unknown: /*elided*/ any;
-            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
-            stackTraceLimit: number;
-            isError(value: unknown): value is Error;
         };
         readonly Unknown: /*elided*/ any;
-        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
-        stackTraceLimit: number;
-        isError(value: unknown): value is Error;
     };
-    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
-    stackTraceLimit: number;
-    isError(value: unknown): value is Error;
 };

package/dist/types/v1/config/migrate.d.ts

@@ -6,18 +6,11 @@ import { ConfigMCPV1 } from "./mcp.js";
 import { ConfigProviderV1 } from "./provider.js";
 export declare function normalizeAction(action: string): string;
 export declare function migrateAgent(info: ConfigAgentV1.Info): {
-    readonly description?: string | undefined;
-    readonly hidden?: boolean | undefined;
-    readonly mode?: "subagent" | "primary" | "all" | undefined;
-    readonly disabled?: boolean | undefined;
     readonly model?: string | {
         readonly providerID: string;
         readonly model: string;
         readonly variant?: string | undefined;
     } | undefined;
-    readonly system?: string | undefined;
-    readonly color?: string | undefined;
-    readonly steps?: number | undefined;
     readonly request?: {
         readonly headers?: {
             readonly [x: string]: string;
@@ -26,10 +19,17 @@ export declare function migrateAgent(info: ConfigAgentV1.Info): {
             readonly [x: string]: Schema.Json;
         } | undefined;
     } | undefined;
+    readonly system?: string | undefined;
+    readonly description?: string | undefined;
+    readonly mode?: "all" | "primary" | "subagent" | undefined;
+    readonly hidden?: boolean | undefined;
+    readonly color?: string | undefined;
+    readonly steps?: number | undefined;
+    readonly disabled?: boolean | undefined;
     readonly permissions?: readonly {
         readonly action: string;
         readonly resource: string;
-        readonly effect: "allow" | "deny" | "ask";
+        readonly effect: "allow" | "ask" | "deny";
     }[] | undefined;
 };
 export declare function migrateCommand(command: ConfigCommandV1.Info): {
@@ -37,16 +37,16 @@ export declare function migrateCommand(command: ConfigCommandV1.Info): {
     description: string | undefined;
     agent: string | undefined;
     model: {
-        variant?: string | undefined;
         providerID: string;
         model: string;
+        variant?: string | undefined;
     } | undefined;
     subagent: boolean | undefined;
 };
 export declare function modelSelection(input?: string, variant?: string): {
-    variant?: string | undefined;
     providerID: string;
     model: string;
+    variant?: string | undefined;
 } | undefined;
 export declare function migrateMcpTimeout(timeout: number): {
     startup: number;
@@ -54,6 +54,7 @@ export declare function migrateMcpTimeout(timeout: number): {
     execution: number;
 };
 export declare function migrateMcp(info: ConfigMCPV1.Info): {
+    url?: undefined;
     type: "local";
     command: string[];
     cwd: string | undefined;
@@ -66,10 +67,12 @@ export declare function migrateMcp(info: ConfigMCPV1.Info): {
         catalog: number;
         execution: number;
     } | undefined;
-    url?: undefined;
     headers?: undefined;
     oauth?: undefined;
 } | {
+    command?: undefined;
+    cwd?: undefined;
+    environment?: undefined;
     type: "remote";
     url: string;
     headers: {
@@ -88,9 +91,6 @@ export declare function migrateMcp(info: ConfigMCPV1.Info): {
         catalog: number;
         execution: number;
     } | undefined;
-    command?: undefined;
-    cwd?: undefined;
-    environment?: undefined;
 };
 export declare function migrateProvider(sourceID: string, info: ConfigProviderV1.Info): {
     name: string | undefined;

package/dist/types/v1/config/permission.d.ts

@@ -3,9 +3,9 @@ import { Schema } from "effect";
 export declare const Action: Schema.Literals<readonly ["ask", "allow", "deny"]>;
 export type Action = Schema.Schema.Type<typeof Action>;
 export declare const Entries: <A, I>(value: Schema.Codec<A, I>) => Schema.decodeTo<Schema.$Array<Schema.Tuple<readonly [Schema.String, Schema.Codec<A, I, never, never>]>>, Schema.ObjectKeyword, never, never>;
-export declare const Object: Schema.decodeTo<Schema.$Array<Schema.Tuple<readonly [Schema.String, Schema.Codec<"allow" | "deny" | "ask", "allow" | "deny" | "ask", never, never>]>>, Schema.ObjectKeyword, never, never>;
+export declare const Object: Schema.decodeTo<Schema.$Array<Schema.Tuple<readonly [Schema.String, Schema.Codec<"allow" | "ask" | "deny", "allow" | "ask" | "deny", never, never>]>>, Schema.ObjectKeyword, never, never>;
 export type Object = Schema.Schema.Type<typeof Object>;
-export declare const Rule: Schema.Union<readonly [Schema.Literals<readonly ["ask", "allow", "deny"]>, Schema.decodeTo<Schema.$Array<Schema.Tuple<readonly [Schema.String, Schema.Codec<"allow" | "deny" | "ask", "allow" | "deny" | "ask", never, never>]>>, Schema.ObjectKeyword, never, never>]>;
+export declare const Rule: Schema.Union<readonly [Schema.Literals<readonly ["ask", "allow", "deny"]>, Schema.decodeTo<Schema.$Array<Schema.Tuple<readonly [Schema.String, Schema.Codec<"allow" | "ask" | "deny", "allow" | "ask" | "deny", never, never>]>>, Schema.ObjectKeyword, never, never>]>;
 export type Rule = Schema.Schema.Type<typeof Rule>;
-export declare const Info: Schema.decodeTo<Schema.decodeTo<Schema.$Array<Schema.Tuple<readonly [Schema.String, Schema.Codec<"allow" | "deny" | "ask" | readonly (readonly [string, "allow" | "deny" | "ask"])[], object | "allow" | "deny" | "ask", never, never>]>>, Schema.ObjectKeyword, never, never>, Schema.Union<readonly [Schema.Literals<readonly ["ask", "allow", "deny"]>, Schema.ObjectKeyword]>, never, never>;
+export declare const Info: Schema.decodeTo<Schema.decodeTo<Schema.$Array<Schema.Tuple<readonly [Schema.String, Schema.Codec<"allow" | "ask" | "deny" | readonly (readonly [string, "allow" | "ask" | "deny"])[], "allow" | "ask" | "deny" | object, never, never>]>>, Schema.ObjectKeyword, never, never>, Schema.Union<readonly [Schema.Literals<readonly ["ask", "allow", "deny"]>, Schema.ObjectKeyword]>, never, never>;
 export type Info = Schema.Schema.Type<typeof Info>;

package/dist/types/wellknown.d.ts

@@ -89,13 +89,13 @@ export declare const Event: {
     };
 };
 export declare const inspect: (origin: string) => Effect.Effect<{
-    readonly config?: {
-        readonly [x: string]: Schema.Json;
-    } | null | undefined;
     readonly auth?: {
         readonly command: readonly string[];
         readonly env: string;
     } | undefined;
+    readonly config?: {
+        readonly [x: string]: Schema.Json;
+    } | null | undefined;
     readonly remote_config?: {
         readonly url: string;
         readonly headers?: {
@@ -103,7 +103,5 @@ export declare const inspect: (origin: string) => Effect.Effect<{
         } | undefined;
     } | undefined;
 }, Error, HttpClient.HttpClient>;
-export declare const resolve: (input: ResolveInput) => Effect.Effect<{
-    readonly [x: string]: Schema.Json;
-}[], Error, HttpClient.HttpClient>;
+export declare const resolve: (input: ResolveInput) => Effect.Effect<Schema.JsonObject[], Error, HttpClient.HttpClient>;
 export declare const node: import("@opencode/util/effect/layer-node").Provider<Service, never, import("@opencode/util/effect/layer-node").Tag<"global">>;

package/dist/types/workspace/sql.d.ts

@@ -85,5 +85,5 @@ export declare const WorkspaceTable: import("drizzle-orm/sqlite-core").SQLiteTab
             generated: undefined;
         }, {}>;
     };
-    dialect: "sqlite";
+    dialect: 'sqlite';
 }>;

package/dist/types/worktree/git.d.ts

@@ -12,10 +12,10 @@ export declare const make: Effect.Effect<{
         branch?: string;
     }) => Effect.Effect<{
         directory: string & import("effect/Brand").Brand<"AbsolutePath">;
-    }, Git.WorktreeError | DirectoryUnavailableError, never>;
+    }, DirectoryUnavailableError | Git.WorktreeError, never>;
     remove: (input: {
         directory: import("@opencode/schema/schema").AbsolutePath;
         force: boolean;
-    }) => Effect.Effect<undefined, Git.WorktreeError | DirectoryUnavailableError, never>;
-    list: (directory: string & import("effect/Brand").Brand<"AbsolutePath">) => Effect.Effect<Worktree.ListEntry[], Git.WorktreeError | DirectoryUnavailableError, never>;
+    }) => Effect.Effect<undefined, DirectoryUnavailableError | Git.WorktreeError, never>;
+    list: (directory: string & import("effect/Brand").Brand<"AbsolutePath">) => Effect.Effect<Worktree.ListEntry[], DirectoryUnavailableError | Git.WorktreeError, never>;
 }, never, FSUtil.Service | Git.Service>;

package/dist/types/worktree/sql.d.ts

@@ -67,5 +67,5 @@ export declare const WorktreeTable: import("drizzle-orm/sqlite-core").SQLiteTabl
             generated: undefined;
         }, {}>;
     };
-    dialect: "sqlite";
+    dialect: 'sqlite';
 }>;

package/dist/util/error-summary.js

@@ -1,7 +1,7 @@
 import {
   from2,
   exports_error_summary
-} from "../chunks/instance-3zsf4n22.js";
+} from "../chunks/shell-3zsf4n22.js";
 export {
   exports_error_summary as ErrorSummary,
   from2 as from

package/dist/util/error.js

@@ -1,6 +1,6 @@
 import {
   NamedError2
-} from "../chunks/instance-2axfhc9x.js";
+} from "../chunks/shell-2axfhc9x.js";
 export {
   NamedError2 as NamedError
 };