@codeworksh/plugin 0.0.1-canary.10.1.g65d5c167

package/settings.mjs

@@ -0,0 +1,132 @@
+import { isAikitModelInfo, validateAikitModelInfo } from "./schema.mjs";
+import { Model as Model$1 } from "@codeworksh/aikit";
+import { Effect, Schema, SchemaGetter, SchemaIssue } from "effect";
+//#region src/settings.ts
+const ThinkingLevel = Schema.Literals(Object.values(Model$1.ThinkingLevelEnum));
+const ToolExecution = Schema.Literals(["sequential", "parallel"]);
+const Budgets = Schema.Record(Schema.Literals(Object.values(Model$1.ThinkingLevelEnum).filter((level) => level !== "off")), Schema.optional(Schema.Finite));
+/** Aikit does not export its request schema; keep this routing surface checked against its public types. */
+const requestFields = {
+	temperature: Schema.optional(Schema.Finite),
+	maxTokens: Schema.optional(Schema.Finite),
+	cacheRetention: Schema.optional(Schema.Literals([
+		"none",
+		"short",
+		"long"
+	])),
+	headers: Schema.optional(Schema.Record(Schema.String, Schema.String)),
+	timeoutMs: Schema.optional(Schema.Finite),
+	maxRetries: Schema.optional(Schema.Finite),
+	metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
+	thinkingBudgets: Schema.optional(Budgets),
+	baseURL: Schema.optional(Schema.String),
+	method: Schema.optional(Schema.Literals(Object.values(Model$1.APIMethodEnum)))
+};
+/**
+* An API key named, never written: `"${NAME}"`, read from the host process environment when the
+* model is called. Settings only ever hold the variable's name.
+*/
+const keyReference = /^\$\{([A-Za-z_][A-Za-z0-9_]*)\}$/;
+const keyReferenceError = "apiKey must reference an environment variable, e.g. \"${OPENAI_API_KEY}\"";
+const KeyReference = Schema.String.check(Schema.makeFilter((value) => keyReference.test(value) || keyReferenceError));
+/** The variable a `"${NAME}"` reference names. */
+const keyName = (reference) => keyReference.exec(reference)?.[1] ?? reference;
+const reserved = /* @__PURE__ */ new Set([
+	"toolChoice",
+	"activeTools",
+	"provider",
+	"id",
+	"signal",
+	"sessionId",
+	"reasoning",
+	"modelId",
+	"onPayload",
+	"api",
+	"npm",
+	"providerOptionsKey",
+	"compat",
+	"thinkingLevelMap"
+]);
+/** The wire protocol a model speaks, which a catalog entry may have wrong for a local endpoint. */
+const ModelProtocol = Schema.Literals(Object.values(Model$1.KnownProviderEnum));
+const Block = Schema.StructWithRest(Schema.Struct({
+	...requestFields,
+	protocol: Schema.optional(ModelProtocol),
+	thinkingLevel: Schema.optional(ThinkingLevel),
+	toolExecution: Schema.optional(ToolExecution),
+	contextWindow: Schema.optional(Schema.Finite),
+	/** Which environment variable holds the key for this model: `"${NAME}"`. */
+	apiKey: Schema.optional(KeyReference),
+	extras: Schema.optional(Schema.Record(Schema.String, Schema.Unknown))
+}), [Schema.Record(Schema.String, Schema.Unknown)]).check(Schema.makeFilter((value) => Object.keys(value).every((key) => !reserved.has(key)) || "Reserved configuration key in model options"));
+const Model = Schema.Struct({
+	provider: Schema.optional(Schema.String),
+	id: Schema.optional(Schema.String),
+	thinkingLevel: Schema.optional(ThinkingLevel),
+	toolExecution: Schema.optional(ToolExecution),
+	thinkingBudgets: Schema.optional(Budgets),
+	options: Schema.optional(Block),
+	providerOptions: Schema.optional(Schema.Record(Schema.String, Schema.Record(Schema.String, Block)))
+});
+const reasonOf = (cause) => cause instanceof Error ? cause.message : String(cause);
+const decodeModelEntry = (value, options) => Effect.try({
+	try: () => {
+		const entry = validateAikitModelInfo(value, "models entry");
+		if (entry.provider.key !== void 0 && !keyReference.test(entry.provider.key)) throw new Error(`models entry ${entry.provider.id}/${entry.id}: provider.key: ${keyReferenceError}`);
+		return entry;
+	},
+	catch: (cause) => new SchemaIssue.InvalidValue({ message: reasonOf(cause) }, value, options)
+});
+/**
+* A catalog entry in settings: an aikit `Model.Info`, read exactly like an entry of the generated
+* catalog. The one difference is `provider.key`, which must be a `"${NAME}"` reference.
+*/
+const ModelEntry = Schema.Unknown.pipe(Schema.decodeTo(Schema.declare(isAikitModelInfo, { expected: "aikit Model.Info" }), {
+	decode: SchemaGetter.transformEffect(decodeModelEntry),
+	encode: SchemaGetter.transformEffect(decodeModelEntry)
+}));
+/** A module to load: a path, a `file:` URL, or a package spec. */
+const PluginReference = Schema.String.check(Schema.isNonEmpty());
+/**
+* Configuration for a plugin something else already selected, named by its ID (`plugin`) or by
+* its registered module string (`package`). It never loads anything: an entry naming a plugin
+* that is not in the selection is ignored.
+*/
+const config = {
+	enabled: Schema.optional(Schema.Boolean),
+	options: Schema.optional(Schema.Record(Schema.String, Schema.Unknown))
+};
+const PluginPatch = Schema.Union([Schema.Struct({
+	plugin: PluginReference,
+	...config
+}), Schema.Struct({
+	package: PluginReference,
+	...config
+})], { mode: "oneOf" });
+const PluginEntry = Schema.Union([PluginReference, PluginPatch]);
+const Patch = Schema.Struct({
+	$schema: Schema.optional(Schema.String),
+	plugins: Schema.optional(Schema.Array(PluginEntry)),
+	model: Schema.optional(Model),
+	models: Schema.optional(Schema.Array(ModelEntry))
+});
+/** Let aikit supply model-aware generation defaults. */
+const defaults = {
+	plugins: [],
+	declared: [],
+	models: [],
+	model: {
+		provider: "openai",
+		id: "gpt-5.6-luna",
+		thinkingLevel: "high",
+		toolExecution: "sequential",
+		options: {
+			timeoutMs: 36e5,
+			maxRetries: 3
+		}
+	}
+};
+//#endregion
+export { Block, KeyReference, Model, ModelEntry, ModelProtocol, Patch, PluginEntry, PluginPatch, ThinkingLevel, ToolExecution, defaults, keyName, requestFields };
+
+//# sourceMappingURL=settings.mjs.map

package/settings.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"settings.mjs","names":["AikitModel"],"sources":["../../src/settings.ts"],"sourcesContent":["import { Model as AikitModel, type Protocol } from \"@codeworksh/aikit\";\nimport { Effect, Schema, type SchemaAST, SchemaGetter, SchemaIssue } from \"effect\";\nimport { isAikitModelInfo, validateAikitModelInfo } from \"./schema.ts\";\n\nexport const ThinkingLevel = Schema.Literals(Object.values(AikitModel.ThinkingLevelEnum));\nexport const ToolExecution = Schema.Literals([\"sequential\", \"parallel\"]);\nexport type ToolExecution = typeof ToolExecution.Type;\nconst Budgets = Schema.Record(\n\tSchema.Literals(Object.values(AikitModel.ThinkingLevelEnum).filter((level) => level !== \"off\")),\n\tSchema.optional(Schema.Finite),\n);\n\n/** Aikit does not export its request schema; keep this routing surface checked against its public types. */\nexport const requestFields = {\n\ttemperature: Schema.optional(Schema.Finite),\n\tmaxTokens: Schema.optional(Schema.Finite),\n\tcacheRetention: Schema.optional(Schema.Literals([\"none\", \"short\", \"long\"])),\n\theaders: Schema.optional(Schema.Record(Schema.String, Schema.String)),\n\ttimeoutMs: Schema.optional(Schema.Finite),\n\tmaxRetries: Schema.optional(Schema.Finite),\n\tmetadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),\n\tthinkingBudgets: Schema.optional(Budgets),\n\tbaseURL: Schema.optional(Schema.String),\n\tmethod: Schema.optional(Schema.Literals(Object.values(AikitModel.APIMethodEnum))),\n} satisfies Record<\n\t| Exclude<keyof Protocol.CommonOptions, \"signal\" | \"sessionId\" | \"reasoning\" | \"apiKey\" | \"onPayload\">\n\t| \"baseURL\"\n\t| \"method\",\n\tSchema.Top\n>;\n\n/**\n * An API key named, never written: `\"${NAME}\"`, read from the host process environment when the\n * model is called. Settings only ever hold the variable's name.\n */\nconst keyReference = /^\\$\\{([A-Za-z_][A-Za-z0-9_]*)\\}$/;\nconst keyReferenceError = 'apiKey must reference an environment variable, e.g. \"${OPENAI_API_KEY}\"';\nexport const KeyReference = Schema.String.check(\n\tSchema.makeFilter((value) => keyReference.test(value) || keyReferenceError),\n);\n\n/** The variable a `\"${NAME}\"` reference names. */\nexport const keyName = (reference: string): string => keyReference.exec(reference)?.[1] ?? reference;\n\nconst reserved = new Set([\n\t\"toolChoice\",\n\t\"activeTools\",\n\t\"provider\",\n\t\"id\",\n\t\"signal\",\n\t\"sessionId\",\n\t\"reasoning\",\n\t\"modelId\",\n\t\"onPayload\",\n\t\"api\",\n\t\"npm\",\n\t\"providerOptionsKey\",\n\t\"compat\",\n\t\"thinkingLevelMap\",\n]);\n\n/** The wire protocol a model speaks, which a catalog entry may have wrong for a local endpoint. */\nexport const ModelProtocol = Schema.Literals(Object.values(AikitModel.KnownProviderEnum));\n\nexport const Block = Schema.StructWithRest(\n\tSchema.Struct({\n\t\t...requestFields,\n\t\tprotocol: Schema.optional(ModelProtocol),\n\t\tthinkingLevel: Schema.optional(ThinkingLevel),\n\t\ttoolExecution: Schema.optional(ToolExecution),\n\t\tcontextWindow: Schema.optional(Schema.Finite),\n\t\t/** Which environment variable holds the key for this model: `\"${NAME}\"`. */\n\t\tapiKey: Schema.optional(KeyReference),\n\t\textras: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),\n\t}),\n\t[Schema.Record(Schema.String, Schema.Unknown)],\n).check(\n\tSchema.makeFilter(\n\t\t(value) => Object.keys(value).every((key) => !reserved.has(key)) || \"Reserved configuration key in model options\",\n\t),\n);\nexport type Block = typeof Block.Type;\n\nexport const Model = Schema.Struct({\n\tprovider: Schema.optional(Schema.String),\n\tid: Schema.optional(Schema.String),\n\tthinkingLevel: Schema.optional(ThinkingLevel),\n\ttoolExecution: Schema.optional(ToolExecution),\n\tthinkingBudgets: Schema.optional(Budgets),\n\toptions: Schema.optional(Block),\n\tproviderOptions: Schema.optional(Schema.Record(Schema.String, Schema.Record(Schema.String, Block))),\n});\nconst reasonOf = (cause: unknown): string => (cause instanceof Error ? cause.message : String(cause));\n\nconst decodeModelEntry = (value: unknown, options: SchemaAST.ParseOptions) =>\n\tEffect.try({\n\t\ttry: () => {\n\t\t\tconst entry = validateAikitModelInfo(value, \"models entry\");\n\t\t\tif (entry.provider.key !== undefined && !keyReference.test(entry.provider.key)) {\n\t\t\t\tthrow new Error(`models entry ${entry.provider.id}/${entry.id}: provider.key: ${keyReferenceError}`);\n\t\t\t}\n\t\t\treturn entry;\n\t\t},\n\t\tcatch: (cause) => new SchemaIssue.InvalidValue({ message: reasonOf(cause) }, value, options),\n\t});\n\n/**\n * A catalog entry in settings: an aikit `Model.Info`, read exactly like an entry of the generated\n * catalog. The one difference is `provider.key`, which must be a `\"${NAME}\"` reference.\n */\nexport const ModelEntry = Schema.Unknown.pipe(\n\tSchema.decodeTo(Schema.declare<AikitModel.Info>(isAikitModelInfo, { expected: \"aikit Model.Info\" }), {\n\t\tdecode: SchemaGetter.transformEffect(decodeModelEntry),\n\t\tencode: SchemaGetter.transformEffect(decodeModelEntry),\n\t}),\n);\nexport type ModelEntry = typeof ModelEntry.Type;\n\n/** A module to load: a path, a `file:` URL, or a package spec. */\nconst PluginReference = Schema.String.check(Schema.isNonEmpty());\n/**\n * Configuration for a plugin something else already selected, named by its ID (`plugin`) or by\n * its registered module string (`package`). It never loads anything: an entry naming a plugin\n * that is not in the selection is ignored.\n */\nconst config = {\n\tenabled: Schema.optional(Schema.Boolean),\n\toptions: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),\n};\nexport const PluginPatch = Schema.Union(\n\t[Schema.Struct({ plugin: PluginReference, ...config }), Schema.Struct({ package: PluginReference, ...config })],\n\t// `oneOf`, so an entry carrying both keys is a decode failure rather than one of them being\n\t// quietly dropped -- naming a plugin two ways at once says two different things.\n\t{ mode: \"oneOf\" },\n);\nexport const PluginEntry = Schema.Union([PluginReference, PluginPatch]);\nexport type PluginEntry = typeof PluginEntry.Type;\n\nexport const Patch = Schema.Struct({\n\t$schema: Schema.optional(Schema.String),\n\tplugins: Schema.optional(Schema.Array(PluginEntry)),\n\tmodel: Schema.optional(Model),\n\tmodels: Schema.optional(Schema.Array(ModelEntry)),\n});\nexport type Patch = typeof Patch.Type;\n\n/**\n * One plugin entry, and where it came from.\n *\n * Flattening every layer's `plugins` into one array loses the file that declared each entry, and\n * that cannot be recovered afterwards: two layers may declare the same string, so attribution is\n * genuinely gone rather than merely inconvenient. Three things need it -- anchoring a relative\n * path, naming the declaring layer in `plugin list`, and the missing-plugin diagnostic -- so the\n * loaded shape carries it from the start.\n *\n * In simple terms:\n * `written` - is what module the developer is declaring - what\n * `file` - where the module is being declared - where\n * `entry` - the resolved path of the module, relative to the `file`; especially needed for local.\n *\n * Example:\n * written: \"@acme/x@^1\"\n * entry:   \"@acme/x@^1\"\n * file:    \"/Users/me/.codework/settings.jsonc\"\n *\n * written: \"./plugins/mine.mjs\"\n * entry:   \"/Users/me/.codework/plugins/mine.mjs\"\n * file:    \"/Users/me/.codework/settings.jsonc\"\n */\nexport interface Declared {\n\t/** The entry exactly as the file spells it, which is the string a person will search for. */\n\treadonly written: PluginEntry;\n\t/** The same entry with any relative path anchored to the directory of its declaring file. */\n\treadonly entry: PluginEntry;\n\t/** The settings file that declared it. */\n\treadonly file: string;\n}\n\n/** A `models` entry, and the settings file that declared it. */\nexport interface DeclaredModel {\n\treadonly entry: AikitModel.Info;\n\treadonly file: string;\n}\n\nexport interface Info {\n\t/**\n\t * Plugin entries added to the harness selection, in order: every layer's entries, lowest\n\t * priority first, so a project's list extends the user's rather than replacing it.\n\t *\n\t * Anchored, and stripped of provenance: this is the list the loader consumes. {@link Info.declared}\n\t * is the same list with the file each entry came from.\n\t */\n\treadonly plugins: ReadonlyArray<PluginEntry>;\n\t/** {@link Info.plugins}, with the origin of each entry. Same order, same length. */\n\treadonly declared: ReadonlyArray<Declared>;\n\t/**\n\t * Catalog entries from every layer, lowest priority first. Applied over the generated catalog\n\t * in this order, so for one `provider.id` + `id` the last entry wins.\n\t */\n\treadonly models: ReadonlyArray<DeclaredModel>;\n\treadonly model: typeof Model.Type & {\n\t\treadonly provider: string;\n\t\treadonly id: string;\n\t\treadonly thinkingLevel: AikitModel.ThinkingLevel;\n\t\treadonly toolExecution: ToolExecution;\n\t};\n}\n\n/** Let aikit supply model-aware generation defaults. */\nexport const defaults: Info = {\n\tplugins: [],\n\tdeclared: [],\n\tmodels: [],\n\tmodel: {\n\t\tprovider: \"openai\",\n\t\tid: \"gpt-5.6-luna\",\n\t\tthinkingLevel: \"high\",\n\t\ttoolExecution: \"sequential\",\n\t\toptions: { timeoutMs: 3_600_000, maxRetries: 3 },\n\t},\n};\n"],"mappings":"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"}

package/shell-CZ6Y4lNU.d.mts

@@ -0,0 +1,109 @@
+import { Context, Effect, Schema, Stream } from "effect";
+//#region src/sandbox/shell.d.ts
+declare const ShellError_base: Schema.Class<ShellError, Schema.TaggedStruct<"ShellError", {
+  readonly command: Schema.String;
+  readonly cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * The pluggable execution contract. Local sandboxes usually get a Shell through
+ * just-bash over the local `Local.Vfs`; remote sandboxes provide their own
+ * native Shell. Either way the rest of the harness depends only on this service
+ * tag.
+ */
+declare class ShellError extends ShellError_base {}
+interface ExecResult {
+  readonly stdout: string;
+  readonly stderr: string;
+  readonly exitCode: number;
+}
+/**
+ * One options shape for every entry point. `cwd` is the operation-level
+ * override: it wins over the mount's working directory, and a relative value
+ * resolves against it. Neither mutates shared state, so concurrent commands in
+ * one mount can run in different directories.
+ */
+interface ShellOptions {
+  readonly env?: Record<string, string>;
+  readonly cwd?: string;
+}
+/**
+ * A streamed chunk of command output, terminated by a single `exit` carrying the
+ * exit code. (A backend-level mirror of the tool layer's event; kept here so
+ * `sandbox/` does not depend on `tool/`.)
+ */
+type ExecChunk = {
+  readonly _tag: "stdout";
+  readonly bytes: Uint8Array;
+} | {
+  readonly _tag: "stderr";
+  readonly bytes: Uint8Array;
+} | {
+  readonly _tag: "exit";
+  readonly exitCode: number;
+};
+/**
+ * The command-execution capability a sandbox exposes. For an in-process
+ * backend this is just-bash; for a remote backend it is the sandbox's own
+ * shell. The {@link Shell} service tag carries this interface.
+ */
+interface ISandboxExe {
+  readonly exec: (command: string, options?: ShellOptions) => Effect.Effect<ExecResult, ShellError>;
+  /**
+   * Run a program with an explicit argument vector, bypassing shell word
+   * splitting. Callers that build commands from untrusted values — branch
+   * names, file paths — must use this instead of interpolating into
+   * {@link exec}, where a space or `$(…)` would change what runs.
+   *
+   * Backends whose transport only accepts a string quote the vector with
+   * {@link quote}; backends that spawn directly pass it through untouched.
+   */
+  readonly execArgv: (argv: ReadonlyArray<string>, options?: ShellOptions) => Effect.Effect<ExecResult, ShellError>;
+  /**
+   * Optional streaming output: stdout/stderr chunks then a terminal `exit`.
+   * Backends that can stream (e.g. Vercel) implement it; `ToolShell.fromSandboxShell`
+   * bridges it to `ToolShell.stream` so the bash tool streams over them too.
+   */
+  readonly stream?: (command: string, options?: ShellOptions) => Stream.Stream<ExecChunk, ShellError>;
+}
+type MountFactory = (cwd: string) => ISandboxExe;
+declare const perMount: (transport: ISandboxExe, make: MountFactory) => ISandboxExe;
+/**
+ * POSIX single-quote escaping: wrap in `'…'` and rewrite each embedded quote as
+ * `'\''`. Everything inside single quotes is literal to the shell, so this is
+ * safe for arbitrary bytes.
+ */
+declare const quote: (value: string) => string;
+/** Render an argument vector as one shell-safe command string. */
+declare const quoteArgv: (argv: ReadonlyArray<string>) => string;
+/**
+ * Resolve a per-command cwd against the sandbox cwd. Passing a relative cwd
+ * straight to a host or remote process API would otherwise resolve it against
+ * that API's own default, which need not be the filesystem's configured cwd.
+ */
+declare const resolveCwd: (base: string | undefined, cwd: string | undefined) => string | undefined;
+/**
+ * Complete a string-only backend: `execArgv` quotes the vector and runs it
+ * through `exec`. Backends that spawn a real argument vector (Vercel) implement
+ * `execArgv` themselves instead, so the args never meet a shell parser at all.
+ *
+ * `cwd` rides the options rather than a `cd <dir> && …` prefix. Every backend
+ * we wrap takes a working directory natively, and the prefix form cannot tell a
+ * failed `cd` from a failed command — both arrive as one exit code.
+ */
+declare const fromExec: (backend: Omit<ISandboxExe, "execArgv">) => ISandboxExe;
+/**
+ * Bind a cwd-neutral backend to one mount's working directory.
+ *
+ * The transport is shared between mounts and must stay rooted at the namespace
+ * root, so the directory cannot live inside it: two mounts at different
+ * directories would otherwise see each other's. This wrapper is per mount, and
+ * an operation-level `cwd` still wins — resolved against the mount's, so a
+ * relative one means what it reads like.
+ */
+declare const withCwd: (backend: ISandboxExe, cwd: string) => ISandboxExe;
+declare const Shell_base: Context.ServiceClass<Shell, "@codeworksh/plugin/sandbox/shell", ISandboxExe>;
+/** Execution service — the live {@link ISandboxExe} for the active sandbox. */
+declare class Shell extends Shell_base {}
+//#endregion
+export { ShellError as a, perMount as c, resolveCwd as d, withCwd as f, Shell as i, quote as l, ExecResult as n, ShellOptions as o, ISandboxExe as r, fromExec as s, ExecChunk as t, quoteArgv as u };
+//# sourceMappingURL=shell-CZ6Y4lNU.d.mts.map

package/space-CR-9UxdT.d.mts

@@ -0,0 +1,25 @@
+import { Schema } from "effect";
+declare namespace space_d_exports {
+  export { ID, Info, Kind, space_d_exports as SpaceSchema, Status };
+}
+declare const ID: Schema.brand<Schema.String, "Space.ID">;
+type ID = typeof ID.Type;
+declare const Kind: Schema.Literals<readonly ["primary", "linked", "copy", "plain"]>;
+type Kind = typeof Kind.Type;
+declare const Status: Schema.Literals<readonly ["active", "archived"]>;
+type Status = typeof Status.Type;
+declare const Info_base: Schema.Class<Info, Schema.Struct<{
+  readonly id: Schema.brand<Schema.String, "Space.ID">;
+  readonly projectId: Schema.brand<Schema.String, "Project.ID">;
+  readonly location: Schema.brand<Schema.String, "AbsolutePath">;
+  readonly kind: Schema.Literals<readonly ["primary", "linked", "copy", "plain"]>;
+  readonly env: Schema.brand<Schema.String, "SandboxInstance.ID"> & {
+    local: string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+    create: () => string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+  };
+  readonly status: Schema.Literals<readonly ["active", "archived"]>;
+}>, {}>;
+declare class Info extends Info_base {}
+//#endregion
+export { space_d_exports as a, Status as i, Info as n, Kind as r, ID as t };
+//# sourceMappingURL=space-CR-9UxdT.d.mts.map

package/space.d.mts

@@ -0,0 +1,2 @@
+import { a as space_d_exports, i as Status, n as Info, r as Kind, t as ID } from "./space-CR-9UxdT.mjs";
+export { ID, Info, Kind, space_d_exports as SpaceSchema, Status };

package/space.mjs

@@ -0,0 +1,33 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { AbsolutePath } from "./schema.mjs";
+import { ID as ID$1 } from "./project.mjs";
+import { ID as ID$2 } from "./sandbox/instance.mjs";
+import { Schema } from "effect";
+//#region src/space.ts
+var space_exports = /* @__PURE__ */ __exportAll({
+	ID: () => ID,
+	Info: () => Info,
+	Kind: () => Kind,
+	SpaceSchema: () => space_exports,
+	Status: () => Status
+});
+const ID = Schema.String.pipe(Schema.brand("Space.ID"));
+const Kind = Schema.Literals([
+	"primary",
+	"linked",
+	"copy",
+	"plain"
+]);
+const Status = Schema.Literals(["active", "archived"]);
+var Info = class extends Schema.Class("Space.Info")({
+	id: ID,
+	projectId: ID$1,
+	location: AbsolutePath,
+	kind: Kind,
+	env: ID$2,
+	status: Status
+}) {};
+//#endregion
+export { ID, Info, Kind, space_exports as SpaceSchema, Status };
+
+//# sourceMappingURL=space.mjs.map

package/space.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"space.mjs","names":["ProjectSchema.ID","SandboxInstance.ID"],"sources":["../../src/space.ts"],"sourcesContent":["import { Schema } from \"effect\";\nimport { ProjectSchema } from \"./project.ts\";\nimport { SandboxInstance } from \"./sandbox/instance.ts\";\nimport { AbsolutePath } from \"./schema.ts\";\n\n// hash(env, location) — no project component, so re-pointing a space to\n// another project never rewrites the key sessions reference.\nexport const ID = Schema.String.pipe(Schema.brand(\"Space.ID\"));\nexport type ID = typeof ID.Type;\n\n// primary: the main checkout (one per project+env); linked: a git worktree\n// sharing the primary's store; copy: another clone; plain: a non-git directory.\nexport const Kind = Schema.Literals([\"primary\", \"linked\", \"copy\", \"plain\"]);\nexport type Kind = typeof Kind.Type;\n\nexport const Status = Schema.Literals([\"active\", \"archived\"]);\nexport type Status = typeof Status.Type;\n\n// One directory in one env that belongs to a project; the unit sessions attach to.\nexport class Info extends Schema.Class<Info>(\"Space.Info\")({\n\tid: ID,\n\tprojectId: ProjectSchema.ID,\n\tlocation: AbsolutePath,\n\tkind: Kind,\n\tenv: SandboxInstance.ID,\n\tstatus: Status,\n}) {}\n\nexport * as SpaceSchema from \"./space.ts\";\n"],"mappings":";;;;;;;;;;;;;AAOA,MAAa,KAAK,OAAO,OAAO,KAAK,OAAO,MAAM,UAAU,CAAC;AAK7D,MAAa,OAAO,OAAO,SAAS;CAAC;CAAW;CAAU;CAAQ;AAAO,CAAC;AAG1E,MAAa,SAAS,OAAO,SAAS,CAAC,UAAU,UAAU,CAAC;AAI5D,IAAa,OAAb,cAA0B,OAAO,MAAY,YAAY,CAAC,CAAC;CAC1D,IAAI;CACJ,WAAWA;CACX,UAAU;CACV,MAAM;CACN,KAAKC;CACL,QAAQ;AACT,CAAC,CAAC,CAAC,CAAC"}

package/tool/error.d.mts

@@ -0,0 +1,2 @@
+import { t as ToolExecutionError } from "../error-ClDISWlT.mjs";
+export { ToolExecutionError };

package/tool/error.mjs

@@ -0,0 +1,11 @@
+import { Schema } from "effect";
+//#region src/tool/error.ts
+/** A typed wrapper for a tool failure crossing the heterogeneous registry boundary. */
+var ToolExecutionError = class extends Schema.TaggedError()("ToolExecutionError", {
+	toolName: Schema.String,
+	cause: Schema.Defect()
+}) {};
+//#endregion
+export { ToolExecutionError };
+
+//# sourceMappingURL=error.mjs.map

package/tool/error.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.mjs","names":[],"sources":["../../../src/tool/error.ts"],"sourcesContent":["import { Schema } from \"effect\";\n\n/** A typed wrapper for a tool failure crossing the heterogeneous registry boundary. */\nexport class ToolExecutionError extends Schema.TaggedError<ToolExecutionError>()(\"ToolExecutionError\", {\n\ttoolName: Schema.String,\n\tcause: Schema.Defect(),\n}) {}\n"],"mappings":";;;AAGA,IAAa,qBAAb,cAAwC,OAAO,YAAgC,CAAC,CAAC,sBAAsB;CACtG,UAAU,OAAO;CACjB,OAAO,OAAO,OAAO;AACtB,CAAC,CAAC,CAAC,CAAC"}

package/tool/progress.d.mts

@@ -0,0 +1,2 @@
+import { _ as IToolProgress, b as make, v as ToolProgress, x as noop, y as ToolProgressPartial } from "../tool-DuYBgiJf.mjs";
+export { IToolProgress, ToolProgress, ToolProgressPartial, make, noop };

package/tool/progress.mjs

@@ -0,0 +1,11 @@
+import { Context, Effect, Layer } from "effect";
+//#region src/tool/progress.ts
+var ToolProgress = class extends Context.Service()("@codeworksh/plugin/tool/progress/ToolProgress") {};
+/** Build a `ToolProgress` Layer from a `report` implementation. */
+const make = (report) => Layer.succeed(ToolProgress, ToolProgress.of({ report }));
+/** Drops every update — the default until the executor wires a live event sink. */
+const noop = make(() => Effect.void);
+//#endregion
+export { ToolProgress, make, noop };
+
+//# sourceMappingURL=progress.mjs.map

package/tool/progress.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"progress.mjs","names":[],"sources":["../../../src/tool/progress.ts"],"sourcesContent":["import { Context, Effect, Layer } from \"effect\";\nimport type { ModelContent } from \"../tool.ts\";\n\n/**\n * `ToolProgress` — the side-channel a long-running tool (e.g. streaming bash)\n * writes interim output to, instead of an `onUpdate` callback.\n *\n * Most tools never call `report` and keep a clean `Effect<Success, Failure>`\n * signature. Throttling / coalescing lives in the Layer (the live one routes to\n * the run's event PubSub, tagged with the active callID); the handler just\n * reports.\n */\n\n/** Mirror of aikit's `Message.ToolRunningPartial` (kept structural to stay decoupled). */\nexport interface ToolProgressPartial {\n\treadonly content?: ModelContent;\n\treadonly details?: unknown;\n}\n\nexport interface IToolProgress {\n\treadonly report: (partial: ToolProgressPartial) => Effect.Effect<void>;\n}\n\nexport class ToolProgress extends Context.Service<ToolProgress, IToolProgress>()(\n\t\"@codeworksh/plugin/tool/progress/ToolProgress\",\n) {}\n\n/** Build a `ToolProgress` Layer from a `report` implementation. */\nexport const make = (report: IToolProgress[\"report\"]): Layer.Layer<ToolProgress> =>\n\tLayer.succeed(ToolProgress, ToolProgress.of({ report }));\n\n/** Drops every update — the default until the executor wires a live event sink. */\nexport const noop: Layer.Layer<ToolProgress> = make(() => Effect.void);\n"],"mappings":";;AAuBA,IAAa,eAAb,cAAkC,QAAQ,QAAqC,CAAC,CAC/E,+CACD,CAAC,CAAC,CAAC;;AAGH,MAAa,QAAQ,WACpB,MAAM,QAAQ,cAAc,aAAa,GAAG,EAAE,OAAO,CAAC,CAAC;;AAGxD,MAAa,OAAkC,WAAW,OAAO,IAAI"}

package/tool-BoVqkYvL.d.mts

@@ -0,0 +1,287 @@
+import { a as RegisteredTool, i as ModelContent, t as AnyToolDef } from "./tool-DuYBgiJf.mjs";
+import { Effect, Schema } from "effect";
+declare namespace tool_d_exports {
+  export { HookReturn, ToolAddOptions, ToolAfter, ToolAfterFn, ToolAfterResult, ToolBefore, ToolBeforeFn, ToolBeforeResult, ToolDefPatch, ToolRegistration, ToolRegistry, ToolResultContent };
+}
+declare const ToolBefore: Schema.Struct<{
+  readonly callID: Schema.String;
+  readonly toolName: Schema.String;
+  readonly rawArgs: Schema.$Record<Schema.String, Schema.Unknown>;
+  readonly sessionId: Schema.brand<Schema.String, "Session.ID"> & {
+    ascending: (id?: string) => string & import("effect/Brand").Brand<"Session.ID">;
+    create: () => string & import("effect/Brand").Brand<"Session.ID">;
+  };
+  readonly messageId: Schema.brand<Schema.String, "Message.ID"> & {
+    create: () => string & import("effect/Brand").Brand<"Message.ID">;
+    from: (id: string) => string & import("effect/Brand").Brand<"Message.ID">;
+  };
+  readonly params: Schema.Unknown;
+}>;
+type ToolBefore = typeof ToolBefore.Type;
+declare const ToolAfter: Schema.Struct<{
+  readonly callID: Schema.String;
+  readonly toolName: Schema.String;
+  readonly rawArgs: Schema.$Record<Schema.String, Schema.Unknown>;
+  readonly sessionId: Schema.brand<Schema.String, "Session.ID"> & {
+    ascending: (id?: string) => string & import("effect/Brand").Brand<"Session.ID">;
+    create: () => string & import("effect/Brand").Brand<"Session.ID">;
+  };
+  readonly messageId: Schema.brand<Schema.String, "Message.ID"> & {
+    create: () => string & import("effect/Brand").Brand<"Message.ID">;
+    from: (id: string) => string & import("effect/Brand").Brand<"Message.ID">;
+  };
+  readonly params: Schema.Unknown;
+  readonly terminal: Schema.decodeTo<Schema.declare<{
+    addedToolNames?: string[];
+    arguments: Record<string, any>;
+    callID: string;
+    name: string;
+    namespace?: string;
+    result: {
+      content: ({
+        type: "text";
+        text: string;
+        textSignature?: string;
+      } | {
+        type: "image";
+        data: string;
+        mimeType: string;
+      })[];
+      details?: any;
+      isError: false;
+    };
+    status: "completed";
+    thoughtSignature?: string;
+    time: {
+      start: number;
+      end: number;
+    };
+    type: "toolCall";
+  } | {
+    addedToolNames?: string[];
+    arguments: Record<string, any>;
+    callID: string;
+    name: string;
+    namespace?: string;
+    result: {
+      content: ({
+        type: "text";
+        text: string;
+        textSignature?: string;
+      } | {
+        type: "image";
+        data: string;
+        mimeType: string;
+      })[];
+      details?: any;
+      isError: true;
+    };
+    status: "error";
+    thoughtSignature?: string;
+    time: {
+      start: number;
+      end: number;
+    };
+    type: "toolCall";
+  } | {
+    addedToolNames?: string[];
+    arguments: Record<string, any>;
+    callID: string;
+    name: string;
+    namespace?: string;
+    result: {
+      content: ({
+        type: "text";
+        text: string;
+        textSignature?: string;
+      } | {
+        type: "image";
+        data: string;
+        mimeType: string;
+      })[];
+      details?: any;
+      isError: true;
+    };
+    status: "skipped";
+    thoughtSignature?: string;
+    time: {
+      start: number;
+      end: number;
+    };
+    type: "toolCall";
+  } | {
+    addedToolNames?: string[];
+    arguments: Record<string, any>;
+    callID: string;
+    name: string;
+    namespace?: string;
+    result: {
+      content: ({
+        type: "text";
+        text: string;
+        textSignature?: string;
+      } | {
+        type: "image";
+        data: string;
+        mimeType: string;
+      })[];
+      details?: any;
+      isError: true;
+    };
+    status: "aborted";
+    thoughtSignature?: string;
+    time: {
+      start: number;
+      end: number;
+    };
+    type: "toolCall";
+  }, {
+    addedToolNames?: string[];
+    arguments: Record<string, any>;
+    callID: string;
+    name: string;
+    namespace?: string;
+    result: {
+      content: ({
+        type: "text";
+        text: string;
+        textSignature?: string;
+      } | {
+        type: "image";
+        data: string;
+        mimeType: string;
+      })[];
+      details?: any;
+      isError: false;
+    };
+    status: "completed";
+    thoughtSignature?: string;
+    time: {
+      start: number;
+      end: number;
+    };
+    type: "toolCall";
+  } | {
+    addedToolNames?: string[];
+    arguments: Record<string, any>;
+    callID: string;
+    name: string;
+    namespace?: string;
+    result: {
+      content: ({
+        type: "text";
+        text: string;
+        textSignature?: string;
+      } | {
+        type: "image";
+        data: string;
+        mimeType: string;
+      })[];
+      details?: any;
+      isError: true;
+    };
+    status: "error";
+    thoughtSignature?: string;
+    time: {
+      start: number;
+      end: number;
+    };
+    type: "toolCall";
+  } | {
+    addedToolNames?: string[];
+    arguments: Record<string, any>;
+    callID: string;
+    name: string;
+    namespace?: string;
+    result: {
+      content: ({
+        type: "text";
+        text: string;
+        textSignature?: string;
+      } | {
+        type: "image";
+        data: string;
+        mimeType: string;
+      })[];
+      details?: any;
+      isError: true;
+    };
+    status: "skipped";
+    thoughtSignature?: string;
+    time: {
+      start: number;
+      end: number;
+    };
+    type: "toolCall";
+  } | {
+    addedToolNames?: string[];
+    arguments: Record<string, any>;
+    callID: string;
+    name: string;
+    namespace?: string;
+    result: {
+      content: ({
+        type: "text";
+        text: string;
+        textSignature?: string;
+      } | {
+        type: "image";
+        data: string;
+        mimeType: string;
+      })[];
+      details?: any;
+      isError: true;
+    };
+    status: "aborted";
+    thoughtSignature?: string;
+    time: {
+      start: number;
+      end: number;
+    };
+    type: "toolCall";
+  }>, Schema.Unknown, never, never>;
+}>;
+type ToolAfter = typeof ToolAfter.Type;
+declare const ToolBeforeResult: Schema.Struct<{
+  readonly block: Schema.Boolean;
+  readonly reason: Schema.optional<Schema.String>;
+}>;
+type ToolBeforeResult = typeof ToolBeforeResult.Type;
+type ToolResultContent = ModelContent;
+interface ToolAfterResult {
+  readonly content?: ToolResultContent;
+  readonly details?: unknown;
+  readonly isError?: boolean;
+}
+type HookReturn<A> = A | void | Promise<A | void> | Effect.Effect<A | void, unknown>;
+type ToolBeforeFn = (call: ToolBefore) => HookReturn<ToolBeforeResult>;
+type ToolAfterFn = (call: ToolAfter) => HookReturn<ToolAfterResult>;
+interface ToolAddOptions {
+  readonly beforeToolCall?: ToolBeforeFn;
+  readonly afterToolCall?: ToolAfterFn;
+}
+interface ToolDefPatch {
+  readonly description?: string;
+  readonly label?: string;
+  readonly promptSnippet?: string;
+  readonly promptGuidelines?: ReadonlyArray<string>;
+}
+/**
+ * One frozen bucket entry: the winning tool for a name together with the hooks that
+ * `add` declared alongside it. Kept here rather than in the bucket implementation so
+ * the executor shares the contract without importing plugin assembly.
+ */
+interface ToolRegistration {
+  readonly tool: RegisteredTool;
+  readonly hooks: ToolAddOptions;
+}
+interface ToolRegistry {
+  readonly add: (tool: RegisteredTool, options?: ToolAddOptions) => void;
+  readonly update: (name: string, patch: ToolDefPatch) => void;
+  readonly list: () => ReadonlyArray<AnyToolDef>;
+  readonly get: (name: string) => AnyToolDef | undefined;
+  readonly has: (name: string) => boolean;
+}
+//#endregion
+export { ToolAfterResult as a, ToolBeforeResult as c, ToolRegistry as d, ToolResultContent as f, ToolAfterFn as i, ToolDefPatch as l, ToolAddOptions as n, ToolBefore as o, tool_d_exports as p, ToolAfter as r, ToolBeforeFn as s, HookReturn as t, ToolRegistration as u };
+//# sourceMappingURL=tool-BoVqkYvL.d.mts.map