@warlock.js/ai-workspace 5.29.0 → 5.31.0

package/esm/tools/shell-output.mjs

@@ -0,0 +1,49 @@
+import { objectSchema, optionalNumberField, stringField } from "./schema.mjs";
+import { SHELL_OUTPUT_JSON_SCHEMA } from "./json-schemas.mjs";
+import { tool } from "@warlock.js/ai";
+
+//#region ../../packages/ai-workspace/src/tools/shell-output.ts
+/** Default tool name exposed to the LLM. */
+const DEFAULT_NAME = "shell_output";
+/** Input schema for the `shell_output` tool. */
+const inputSchema = objectSchema({
+	id: stringField(),
+	since: optionalNumberField(),
+	waitMs: optionalNumberField()
+}, SHELL_OUTPUT_JSON_SCHEMA);
+/**
+* Build the agent-facing `shell_output` tool: the new output of a
+* background command started with `run_shell({ background: true })`, plus
+* its state (`running` / `exited` / `killed` / `timed-out`, `exitCode`).
+*
+* Without `since` it returns everything produced since the previous read;
+* `cursor` in the result is the position to pass as `since` next time.
+* `waitMs` (at most 30 s) waits for new output or for the command to stop
+* when there is nothing new yet — the agent run's signal ends the wait
+* early. Only the newest `shell.maxOutputBytes` of a command's output are
+* kept; `droppedBytes` says how much the reader missed.
+*
+* @param ops - The shared, policy-enforced operation layer.
+* @param options - Optional overrides; `name` renames the LLM-visible tool.
+*
+* @example
+* const { data } = await makeShellOutputTool(ops).invoke({ id: "job-1", waitMs: 2_000 });
+* if (data?.stdout.includes("ready")) console.log("dev server is up");
+*/
+function makeShellOutputTool(ops, options) {
+	return tool({
+		name: options?.name ?? DEFAULT_NAME,
+		description: "Read new output of a background command started with run_shell (background: true) and see whether it is still running. Returns output since the last read; waitMs waits briefly for more.",
+		action: (input) => `Reading output of ${typeof input.id === "string" ? input.id : "a background command"}`,
+		input: inputSchema,
+		execute: (input, ctx) => ops.shellOutput(input.id, {
+			...input.since !== void 0 ? { since: input.since } : {},
+			...input.waitMs !== void 0 ? { waitMs: input.waitMs } : {},
+			...ctx?.signal ? { signal: ctx.signal } : {}
+		})
+	});
+}
+
+//#endregion
+export { makeShellOutputTool };
+//# sourceMappingURL=shell-output.mjs.map

package/esm/tools/shell-output.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"shell-output.mjs","names":[],"sources":["../../../../../../../../packages/ai-workspace/src/tools/shell-output.ts"],"sourcesContent":["import { tool, type ToolContract } from \"@warlock.js/ai\";\nimport type { ShellOutputInput, ShellOutputResult, WorkspaceOps } from \"../contracts\";\nimport { SHELL_OUTPUT_JSON_SCHEMA } from \"./json-schemas\";\nimport { objectSchema, optionalNumberField, stringField } from \"./schema\";\n\n/** Default tool name exposed to the LLM. */\nconst DEFAULT_NAME = \"shell_output\";\n\n/** Input schema for the `shell_output` tool. */\nconst inputSchema = objectSchema<ShellOutputInput>(\n  {\n    id: stringField(),\n    since: optionalNumberField(),\n    waitMs: optionalNumberField(),\n  },\n  SHELL_OUTPUT_JSON_SCHEMA,\n);\n\n/**\n * Build the agent-facing `shell_output` tool: the new output of a\n * background command started with `run_shell({ background: true })`, plus\n * its state (`running` / `exited` / `killed` / `timed-out`, `exitCode`).\n *\n * Without `since` it returns everything produced since the previous read;\n * `cursor` in the result is the position to pass as `since` next time.\n * `waitMs` (at most 30 s) waits for new output or for the command to stop\n * when there is nothing new yet — the agent run's signal ends the wait\n * early. Only the newest `shell.maxOutputBytes` of a command's output are\n * kept; `droppedBytes` says how much the reader missed.\n *\n * @param ops - The shared, policy-enforced operation layer.\n * @param options - Optional overrides; `name` renames the LLM-visible tool.\n *\n * @example\n * const { data } = await makeShellOutputTool(ops).invoke({ id: \"job-1\", waitMs: 2_000 });\n * if (data?.stdout.includes(\"ready\")) console.log(\"dev server is up\");\n */\nexport function makeShellOutputTool(\n  ops: WorkspaceOps,\n  options?: { name?: string },\n): ToolContract<ShellOutputInput, ShellOutputResult> {\n  return tool<ShellOutputInput, ShellOutputResult>({\n    name: options?.name ?? DEFAULT_NAME,\n    description:\n      \"Read new output of a background command started with run_shell \" +\n      \"(background: true) and see whether it is still running. Returns \" +\n      \"output since the last read; waitMs waits briefly for more.\",\n    action: (input) =>\n      `Reading output of ${typeof input.id === \"string\" ? input.id : \"a background command\"}`,\n    input: inputSchema,\n    execute: (input, ctx) =>\n      ops.shellOutput(input.id, {\n        ...(input.since !== undefined ? { since: input.since } : {}),\n        ...(input.waitMs !== undefined ? { waitMs: input.waitMs } : {}),\n        ...(ctx?.signal ? { signal: ctx.signal } : {}),\n      }),\n  });\n}\n"],"mappings":";;;;;;AAMA,MAAM,eAAe;;AAGrB,MAAM,cAAc,aAClB;CACE,IAAI,YAAY;CAChB,OAAO,oBAAoB;CAC3B,QAAQ,oBAAoB;AAC9B,GACA,wBACF;;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,oBACd,KACA,SACmD;CACnD,OAAO,KAA0C;EAC/C,MAAM,SAAS,QAAQ;EACvB,aACE;EAGF,SAAS,UACP,qBAAqB,OAAO,MAAM,OAAO,WAAW,MAAM,KAAK;EACjE,OAAO;EACP,UAAU,OAAO,QACf,IAAI,YAAY,MAAM,IAAI;GACxB,GAAI,MAAM,UAAU,SAAY,EAAE,OAAO,MAAM,MAAM,IAAI,CAAC;GAC1D,GAAI,MAAM,WAAW,SAAY,EAAE,QAAQ,MAAM,OAAO,IAAI,CAAC;GAC7D,GAAI,KAAK,SAAS,EAAE,QAAQ,IAAI,OAAO,IAAI,CAAC;EAC9C,CAAC;CACL,CAAC;AACH"}

package/esm/tools/todo.d.mts

@@ -0,0 +1,43 @@
+import { TodoListResult, TodoWriteInput } from "../contracts/tool-io.type.mjs";
+import { TodoStore } from "../todos.mjs";
+import { ToolContract } from "@warlock.js/ai";
+
+//#region ../../packages/ai-workspace/src/tools/todo.d.ts
+/**
+ * Build the agent-facing `todo_write` tool over a workspace's todo list:
+ * the model sends the **complete** updated list (each item `content` +
+ * `status` of `pending` / `in_progress` / `completed`, optional `id`) and it
+ * replaces the old one. The list lives in memory, per workspace (shared by
+ * its `readonly()` / `scope()` projections), for the length of the run.
+ *
+ * @param store - The workspace's todo list.
+ * @param options - Optional overrides; `name` renames the LLM-visible tool.
+ *
+ * @example
+ * await makeTodoWriteTool(store).invoke({
+ *   todos: [
+ *     { content: "Reproduce the failing test", status: "completed" },
+ *     { content: "Fix the rounding bug", status: "in_progress" },
+ *   ],
+ * });
+ */
+declare function makeTodoWriteTool(store: TodoStore, options?: {
+  name?: string;
+}): ToolContract<TodoWriteInput, TodoListResult>;
+/**
+ * Build the agent-facing `todo_read` tool: the workspace's current todo
+ * list and a count per status.
+ *
+ * @param store - The workspace's todo list.
+ * @param options - Optional overrides; `name` renames the LLM-visible tool.
+ *
+ * @example
+ * const { data } = await makeTodoReadTool(store).invoke({});
+ * console.log(data?.counts.pending);
+ */
+declare function makeTodoReadTool(store: TodoStore, options?: {
+  name?: string;
+}): ToolContract<Record<string, never>, TodoListResult>;
+//#endregion
+export { makeTodoReadTool, makeTodoWriteTool };
+//# sourceMappingURL=todo.d.mts.map

package/esm/tools/todo.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"todo.d.mts","names":[],"sources":["../../../../../../../../packages/ai-workspace/src/tools/todo.ts"],"mappings":";;;;;;;;AA8HA;;;;;;;;;;;;;;;iBAAgB,iBAAA,CACd,KAAA,EAAO,SAAA,EACP,OAAA;EAAY,IAAA;AAAA,IACX,YAAA,CAAa,cAAA,EAAgB,cAAA;AAwBhC;;;;;;;;;;;AAAA,iBAAgB,gBAAA,CACd,KAAA,EAAO,SAAA,EACP,OAAA;EAAY,IAAA;AAAA,IACX,YAAA,CAAa,MAAA,iBAAuB,cAAA"}

package/esm/tools/todo.mjs

@@ -0,0 +1,126 @@
+import { withJsonSchema } from "./schema.mjs";
+import { TODO_READ_JSON_SCHEMA, TODO_WRITE_JSON_SCHEMA } from "./json-schemas.mjs";
+import { TODO_STATUSES, todoListProblems } from "../todos.mjs";
+import { tool } from "@warlock.js/ai";
+
+//#region ../../packages/ai-workspace/src/tools/todo.ts
+/** Whether `value` is a todo status. */
+function isTodoStatus(value) {
+	return typeof value === "string" && TODO_STATUSES.includes(value);
+}
+/** Input schema for the `todo_write` tool. */
+const todoWriteSchema = withJsonSchema({ "~standard": {
+	version: 1,
+	vendor: "ai-workspace",
+	validate(value) {
+		if (typeof value !== "object" || value === null || Array.isArray(value)) return { issues: [{ message: "input must be an object" }] };
+		const raw = value.todos;
+		if (!Array.isArray(raw) || raw.length > 100) return { issues: [{
+			message: `"todos" must be an array of at most ${100} items`,
+			path: ["todos"]
+		}] };
+		const issues = [];
+		const todos = [];
+		raw.forEach((item, index) => {
+			if (typeof item !== "object" || item === null || Array.isArray(item)) {
+				issues.push({
+					message: `todos[${index}] must be an object`,
+					path: ["todos", index]
+				});
+				return;
+			}
+			const candidate = item;
+			if (typeof candidate.content !== "string") issues.push({
+				message: `todos[${index}].content must be a string`,
+				path: [
+					"todos",
+					index,
+					"content"
+				]
+			});
+			if (!isTodoStatus(candidate.status)) issues.push({
+				message: `todos[${index}].status must be one of ${TODO_STATUSES.join(", ")}`,
+				path: [
+					"todos",
+					index,
+					"status"
+				]
+			});
+			if (candidate.id !== void 0 && typeof candidate.id !== "string") issues.push({
+				message: `todos[${index}].id must be a string when provided`,
+				path: [
+					"todos",
+					index,
+					"id"
+				]
+			});
+			if (typeof candidate.content === "string" && isTodoStatus(candidate.status)) todos.push({
+				content: candidate.content,
+				status: candidate.status,
+				...typeof candidate.id === "string" ? { id: candidate.id } : {}
+			});
+		});
+		if (issues.length === 0) for (const problem of todoListProblems(todos)) issues.push({
+			message: problem,
+			path: ["todos"]
+		});
+		return issues.length > 0 ? { issues } : { value: { todos } };
+	}
+} }, TODO_WRITE_JSON_SCHEMA);
+/** Input schema for the `todo_read` tool (no arguments). */
+const todoReadSchema = withJsonSchema({ "~standard": {
+	version: 1,
+	vendor: "ai-workspace",
+	validate: () => ({ value: {} })
+} }, TODO_READ_JSON_SCHEMA);
+/**
+* Build the agent-facing `todo_write` tool over a workspace's todo list:
+* the model sends the **complete** updated list (each item `content` +
+* `status` of `pending` / `in_progress` / `completed`, optional `id`) and it
+* replaces the old one. The list lives in memory, per workspace (shared by
+* its `readonly()` / `scope()` projections), for the length of the run.
+*
+* @param store - The workspace's todo list.
+* @param options - Optional overrides; `name` renames the LLM-visible tool.
+*
+* @example
+* await makeTodoWriteTool(store).invoke({
+*   todos: [
+*     { content: "Reproduce the failing test", status: "completed" },
+*     { content: "Fix the rounding bug", status: "in_progress" },
+*   ],
+* });
+*/
+function makeTodoWriteTool(store, options) {
+	return tool({
+		name: options?.name ?? "todo_write",
+		description: "Replace your todo list for this task with the complete updated list (each item: content and status pending | in_progress | completed). Use it to plan multi-step work and to mark progress.",
+		action: "Updating the todo list",
+		input: todoWriteSchema,
+		execute: async (input) => store.write(input.todos)
+	});
+}
+/**
+* Build the agent-facing `todo_read` tool: the workspace's current todo
+* list and a count per status.
+*
+* @param store - The workspace's todo list.
+* @param options - Optional overrides; `name` renames the LLM-visible tool.
+*
+* @example
+* const { data } = await makeTodoReadTool(store).invoke({});
+* console.log(data?.counts.pending);
+*/
+function makeTodoReadTool(store, options) {
+	return tool({
+		name: options?.name ?? "todo_read",
+		description: "Read your current todo list for this task.",
+		action: "Reading the todo list",
+		input: todoReadSchema,
+		execute: async () => store.read()
+	});
+}
+
+//#endregion
+export { makeTodoReadTool, makeTodoWriteTool };
+//# sourceMappingURL=todo.mjs.map

package/esm/tools/todo.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"todo.mjs","names":[],"sources":["../../../../../../../../packages/ai-workspace/src/tools/todo.ts"],"sourcesContent":["import type { StandardSchemaV1 } from \"@standard-schema/spec\";\nimport { tool, type ToolContract } from \"@warlock.js/ai\";\nimport { MAX_TODOS, TODO_STATUSES, type TodoStore, todoListProblems } from \"../todos\";\nimport type {\n  TodoListResult,\n  TodoWriteInput,\n  WorkspaceTodoInput,\n  WorkspaceTodoStatus,\n} from \"../contracts\";\nimport { TODO_READ_JSON_SCHEMA, TODO_WRITE_JSON_SCHEMA } from \"./json-schemas\";\nimport { withJsonSchema } from \"./schema\";\n\n/** Whether `value` is a todo status. */\nfunction isTodoStatus(value: unknown): value is WorkspaceTodoStatus {\n  return typeof value === \"string\" && (TODO_STATUSES as readonly string[]).includes(value);\n}\n\n/** Input schema for the `todo_write` tool. */\nconst todoWriteSchema = withJsonSchema<TodoWriteInput>(\n  {\n    \"~standard\": {\n      version: 1,\n      vendor: \"ai-workspace\",\n      validate(value) {\n        if (typeof value !== \"object\" || value === null || Array.isArray(value)) {\n          return { issues: [{ message: \"input must be an object\" }] };\n        }\n\n        const raw = (value as Record<string, unknown>).todos;\n\n        if (!Array.isArray(raw) || raw.length > MAX_TODOS) {\n          return {\n            issues: [\n              {\n                message: `\"todos\" must be an array of at most ${MAX_TODOS} items`,\n                path: [\"todos\"],\n              },\n            ],\n          };\n        }\n\n        const issues: StandardSchemaV1.Issue[] = [];\n        const todos: WorkspaceTodoInput[] = [];\n\n        raw.forEach((item: unknown, index: number) => {\n          if (typeof item !== \"object\" || item === null || Array.isArray(item)) {\n            issues.push({ message: `todos[${index}] must be an object`, path: [\"todos\", index] });\n\n            return;\n          }\n\n          const candidate = item as Record<string, unknown>;\n\n          if (typeof candidate.content !== \"string\") {\n            issues.push({\n              message: `todos[${index}].content must be a string`,\n              path: [\"todos\", index, \"content\"],\n            });\n          }\n\n          if (!isTodoStatus(candidate.status)) {\n            issues.push({\n              message: `todos[${index}].status must be one of ${TODO_STATUSES.join(\", \")}`,\n              path: [\"todos\", index, \"status\"],\n            });\n          }\n\n          if (candidate.id !== undefined && typeof candidate.id !== \"string\") {\n            issues.push({\n              message: `todos[${index}].id must be a string when provided`,\n              path: [\"todos\", index, \"id\"],\n            });\n          }\n\n          if (typeof candidate.content === \"string\" && isTodoStatus(candidate.status)) {\n            todos.push({\n              content: candidate.content,\n              status: candidate.status,\n              ...(typeof candidate.id === \"string\" ? { id: candidate.id } : {}),\n            });\n          }\n        });\n\n        if (issues.length === 0) {\n          for (const problem of todoListProblems(todos)) {\n            issues.push({ message: problem, path: [\"todos\"] });\n          }\n        }\n\n        return issues.length > 0 ? { issues } : { value: { todos } };\n      },\n    },\n  },\n  TODO_WRITE_JSON_SCHEMA,\n);\n\n/** Input schema for the `todo_read` tool (no arguments). */\nconst todoReadSchema = withJsonSchema<Record<string, never>>(\n  {\n    \"~standard\": {\n      version: 1,\n      vendor: \"ai-workspace\",\n      validate: () => ({ value: {} }),\n    },\n  },\n  TODO_READ_JSON_SCHEMA,\n);\n\n/**\n * Build the agent-facing `todo_write` tool over a workspace's todo list:\n * the model sends the **complete** updated list (each item `content` +\n * `status` of `pending` / `in_progress` / `completed`, optional `id`) and it\n * replaces the old one. The list lives in memory, per workspace (shared by\n * its `readonly()` / `scope()` projections), for the length of the run.\n *\n * @param store - The workspace's todo list.\n * @param options - Optional overrides; `name` renames the LLM-visible tool.\n *\n * @example\n * await makeTodoWriteTool(store).invoke({\n *   todos: [\n *     { content: \"Reproduce the failing test\", status: \"completed\" },\n *     { content: \"Fix the rounding bug\", status: \"in_progress\" },\n *   ],\n * });\n */\nexport function makeTodoWriteTool(\n  store: TodoStore,\n  options?: { name?: string },\n): ToolContract<TodoWriteInput, TodoListResult> {\n  return tool<TodoWriteInput, TodoListResult>({\n    name: options?.name ?? \"todo_write\",\n    description:\n      \"Replace your todo list for this task with the complete updated list \" +\n      \"(each item: content and status pending | in_progress | completed). \" +\n      \"Use it to plan multi-step work and to mark progress.\",\n    action: \"Updating the todo list\",\n    input: todoWriteSchema,\n    execute: async (input) => store.write(input.todos),\n  });\n}\n\n/**\n * Build the agent-facing `todo_read` tool: the workspace's current todo\n * list and a count per status.\n *\n * @param store - The workspace's todo list.\n * @param options - Optional overrides; `name` renames the LLM-visible tool.\n *\n * @example\n * const { data } = await makeTodoReadTool(store).invoke({});\n * console.log(data?.counts.pending);\n */\nexport function makeTodoReadTool(\n  store: TodoStore,\n  options?: { name?: string },\n): ToolContract<Record<string, never>, TodoListResult> {\n  return tool<Record<string, never>, TodoListResult>({\n    name: options?.name ?? \"todo_read\",\n    description: \"Read your current todo list for this task.\",\n    action: \"Reading the todo list\",\n    input: todoReadSchema,\n    execute: async () => store.read(),\n  });\n}\n"],"mappings":";;;;;;;AAaA,SAAS,aAAa,OAA8C;CAClE,OAAO,OAAO,UAAU,YAAa,cAAoC,SAAS,KAAK;AACzF;;AAGA,MAAM,kBAAkB,eACtB,EACE,aAAa;CACX,SAAS;CACT,QAAQ;CACR,SAAS,OAAO;EACd,IAAI,OAAO,UAAU,YAAY,UAAU,QAAQ,MAAM,QAAQ,KAAK,GACpE,OAAO,EAAE,QAAQ,CAAC,EAAE,SAAS,0BAA0B,CAAC,EAAE;EAG5D,MAAM,MAAO,MAAkC;EAE/C,IAAI,CAAC,MAAM,QAAQ,GAAG,KAAK,IAAI,cAC7B,OAAO,EACL,QAAQ,CACN;GACE,SAAS,2CAAiD;GAC1D,MAAM,CAAC,OAAO;EAChB,CACF,EACF;EAGF,MAAM,SAAmC,CAAC;EAC1C,MAAM,QAA8B,CAAC;EAErC,IAAI,SAAS,MAAe,UAAkB;GAC5C,IAAI,OAAO,SAAS,YAAY,SAAS,QAAQ,MAAM,QAAQ,IAAI,GAAG;IACpE,OAAO,KAAK;KAAE,SAAS,SAAS,MAAM;KAAsB,MAAM,CAAC,SAAS,KAAK;IAAE,CAAC;IAEpF;GACF;GAEA,MAAM,YAAY;GAElB,IAAI,OAAO,UAAU,YAAY,UAC/B,OAAO,KAAK;IACV,SAAS,SAAS,MAAM;IACxB,MAAM;KAAC;KAAS;KAAO;IAAS;GAClC,CAAC;GAGH,IAAI,CAAC,aAAa,UAAU,MAAM,GAChC,OAAO,KAAK;IACV,SAAS,SAAS,MAAM,0BAA0B,cAAc,KAAK,IAAI;IACzE,MAAM;KAAC;KAAS;KAAO;IAAQ;GACjC,CAAC;GAGH,IAAI,UAAU,OAAO,UAAa,OAAO,UAAU,OAAO,UACxD,OAAO,KAAK;IACV,SAAS,SAAS,MAAM;IACxB,MAAM;KAAC;KAAS;KAAO;IAAI;GAC7B,CAAC;GAGH,IAAI,OAAO,UAAU,YAAY,YAAY,aAAa,UAAU,MAAM,GACxE,MAAM,KAAK;IACT,SAAS,UAAU;IACnB,QAAQ,UAAU;IAClB,GAAI,OAAO,UAAU,OAAO,WAAW,EAAE,IAAI,UAAU,GAAG,IAAI,CAAC;GACjE,CAAC;EAEL,CAAC;EAED,IAAI,OAAO,WAAW,GACpB,KAAK,MAAM,WAAW,iBAAiB,KAAK,GAC1C,OAAO,KAAK;GAAE,SAAS;GAAS,MAAM,CAAC,OAAO;EAAE,CAAC;EAIrD,OAAO,OAAO,SAAS,IAAI,EAAE,OAAO,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE;CAC7D;AACF,EACF,GACA,sBACF;;AAGA,MAAM,iBAAiB,eACrB,EACE,aAAa;CACX,SAAS;CACT,QAAQ;CACR,iBAAiB,EAAE,OAAO,CAAC,EAAE;AAC/B,EACF,GACA,qBACF;;;;;;;;;;;;;;;;;;;AAoBA,SAAgB,kBACd,OACA,SAC8C;CAC9C,OAAO,KAAqC;EAC1C,MAAM,SAAS,QAAQ;EACvB,aACE;EAGF,QAAQ;EACR,OAAO;EACP,SAAS,OAAO,UAAU,MAAM,MAAM,MAAM,KAAK;CACnD,CAAC;AACH;;;;;;;;;;;;AAaA,SAAgB,iBACd,OACA,SACqD;CACrD,OAAO,KAA4C;EACjD,MAAM,SAAS,QAAQ;EACvB,aAAa;EACb,QAAQ;EACR,OAAO;EACP,SAAS,YAAY,MAAM,KAAK;CAClC,CAAC;AACH"}

package/esm/tools/write-file.d.mts

@@ -2,7 +2,7 @@ import { WriteFileInput, WriteFileResult } from "../contracts/tool-io.type.mjs";
 import { WorkspaceOps } from "../contracts/workspace-ops.contract.mjs";
 import { ToolContract } from "@warlock.js/ai";
 
-//#region ../ai-workspace/src/tools/write-file.d.ts
+//#region ../../packages/ai-workspace/src/tools/write-file.d.ts
 /**
  * Build the agent-facing `write_file` tool over a workspace's policy-
  * enforced {@link WorkspaceOps}.

package/esm/tools/write-file.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"write-file.d.mts","names":[],"sources":["../../../../../../../ai-workspace/src/tools/write-file.ts"],"mappings":";;;;;;;;;AAmCA;;;;;;;;;;;;;;;;;AAG+C;iBAH/B,iBAAA,CACd,GAAA,EAAK,YAAA,EACL,OAAA;EAAY,IAAA;AAAA,IACX,YAAA,CAAa,cAAA,EAAgB,eAAA"}
+{"version":3,"file":"write-file.d.mts","names":[],"sources":["../../../../../../../../packages/ai-workspace/src/tools/write-file.ts"],"mappings":";;;;;;;;;AAuCA;;;;;;;;;;;;;;;;;AAG+C;iBAH/B,iBAAA,CACd,GAAA,EAAK,YAAA,EACL,OAAA;EAAY,IAAA;AAAA,IACX,YAAA,CAAa,cAAA,EAAgB,eAAA"}

package/esm/tools/write-file.mjs

@@ -1,14 +1,15 @@
 import { objectSchema, stringField } from "./schema.mjs";
+import { WRITE_FILE_JSON_SCHEMA } from "./json-schemas.mjs";
 import { tool } from "@warlock.js/ai";
 
-//#region ../ai-workspace/src/tools/write-file.ts
+//#region ../../packages/ai-workspace/src/tools/write-file.ts
 /** Default tool name exposed to the LLM. */
 const DEFAULT_NAME = "write_file";
 /** Input schema for the `write_file` tool. */
 const inputSchema = objectSchema({
 	path: stringField(),
 	content: stringField()
-});
+}, WRITE_FILE_JSON_SCHEMA);
 /**
 * Build the agent-facing `write_file` tool over a workspace's policy-
 * enforced {@link WorkspaceOps}.

package/esm/tools/write-file.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"write-file.mjs","names":[],"sources":["../../../../../../../ai-workspace/src/tools/write-file.ts"],"sourcesContent":["import { tool, type ToolContract } from \"@warlock.js/ai\";\nimport { objectSchema, stringField } from \"./schema\";\nimport type { WorkspaceOps, WriteFileInput, WriteFileResult } from \"../contracts\";\n\n/** Default tool name exposed to the LLM. */\nconst DEFAULT_NAME = \"write_file\";\n\n/** Input schema for the `write_file` tool. */\nconst inputSchema = objectSchema<WriteFileInput>({\n  path: stringField(),\n  content: stringField(),\n});\n\n/**\n * Build the agent-facing `write_file` tool over a workspace's policy-\n * enforced {@link WorkspaceOps}.\n *\n * The tool validates `{ path, content }` against a Standard Schema, then\n * delegates to `ops.writeFile`, which atomically writes the full content\n * (creating parent directories) and returns the byte count and content\n * `hash`. The tool re-attaches the workspace-relative `path` so the\n * result matches the {@link WriteFileResult} wire shape.\n *\n * **Errors flow as data.** A jail escape is thrown by `ops`; the\n * `tool()` wrapper catches it and surfaces it in the returned `{ error }`\n * field — `invoke()` never throws.\n *\n * @param ops - The shared, policy-enforced operation layer.\n * @param options - Optional overrides; `name` renames the LLM-visible tool.\n *\n * @example\n * const writeTool = makeWriteFileTool(ops);\n * const { data } = await writeTool.invoke({ path: \"src/new.ts\", content: \"export {};\" });\n * console.log(data.bytesWritten, data.hash);\n */\nexport function makeWriteFileTool(\n  ops: WorkspaceOps,\n  options?: { name?: string },\n): ToolContract<WriteFileInput, WriteFileResult> {\n  return tool<WriteFileInput, WriteFileResult>({\n    name: options?.name ?? DEFAULT_NAME,\n    description:\n      \"Write full content to a workspace file, creating it (and any parent \" +\n      \"directories) if absent and overwriting it otherwise. The write is \" +\n      \"atomic. Returns the bytes written and the new content hash.\",\n    input: inputSchema,\n    async execute(input) {\n      const { hash, bytesWritten } = await ops.writeFile(input.path, input.content);\n\n      return { path: input.path, bytesWritten, hash };\n    },\n  });\n}\n"],"mappings":";;;;;AAKA,MAAM,eAAe;;AAGrB,MAAM,cAAc,aAA6B;CAC/C,MAAM,YAAY;CAClB,SAAS,YAAY;AACvB,CAAC;;;;;;;;;;;;;;;;;;;;;;;AAwBD,SAAgB,kBACd,KACA,SAC+C;CAC/C,OAAO,KAAsC;EAC3C,MAAM,SAAS,QAAQ;EACvB,aACE;EAGF,OAAO;EACP,MAAM,QAAQ,OAAO;GACnB,MAAM,EAAE,MAAM,iBAAiB,MAAM,IAAI,UAAU,MAAM,MAAM,MAAM,OAAO;GAE5E,OAAO;IAAE,MAAM,MAAM;IAAM;IAAc;GAAK;EAChD;CACF,CAAC;AACH"}
+{"version":3,"file":"write-file.mjs","names":[],"sources":["../../../../../../../../packages/ai-workspace/src/tools/write-file.ts"],"sourcesContent":["import { tool, type ToolContract } from \"@warlock.js/ai\";\nimport { objectSchema, stringField } from \"./schema\";\nimport { WRITE_FILE_JSON_SCHEMA } from \"./json-schemas\";\nimport type { WorkspaceOps, WriteFileInput, WriteFileResult } from \"../contracts\";\n\n/** Default tool name exposed to the LLM. */\nconst DEFAULT_NAME = \"write_file\";\n\n/** Input schema for the `write_file` tool. */\nconst inputSchema = objectSchema<WriteFileInput>(\n  {\n    path: stringField(),\n    content: stringField(),\n  },\n  WRITE_FILE_JSON_SCHEMA,\n);\n\n/**\n * Build the agent-facing `write_file` tool over a workspace's policy-\n * enforced {@link WorkspaceOps}.\n *\n * The tool validates `{ path, content }` against a Standard Schema, then\n * delegates to `ops.writeFile`, which atomically writes the full content\n * (creating parent directories) and returns the byte count and content\n * `hash`. The tool re-attaches the workspace-relative `path` so the\n * result matches the {@link WriteFileResult} wire shape.\n *\n * **Errors flow as data.** A jail escape is thrown by `ops`; the\n * `tool()` wrapper catches it and surfaces it in the returned `{ error }`\n * field — `invoke()` never throws.\n *\n * @param ops - The shared, policy-enforced operation layer.\n * @param options - Optional overrides; `name` renames the LLM-visible tool.\n *\n * @example\n * const writeTool = makeWriteFileTool(ops);\n * const { data } = await writeTool.invoke({ path: \"src/new.ts\", content: \"export {};\" });\n * console.log(data.bytesWritten, data.hash);\n */\nexport function makeWriteFileTool(\n  ops: WorkspaceOps,\n  options?: { name?: string },\n): ToolContract<WriteFileInput, WriteFileResult> {\n  return tool<WriteFileInput, WriteFileResult>({\n    name: options?.name ?? DEFAULT_NAME,\n    description:\n      \"Write full content to a workspace file, creating it (and any parent \" +\n      \"directories) if absent and overwriting it otherwise. The write is \" +\n      \"atomic. Returns the bytes written and the new content hash.\",\n    input: inputSchema,\n    async execute(input) {\n      const { hash, bytesWritten } = await ops.writeFile(input.path, input.content);\n\n      return { path: input.path, bytesWritten, hash };\n    },\n  });\n}\n"],"mappings":";;;;;;AAMA,MAAM,eAAe;;AAGrB,MAAM,cAAc,aAClB;CACE,MAAM,YAAY;CAClB,SAAS,YAAY;AACvB,GACA,sBACF;;;;;;;;;;;;;;;;;;;;;;;AAwBA,SAAgB,kBACd,KACA,SAC+C;CAC/C,OAAO,KAAsC;EAC3C,MAAM,SAAS,QAAQ;EACvB,aACE;EAGF,OAAO;EACP,MAAM,QAAQ,OAAO;GACnB,MAAM,EAAE,MAAM,iBAAiB,MAAM,IAAI,UAAU,MAAM,MAAM,MAAM,OAAO;GAE5E,OAAO;IAAE,MAAM,MAAM;IAAM;IAAc;GAAK;EAChD;CACF,CAAC;AACH"}

package/esm/workspace.d.mts

@@ -1,23 +1,26 @@
 import { WorkspacePolicy } from "./contracts/workspace-policy.type.mjs";
 import { Workspace } from "./contracts/workspace.contract.mjs";
-//#region ../ai-workspace/src/workspace.d.ts
+//#region ../../packages/ai-workspace/src/workspace.d.ts
 /**
  * Build a {@link Workspace} — the integrator that wires a
  * {@link WorkspacePolicy} to a backend, the shared policy-enforced ops
- * layer, and the seven agent-facing tool factories.
+ * layer, and the agent-facing tool factories.
  *
  * The backend is chosen from `policy.backend`: `"mock"` runs in memory
  * (hermetic tests); the `"local"` default (and any absent value) runs
  * over the real disk via `@warlock.js/fs` + `node:child_process`. The
  * returned workspace exposes:
  *
- * - **`tools.*`** — `readFile` / `editFile` / `writeFile` / `runShell` /
- *   `runTests` / `grep` / `glob`, plus `all()` (every tool) and
- *   `pick(...)` (a least-privilege subset).
- * - **direct methods** — `readFile` / `writeFile` / `editFile` / `exec` /
- *   `grep` / `glob` / `exists` / `mkdir` / `remove`, each delegating 1:1
- *   to the shared ops layer.
- * - **`readonly()`** — a projection that vends only read/grep/glob and
+ * - **`tools.*`** — `readFile` / `editFile` / `multiEdit` / `writeFile` /
+ *   `listDir` / `runShell` / `shellOutput` / `shellKill` / `runTests` /
+ *   `grep` / `glob` / `todoWrite` / `todoRead`, plus `all()` (every tool)
+ *   and `pick(...)` (a least-privilege subset).
+ * - **direct methods** — `readFile` / `writeFile` / `editFile` /
+ *   `multiEdit` / `listDir` / `exec` / `startShell` / `shellOutput` /
+ *   `shellKill` / `listShells` / `grep` / `glob` / `exists` / `mkdir` /
+ *   `remove` / `readTodos` / `writeTodos`, each delegating to the shared
+ *   ops layer, and `dispose()`.
+ * - **`readonly()`** — a projection that vends only the read-side tools and
  *   rejects every mutating direct method.
  * - **`scope(subdir)`** — a sub-jailed workspace rooted at `subdir`.
  *

package/esm/workspace.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"workspace.d.mts","names":[],"sources":["../../../../../../ai-workspace/src/workspace.ts"],"mappings":";;;;;;;AA6RA;;;;;;;;AAA6D;AAE5D;;;;;;;;;;;AAWgD;;;;;;;;;;;iBAbjC,SAAA,CAAU,MAAA,EAAQ,eAAA,GAAkB,SAAS;;;;;;;;YAWjD,EAAA;;IAER,SAAA,CAAU,MAAA,EAAQ,eAAA,GAAkB,SAAS;EAAA;AAAA"}
+{"version":3,"file":"workspace.d.mts","names":[],"sources":["../../../../../../../packages/ai-workspace/src/workspace.ts"],"mappings":";;;;;;;AAuZA;;;;;;;;AAA6D;AAE5D;;;;;;;;;;;AAWgD;;;;;;;;;;;;;;iBAbjC,SAAA,CAAU,MAAA,EAAQ,eAAA,GAAkB,SAAS;;;;;;;;YAWjD,EAAA;;IAER,SAAA,CAAU,MAAA,EAAQ,eAAA,GAAkB,SAAS;EAAA;AAAA"}

package/esm/workspace.mjs

@@ -1,18 +1,25 @@
 import { WorkspacePolicyError } from "./errors.mjs";
+import { ShellJobs } from "./shell-jobs.mjs";
 import { createOps } from "./ops.mjs";
 import { createLocalBackend } from "./backends/local.mjs";
 import { createMockBackend } from "./backends/mock.mjs";
 import { makeEditFileTool } from "./tools/edit-file.mjs";
 import { makeGlobTool } from "./tools/glob.mjs";
 import { makeGrepTool } from "./tools/grep.mjs";
+import { makeListDirTool } from "./tools/list-dir.mjs";
+import { makeMultiEditTool } from "./tools/multi-edit.mjs";
 import { makeReadFileTool } from "./tools/read-file.mjs";
 import { makeRunShellTool } from "./tools/run-shell.mjs";
 import { makeRunTestsTool } from "./tools/run-tests.mjs";
+import { makeShellKillTool } from "./tools/shell-kill.mjs";
+import { makeShellOutputTool } from "./tools/shell-output.mjs";
+import { TodoStore } from "./todos.mjs";
+import { makeTodoReadTool, makeTodoWriteTool } from "./tools/todo.mjs";
 import { makeWriteFileTool } from "./tools/write-file.mjs";
 import { ai } from "@warlock.js/ai";
 import path from "node:path";
 
-//#region ../ai-workspace/src/workspace.ts
+//#region ../../packages/ai-workspace/src/workspace.ts
 /**
 * The full set of tool names a writable workspace vends, in a stable
 * canonical order so `tools.all()` is deterministic.
@@ -20,23 +27,35 @@ import path from "node:path";
 const ALL_TOOL_NAMES = [
 	"readFile",
 	"editFile",
+	"multiEdit",
 	"writeFile",
+	"listDir",
 	"runShell",
+	"shellOutput",
+	"shellKill",
 	"runTests",
 	"grep",
-	"glob"
+	"glob",
+	"todoWrite",
+	"todoRead"
 ];
 /**
 * The subset a {@link Workspace.readonly} projection exposes — the
-* non-mutating tools only. `editFile` / `writeFile` / `runShell` /
-* `runTests` are deliberately omitted so a reviewer agent has no path to
-* change the tree.
+* tools that cannot change the tree. `editFile` / `multiEdit` /
+* `writeFile` / the shell tools / `runTests` are deliberately omitted so a
+* reviewer agent has no path to change it. The todo tools stay: they only
+* touch the in-memory plan.
 */
 const READONLY_TOOL_NAMES = [
 	"readFile",
+	"listDir",
 	"grep",
-	"glob"
+	"glob",
+	"todoWrite",
+	"todoRead"
 ];
+/** Tools vended only when the policy enables background commands. */
+const BACKGROUND_TOOL_NAMES = new Set(["shellOutput", "shellKill"]);
 /**
 * Choose the dumb IO executor for a policy. `"mock"` selects the
 * in-memory backend (hermetic tests); anything else — including the
@@ -61,11 +80,15 @@ function selectBackend(policy) {
 * Constructed via {@link workspace}; the class itself is internal.
 */
 var WorkspaceImpl = class WorkspaceImpl {
-	constructor(policy, allowedTools = ALL_TOOL_NAMES) {
+	constructor(policy, allowedTools = ALL_TOOL_NAMES, state) {
 		this.policy = policy;
 		this.allowedTools = new Set(allowedTools);
+		this.state = state ?? {
+			jobs: new ShellJobs(),
+			todos: new TodoStore()
+		};
 		const backend = selectBackend(policy);
-		this.ops = createOps(backend, policy);
+		this.ops = createOps(backend, policy, { jobs: this.state.jobs });
 		this.tools = this.buildTools();
 	}
 	/**
@@ -77,26 +100,49 @@ var WorkspaceImpl = class WorkspaceImpl {
 	*/
 	buildTools() {
 		const erase = (contract) => contract;
+		const shell = this.policy.shell;
+		const background = shell?.background !== void 0;
+		const interpreter = shell?.interpreter ?? "none";
 		const factories = {
 			readFile: (opts) => erase(makeReadFileTool(this.ops, opts)),
 			editFile: (opts) => erase(makeEditFileTool(this.ops, opts)),
+			multiEdit: (opts) => erase(makeMultiEditTool(this.ops, opts)),
 			writeFile: (opts) => erase(makeWriteFileTool(this.ops, opts)),
-			runShell: (opts) => erase(makeRunShellTool(this.ops, opts)),
-			runTests: (opts) => erase(makeRunTestsTool(this.ops, opts)),
+			listDir: (opts) => erase(makeListDirTool(this.ops, opts)),
+			runShell: (opts) => erase(makeRunShellTool(this.ops, {
+				...opts?.name !== void 0 ? { name: opts.name } : {},
+				...shell?.timeoutMs !== void 0 ? { maxTimeoutMs: shell.timeoutMs } : {},
+				background
+			})),
+			shellOutput: (opts) => erase(makeShellOutputTool(this.ops, opts)),
+			shellKill: (opts) => erase(makeShellKillTool(this.ops, opts)),
+			runTests: (opts) => erase(makeRunTestsTool(this.ops, {
+				...opts,
+				interpreter
+			})),
 			grep: (opts) => erase(makeGrepTool(this.ops, opts)),
-			glob: (opts) => erase(makeGlobTool(this.ops, opts))
+			glob: (opts) => erase(makeGlobTool(this.ops, opts)),
+			todoWrite: (opts) => erase(makeTodoWriteTool(this.state.todos, opts)),
+			todoRead: (opts) => erase(makeTodoReadTool(this.state.todos, opts))
 		};
 		const build = (name, opts) => factories[name](opts);
+		const vendedByAll = (name) => this.allowedTools.has(name) && (background || !BACKGROUND_TOOL_NAMES.has(name));
 		return {
-			all: () => ALL_TOOL_NAMES.filter((name) => this.allowedTools.has(name)).map((name) => build(name)),
+			all: () => ALL_TOOL_NAMES.filter(vendedByAll).map((name) => build(name)),
 			pick: (...names) => names.filter((name) => this.allowedTools.has(name)).map((name) => build(name)),
 			readFile: (opts) => build("readFile", opts),
 			editFile: (opts) => build("editFile", opts),
+			multiEdit: (opts) => build("multiEdit", opts),
 			writeFile: (opts) => build("writeFile", opts),
+			listDir: (opts) => build("listDir", opts),
 			runShell: (opts) => build("runShell", opts),
+			shellOutput: (opts) => build("shellOutput", opts),
+			shellKill: (opts) => build("shellKill", opts),
 			runTests: (opts) => build("runTests", opts),
 			grep: (opts) => build("grep", opts),
-			glob: (opts) => build("glob", opts)
+			glob: (opts) => build("glob", opts),
+			todoWrite: (opts) => build("todoWrite", opts),
+			todoRead: (opts) => build("todoRead", opts)
 		};
 	}
 	/**
@@ -122,10 +168,40 @@ var WorkspaceImpl = class WorkspaceImpl {
 		this.assertWritable("editFile");
 		return this.ops.editFile(input);
 	}
+	async multiEdit(input) {
+		this.assertWritable("multiEdit");
+		return this.ops.multiEdit(input);
+	}
+	listDir(dirPath, opts) {
+		return this.ops.listDir(dirPath, opts);
+	}
 	async exec(command, opts) {
 		this.assertWritable("exec");
 		return this.ops.exec(command, opts);
 	}
+	async startShell(command, opts) {
+		this.assertWritable("startShell");
+		return this.ops.startShell(command, opts);
+	}
+	shellOutput(id, opts) {
+		return this.ops.shellOutput(id, opts);
+	}
+	async shellKill(id) {
+		this.assertWritable("shellKill");
+		return this.ops.shellKill(id);
+	}
+	listShells() {
+		return this.ops.listShells();
+	}
+	readTodos() {
+		return this.state.todos.read();
+	}
+	writeTodos(todos) {
+		return this.state.todos.write(todos);
+	}
+	dispose() {
+		return this.ops.dispose();
+	}
 	grep(pattern, opts) {
 		return this.ops.grep(pattern, opts);
 	}
@@ -144,44 +220,49 @@ var WorkspaceImpl = class WorkspaceImpl {
 		return this.ops.remove(filePath);
 	}
 	/**
-	* A read-only projection over the SAME policy — only the read/grep/glob
-	* tools are vended and every mutating direct method rejects with a
-	* {@link WorkspacePolicyError}. A fresh ops/backend is built from the
-	* identical policy, so the projection sees the same jailed tree.
+	* A read-only projection over the SAME policy — only the read / list /
+	* grep / glob / todo tools are vended and every mutating direct method
+	* rejects with a {@link WorkspacePolicyError}. A fresh ops/backend is
+	* built from the identical policy, so the projection sees the same jailed
+	* tree; it shares this workspace's background commands and todo list.
 	*/
 	readonly() {
-		return new WorkspaceImpl(this.policy, READONLY_TOOL_NAMES);
+		return new WorkspaceImpl(this.policy, READONLY_TOOL_NAMES.filter((name) => this.allowedTools.has(name)), this.state);
 	}
 	/**
 	* A sub-jailed view rooted at `subdir` (relative to this workspace's
 	* `cwd`). Returns a brand-new workspace whose policy is this policy
 	* with `cwd` narrowed to `join(cwd, subdir)` — same backend selection,
-	* same allow/deny/shell/read sub-policies, but a tighter jail root.
+	* same allow/deny/shell/read sub-policies, but a tighter jail root. It
+	* shares this workspace's background commands and todo list.
 	*/
 	scope(subdir) {
 		return new WorkspaceImpl({
 			...this.policy,
 			cwd: path.join(this.policy.cwd, subdir)
-		}, [...this.allowedTools]);
+		}, [...this.allowedTools], this.state);
 	}
 };
 /**
 * Build a {@link Workspace} — the integrator that wires a
 * {@link WorkspacePolicy} to a backend, the shared policy-enforced ops
-* layer, and the seven agent-facing tool factories.
+* layer, and the agent-facing tool factories.
 *
 * The backend is chosen from `policy.backend`: `"mock"` runs in memory
 * (hermetic tests); the `"local"` default (and any absent value) runs
 * over the real disk via `@warlock.js/fs` + `node:child_process`. The
 * returned workspace exposes:
 *
-* - **`tools.*`** — `readFile` / `editFile` / `writeFile` / `runShell` /
-*   `runTests` / `grep` / `glob`, plus `all()` (every tool) and
-*   `pick(...)` (a least-privilege subset).
-* - **direct methods** — `readFile` / `writeFile` / `editFile` / `exec` /
-*   `grep` / `glob` / `exists` / `mkdir` / `remove`, each delegating 1:1
-*   to the shared ops layer.
-* - **`readonly()`** — a projection that vends only read/grep/glob and
+* - **`tools.*`** — `readFile` / `editFile` / `multiEdit` / `writeFile` /
+*   `listDir` / `runShell` / `shellOutput` / `shellKill` / `runTests` /
+*   `grep` / `glob` / `todoWrite` / `todoRead`, plus `all()` (every tool)
+*   and `pick(...)` (a least-privilege subset).
+* - **direct methods** — `readFile` / `writeFile` / `editFile` /
+*   `multiEdit` / `listDir` / `exec` / `startShell` / `shellOutput` /
+*   `shellKill` / `listShells` / `grep` / `glob` / `exists` / `mkdir` /
+*   `remove` / `readTodos` / `writeTodos`, each delegating to the shared
+*   ops layer, and `dispose()`.
+* - **`readonly()`** — a projection that vends only the read-side tools and
 *   rejects every mutating direct method.
 * - **`scope(subdir)`** — a sub-jailed workspace rooted at `subdir`.
 *