@akira-tl/forgerelay 0.5.2 → 0.5.5

package/dist/capability-registry.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { MAX_CODE_INTELLIGENCE_RESULT_LIMIT, } from "./lsp/code-intelligence-types.js";
+import { batchExecuteInputSchema, } from "./operations/batch/types.js";
 export class CapabilityError extends Error {
     code;
     constructor(code, message) {
@@ -25,6 +26,7 @@ export class CapabilityRegistry {
                 name: definition.name,
                 description: definition.description,
                 available,
+                batchPolicy: definition.batchPolicy,
                 ...(!available && unavailableReason ? { unavailableReason } : {}),
                 guide: {
                     name: definition.guideName,
@@ -65,6 +67,9 @@ export class CapabilityRegistry {
         if (!catalogEntry.available) {
             throw new CapabilityError("capability_unavailable", `Capability ${name} is unavailable${catalogEntry.unavailableReason ? `: ${catalogEntry.unavailableReason}` : "."}`);
         }
+        if (options.batch && definition.batchPolicy === "unsupported") {
+            throw new CapabilityError("capability_batch_unsupported", `Capability ${name} is not supported inside batch.execute.`);
+        }
         if (options.nativeFile !== undefined && !definition.nativeFileArgument) {
             throw new CapabilityError("invalid_arguments", `Capability ${name} does not accept a Host-native file value.`);
         }
@@ -87,6 +92,9 @@ export class CapabilityRegistry {
             throw new CapabilityError("execution_failed", `Capability ${name} failed: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
+    batchPolicy(name) {
+        return this.definitions.get(name)?.batchPolicy;
+    }
     requireDefinition(name) {
         const definition = this.definitions.get(name);
         if (!definition) {
@@ -105,6 +113,7 @@ export class CapabilityRegistry {
             name: definition.name,
             description: definition.description,
             available,
+            batchPolicy: definition.batchPolicy,
             ...(!available && unavailableReason ? { unavailableReason } : {}),
             guide: {
                 name: definition.guideName,
@@ -152,6 +161,7 @@ export function createCapabilityRegistry(dependencies) {
             description: "Validate the active ForgeRelay Hook configuration for this workspace.",
             guideName: "lifecycle-hooks",
             readGuideBeforeFirstUse: true,
+            batchPolicy: "parallel",
             inputSchema: hooksCheckInput,
             availability: () => ({ available: true }),
             run: async (_input, context) => ({
@@ -167,6 +177,7 @@ export function createCapabilityRegistry(dependencies) {
                     description: "Review accumulated workspace changes from the Git-backed review checkpoint.",
                     guideName: "artifacts-review",
                     readGuideBeforeFirstUse: true,
+                    batchPolicy: "serial",
                     inputSchema: z.object({}).strict(),
                     availability: () => ({
                         available: dependencies.reviewChanges?.available ?? false,
@@ -181,6 +192,7 @@ export function createCapabilityRegistry(dependencies) {
                     description: "Read semantic code information through an available Language server without changing the Workspace.",
                     guideName: "code-intelligence",
                     readGuideBeforeFirstUse: true,
+                    batchPolicy: "parallel",
                     inputSchema: codeIntelligenceInput,
                     availability: () => ({
                         available: dependencies.codeIntelligence?.available ?? false,
@@ -189,12 +201,28 @@ export function createCapabilityRegistry(dependencies) {
                     run: async (input, context, options) => dependencies.codeIntelligence.run(input, context, options),
                 }]
             : []),
+        ...(dependencies.batchExecute
+            ? [{
+                    name: "batch.execute",
+                    description: "Execute multiple independent ForgeRelay core operations in one Agent interaction.",
+                    guideName: "batch-execution",
+                    readGuideBeforeFirstUse: true,
+                    batchPolicy: "unsupported",
+                    inputSchema: batchExecuteInputSchema,
+                    availability: () => ({
+                        available: dependencies.batchExecute?.available ?? false,
+                        reason: dependencies.batchExecute?.unavailableReason,
+                    }),
+                    run: async (input, context, options) => dependencies.batchExecute.run(input, context, options),
+                }]
+            : []),
         ...(dependencies.downloadArtifact
             ? [{
                     name: "artifact.download",
                     description: "Save one Host-native file into a workspace-relative destination without overwriting.",
                     guideName: "artifacts-review",
                     readGuideBeforeFirstUse: true,
+                    batchPolicy: "unsupported",
                     inputSchema: z.object({
                         file: z.strictObject({
                             download_url: z.string(),

package/dist/db/migrations.js

@@ -44,6 +44,16 @@ const migrations = [
         name: "bash-output-audit",
         up: migrateBashOutputAudit,
     },
+    {
+        version: 10,
+        name: "activity-host-turns",
+        up: migrateActivityHostTurns,
+    },
+    {
+        version: 11,
+        name: "activity-parent-child",
+        up: migrateActivityParentChild,
+    },
 ];
 export function migrateDatabase(sqlite) {
     const migrate = sqlite.transaction(() => {
@@ -296,6 +306,29 @@ function migrateBashOutputAudit(sqlite) {
       on bash_output_chunks(output_id, sequence);
   `);
 }
+function migrateActivityHostTurns(sqlite) {
+    sqlite.exec(`
+    create table if not exists activity_host_turns (
+      turn_id text primary key,
+      conversation_scope_id text,
+      created_at text not null
+    );
+
+    create index if not exists activity_host_turns_conversation_idx
+      on activity_host_turns(conversation_scope_id, created_at desc);
+
+    create index if not exists activity_host_turns_created_idx
+      on activity_host_turns(created_at desc);
+  `);
+}
+function migrateActivityParentChild(sqlite) {
+    sqlite.exec(`
+    alter table activity_audit_events add column parent_activity_id text;
+
+    create index if not exists activity_audit_events_parent_idx
+      on activity_audit_events(parent_activity_id, created_at);
+  `);
+}
 function addColumnIfMissing(sqlite, table, column, definition) {
     const columns = sqlite.prepare(`pragma table_info(${table})`).all();
     if (columns.some((existingColumn) => existingColumn.name === column))

package/dist/db/schema.js

@@ -97,6 +97,14 @@ export const activityAuditEvents = sqliteTable("activity_audit_events", {
     index("activity_audit_events_turn_idx").on(table.turnId, table.createdAt),
     index("activity_audit_events_created_idx").on(table.createdAt),
 ]);
+export const activityHostTurns = sqliteTable("activity_host_turns", {
+    turnId: text("turn_id").primaryKey(),
+    conversationScopeId: text("conversation_scope_id"),
+    createdAt: text("created_at").notNull(),
+}, (table) => [
+    index("activity_host_turns_conversation_idx").on(table.conversationScopeId, table.createdAt),
+    index("activity_host_turns_created_idx").on(table.createdAt),
+]);
 export const bashOutputStreams = sqliteTable("bash_output_streams", {
     id: text("id").primaryKey(),
     activityId: text("activity_id").notNull(),

package/dist/file-mutations.js

@@ -1,6 +1,6 @@
-import { lstat, realpath, rename, rm, rmdir, unlink } from "node:fs/promises";
+import { lstat, readdir, realpath, rename, rm, rmdir, unlink } from "node:fs/promises";
 import { resolve } from "node:path";
-import { expandHomePath, resolveCanonicalAllowedPath } from "./roots.js";
+import { expandHomePath, isPathInsideRoot, resolveCanonicalAllowedPath } from "./roots.js";
 export async function renamePath(input, context) {
     const source = await resolveCanonicalAllowedPath(input.path, context.cwd, context.allowedRoots);
     await assertNotAllowedRootItself(source, context.allowedRoots, input.path);
@@ -10,6 +10,37 @@ export async function renamePath(input, context) {
     await rename(source, destination);
     return { path: input.path, newPath: input.newPath };
 }
+export async function preflightDeletePaths(inputs, context) {
+    const targets = await Promise.all(inputs.map(async (input) => {
+        const path = await resolveCanonicalAllowedPath(input.path, context.cwd, context.allowedRoots);
+        await assertNotAllowedRootItself(path, context.allowedRoots, input.path);
+        const entry = await lstat(path);
+        const recursive = input.recursive ?? false;
+        if (entry.isDirectory() && !recursive) {
+            const entries = await readdir(path);
+            if (entries.length > 0) {
+                throw new Error(`Directory is non-empty: ${input.path}. Use recursive=true to delete it.`);
+            }
+        }
+        return {
+            inputPath: input.path,
+            canonicalPath: await realpath(path),
+        };
+    }));
+    for (let index = 0; index < targets.length; index += 1) {
+        const current = targets[index];
+        for (let otherIndex = index + 1; otherIndex < targets.length; otherIndex += 1) {
+            const other = targets[otherIndex];
+            if (current.canonicalPath === other.canonicalPath) {
+                throw new Error(`Bulk delete targets overlap: ${current.inputPath} and ${other.inputPath} resolve to the same path.`);
+            }
+            if (isPathInsideRoot(other.canonicalPath, current.canonicalPath) ||
+                isPathInsideRoot(current.canonicalPath, other.canonicalPath)) {
+                throw new Error(`Bulk delete targets overlap as ancestor/descendant paths: ${current.inputPath} and ${other.inputPath}.`);
+            }
+        }
+    }
+}
 export async function deletePath(input, context) {
     const path = await resolveCanonicalAllowedPath(input.path, context.cwd, context.allowedRoots);
     await assertNotAllowedRootItself(path, context.allowedRoots, input.path);

package/dist/lsp/test-support/server-fixture.js

@@ -6,7 +6,9 @@ import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
 import { ActivityAuditStore } from "../../activity/audit-store.js";
 import { BashOutputStore } from "../../activity/bash-output-store.js";
+import { HostTurnStore } from "../../activity/host-turn-store.js";
 import { ActivityLifecycle } from "../../activity/lifecycle.js";
+import { ActivityQueryService } from "../../activity/query-service.js";
 import { loadConfig } from "../../config.js";
 import { createReviewCheckpointManager } from "../../review-checkpoints.js";
 import { ProcessManager } from "../../process-sessions.js";
@@ -37,10 +39,14 @@ export async function createCodeIntelligenceServerFixture(t, options = {}) {
     const workspaces = new WorkspaceRegistry(config, store);
     const auditStore = new ActivityAuditStore(stateDir);
     const bashOutputStore = new BashOutputStore(stateDir);
+    const hostTurnStore = new HostTurnStore(stateDir);
+    const activityQueries = new ActivityQueryService(hostTurnStore, auditStore, bashOutputStore);
     const processSessions = new ProcessManager({ outputAudit: bashOutputStore });
-    const activityLifecycle = new ActivityLifecycle(auditStore);
+    const activityLifecycle = new ActivityLifecycle(auditStore, {
+        turnIdForConversation: (conversationScopeId) => activityQueries.currentTurnId(conversationScopeId),
+    });
     const codeIntelligence = new CodeIntelligenceManager(config, options.codeIntelligenceOptions);
-    const server = createMcpServer(config, workspaces, createReviewCheckpointManager(), processSessions, [], [], codeIntelligence, activityLifecycle, bashOutputStore);
+    const server = createMcpServer(config, workspaces, createReviewCheckpointManager(), processSessions, [], [], codeIntelligence, activityLifecycle, bashOutputStore, activityQueries);
     const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
     const client = new Client({ name: "forgerelay-code-intelligence-test-client", version: "1.0.0" });
     await Promise.all([client.connect(clientTransport), server.connect(serverTransport)]);
@@ -53,6 +59,7 @@ export async function createCodeIntelligenceServerFixture(t, options = {}) {
         await server.close();
         await codeIntelligence.shutdown();
         processSessions.shutdown();
+        hostTurnStore.close();
         bashOutputStore.close();
         auditStore.close();
         store.close();

package/dist/mcp/server-instructions.js

@@ -24,11 +24,11 @@ export function buildToolDescriptions(config) {
         ? ""
         : " Use shell commands for search and directory inspection instead of dedicated MCP search tools.";
     return {
-        read: `Read a file inside an open workspace or the OS temp directory. Instruction files and advertised capability guides returned by ${toolNames.openWorkspace} are also readable when applicable.${skillCapability} Only advertised entry files and files under already-loaded advertised directories are readable outside the normal roots. Call ${toolNames.openWorkspace} first and pass workspaceId.`,
+        read: `Read one file or multiple files inside an open workspace or the OS temp directory. Use path for one target or paths for multiple targets; offset/limit apply to every target in a bulk read. Instruction files and advertised capability guides returned by ${toolNames.openWorkspace} are also readable when applicable.${skillCapability} Only advertised entry files and files under already-loaded advertised directories are readable outside the normal roots. Call ${toolNames.openWorkspace} first and pass workspaceId.`,
         write: `Create or completely overwrite a file inside an open workspace or the OS temp directory. Workspace paths may be relative; OS temp paths may be absolute. Call ${toolNames.openWorkspace} first and pass workspaceId.`,
-        edit: `Edit one file inside an open workspace or the OS temp directory by replacing exact text blocks. Each oldText must match a unique, non-overlapping region of the original file. Workspace paths may be relative; OS temp paths may be absolute. Call ${toolNames.openWorkspace} first and pass workspaceId.`,
+        edit: `Edit one file or multiple files inside an open workspace or the OS temp directory by replacing exact text blocks. Use path for one target or paths for multiple targets; a bulk Edit applies the same edits to every file and preflights all targets before the first mutation. Each oldText must match a unique, non-overlapping region of the original file. Workspace paths may be relative; OS temp paths may be absolute. Call ${toolNames.openWorkspace} first and pass workspaceId.`,
         rename: `Rename or move one file or directory inside an open workspace or the OS temp directory without overwriting an existing destination. Source and destination must both remain inside the permitted file roots. Call ${toolNames.openWorkspace} first and pass workspaceId.`,
-        delete: `Delete one file or directory inside an open workspace or the OS temp directory. Non-empty directories require recursive=true. An allowed root itself cannot be deleted. Call ${toolNames.openWorkspace} first and pass workspaceId.`,
+        delete: `Delete one path or multiple paths inside an open workspace or the OS temp directory. Use path for one target or paths for multiple targets; a bulk Delete preflights all targets before deleting anything. Non-empty directories require recursive=true. An allowed root itself cannot be deleted. Call ${toolNames.openWorkspace} first and pass workspaceId.`,
         applyPatch: `Apply one Codex-style patch inside an open workspace or the OS temp directory. Supports adding, overwriting, updating, deleting, and moving files. Workspace paths must remain relative; absolute paths are accepted only inside the OS temp directory. Call ${toolNames.openWorkspace} first and pass workspaceId.`,
         shell: `Run or manage a shell process inside an open workspace.${shellSurface} Commands execute with the local user's authority; workspace containment does not make shell execution a sandbox. For action=run, yieldTimeMs is only the feedback wait (default 10000ms; 0 returns a processId immediately) and optional timeoutMs is the independent total execution limit. action=process polls/waits for incremental output, writes input, resizes a PTY, or interrupts by processId. Keep explicit waits below the Host request deadline; use 60000ms only when supported. Completed background results may be attached to a later result for the same workspaceId. Call ${toolNames.openWorkspace} first and pass workspaceId. Expose this capability only behind strong authentication.`,
         shellCommand: "Shell command to run with the local user's authority.",

package/dist/operations/batch/executor.js

@@ -0,0 +1,216 @@
+import { resolve } from "node:path";
+import { openAiConversationScopeId } from "../../request-meta.js";
+import { BatchScheduler } from "./scheduler.js";
+export class BatchExecutor {
+    dependencies;
+    scheduler;
+    shellSurface;
+    constructor(dependencies) {
+        this.dependencies = dependencies;
+        this.scheduler = dependencies.scheduler ?? new BatchScheduler();
+        this.shellSurface = dependencies.shellSurface ?? "bash";
+    }
+    async run(workspaceId, input, context) {
+        const workspace = this.dependencies.workspaces.getWorkspace(workspaceId);
+        let response;
+        await this.dependencies.lifecycle.run({
+            tool: "batch",
+            workspace: workspaceSnapshot(workspace),
+            conversationScopeId: openAiConversationScopeId(context.requestMeta),
+            request: {
+                workspaceId,
+                concurrency: input.concurrency ?? Math.min(input.tasks.length, 10),
+                tasks: input.tasks.map((task) => ({ id: task.id, operation: task.operation })),
+            },
+            operation: async (parentContext) => {
+                const scheduled = input.tasks.map((task) => this.scheduledTask(workspace, task, context, parentContext));
+                const results = await this.scheduler.run(scheduled, {
+                    concurrency: input.concurrency,
+                    signal: context.signal,
+                });
+                const children = results.map((result, index) => {
+                    const task = input.tasks[index];
+                    if (result.status === "error") {
+                        return {
+                            id: task.id,
+                            operation: task.operation,
+                            status: "error",
+                            error: result.error,
+                        };
+                    }
+                    const childResult = sanitizeChildResult(result.value.response);
+                    return {
+                        id: task.id,
+                        operation: task.operation,
+                        status: result.value.failed ? "error" : "done",
+                        result: childResult,
+                        ...(result.value.failed
+                            ? { error: childFailureMessage(result.value.response) }
+                            : {}),
+                    };
+                });
+                const failed = children.filter((child) => child.status === "error").length;
+                response = {
+                    status: failed > 0 ? "partial" : "done",
+                    tasks: children.length,
+                    completed: children.length - failed,
+                    failed,
+                    results: children,
+                };
+                return {
+                    childCount: children.length,
+                    completed: children.length - failed,
+                    failed,
+                };
+            },
+            outcome: batchParentOutcome,
+        });
+        if (!response)
+            throw new Error("Batch execution completed without a response.");
+        return response;
+    }
+    scheduledTask(workspace, task, context, parent) {
+        return {
+            id: task.id,
+            claims: taskClaims(workspace.root, task),
+            ...(batchTaskIsExclusive(task, this.dependencies.capabilityBatchPolicy) ? { exclusive: true } : {}),
+            run: async (signal) => {
+                const response = await this.runCoreTask(workspace.id, task, {
+                    ...context,
+                    signal,
+                    parentActivityId: parent.activityId,
+                    turnId: parent.turnId,
+                });
+                return {
+                    response,
+                    failed: this.dependencies.resultIsError(response),
+                };
+            },
+        };
+    }
+    runCoreTask(workspaceId, task, context) {
+        switch (task.operation) {
+            case "read":
+                return this.dependencies.coreOperations.read({
+                    workspaceId,
+                    path: task.path,
+                    offset: task.offset,
+                    limit: task.limit,
+                }, context);
+            case "write":
+                return this.dependencies.coreOperations.write({
+                    workspaceId,
+                    path: task.path,
+                    content: task.content,
+                }, context);
+            case "edit":
+                return this.dependencies.coreOperations.edit({
+                    workspaceId,
+                    path: task.path,
+                    edits: task.edits,
+                }, context);
+            case "rename":
+                return this.dependencies.coreOperations.rename({
+                    workspaceId,
+                    path: task.path,
+                    newPath: task.newPath,
+                }, context);
+            case "delete":
+                return this.dependencies.coreOperations.delete({
+                    workspaceId,
+                    path: task.path,
+                    recursive: task.recursive,
+                }, context);
+            case "capability.run":
+                return this.dependencies.coreOperations.capabilityRun({
+                    workspaceId,
+                    name: task.name,
+                    arguments: task.arguments,
+                }, { ...context, batch: true });
+            case "bash.run":
+                return this.dependencies.coreOperations.shellRun({
+                    workspaceId,
+                    command: task.command,
+                    surface: this.shellSurface,
+                    tty: task.tty,
+                    columns: task.columns,
+                    rows: task.rows,
+                    workingDirectory: task.workingDirectory,
+                    yieldTimeMs: task.yieldTimeMs,
+                    timeoutMs: task.timeoutMs,
+                    maxOutputTokens: task.maxOutputTokens,
+                }, context);
+        }
+    }
+}
+export function batchTaskIsExclusive(task, capabilityBatchPolicy) {
+    if (task.operation === "bash.run")
+        return true;
+    if (task.operation !== "capability.run")
+        return false;
+    return capabilityBatchPolicy?.(task.name) === "serial";
+}
+function batchParentOutcome(summary) {
+    return summary.failed > 0
+        ? { type: "failed", error: `${summary.failed} of ${summary.childCount} Batch tasks failed.` }
+        : { type: "succeeded" };
+}
+function taskClaims(root, task) {
+    switch (task.operation) {
+        case "read":
+            return [{ key: batchPathKey(root, task.path), mode: "read" }];
+        case "write":
+        case "edit":
+        case "delete":
+            return [{ key: batchPathKey(root, task.path), mode: "write" }];
+        case "rename":
+            return [
+                { key: batchPathKey(root, task.path), mode: "write" },
+                { key: batchPathKey(root, task.newPath), mode: "write" },
+            ];
+        case "capability.run":
+        case "bash.run":
+            return [];
+    }
+}
+function batchPathKey(root, path) {
+    const resolved = resolve(root, path);
+    return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+}
+function sanitizeChildResult(result) {
+    if (typeof result !== "object" || result === null) {
+        return { content: [{ type: "text", text: String(result ?? "") }] };
+    }
+    const record = result;
+    const content = Array.isArray(record.content) ? record.content : [];
+    const structuredContent = typeof record.structuredContent === "object" &&
+        record.structuredContent !== null &&
+        !Array.isArray(record.structuredContent)
+        ? record.structuredContent
+        : undefined;
+    return {
+        content,
+        ...(structuredContent ? { structuredContent } : {}),
+        ...(record.isError === true ? { isError: true } : {}),
+    };
+}
+function childFailureMessage(result) {
+    const sanitized = sanitizeChildResult(result);
+    const text = sanitized.content.flatMap((entry) => {
+        if (typeof entry !== "object" || entry === null)
+            return [];
+        const value = entry.text;
+        return typeof value === "string" ? [value] : [];
+    }).join("\n").trim();
+    return text || "Batch child returned an error result.";
+}
+function workspaceSnapshot(workspace) {
+    return {
+        id: workspace.id,
+        root: workspace.root,
+        mode: workspace.mode,
+        ...(workspace.sourceRoot ? { sourceRoot: workspace.sourceRoot } : {}),
+        ...(workspace.worktree?.branch ? { branch: workspace.worktree.branch } : {}),
+        ...(workspace.worktree?.targetBranch ? { targetBranch: workspace.worktree.targetBranch } : {}),
+    };
+}

package/dist/operations/batch/scheduler.js

@@ -0,0 +1,108 @@
+import { relative, sep } from "node:path";
+export class BatchScheduler {
+    async run(tasks, options = {}) {
+        validateTasks(tasks);
+        const concurrency = resolveConcurrency(tasks.length, options.concurrency);
+        const signal = options.signal ?? new AbortController().signal;
+        signal.throwIfAborted();
+        const pending = new Set(tasks.map((_task, index) => index));
+        const active = new Map();
+        const results = new Array(tasks.length);
+        while (pending.size > 0 || active.size > 0) {
+            signal.throwIfAborted();
+            this.startRunnable(tasks, pending, active, concurrency, signal);
+            if (active.size === 0) {
+                throw new Error("Batch scheduler could not make progress.");
+            }
+            const settled = await Promise.race([...active.values()].map((entry) => entry.promise));
+            active.delete(settled.index);
+            if (signal.aborted) {
+                await Promise.allSettled([...active.values()].map((entry) => entry.promise));
+                throw abortReason(signal);
+            }
+            const task = tasks[settled.index];
+            results[settled.index] = settled.status === "done"
+                ? { id: task.id, status: "done", value: settled.value }
+                : { id: task.id, status: "error", error: errorMessage(settled.error) };
+        }
+        return results.map((result, index) => {
+            if (!result)
+                throw new Error(`Batch task ${tasks[index]?.id ?? index} did not produce a result.`);
+            return result;
+        });
+    }
+    startRunnable(tasks, pending, active, concurrency, signal) {
+        while (active.size < concurrency) {
+            signal.throwIfAborted();
+            const index = [...pending].find((candidate) => canStart(tasks[candidate], active));
+            if (index === undefined)
+                return;
+            const task = tasks[index];
+            pending.delete(index);
+            const promise = Promise.resolve()
+                .then(() => task.run(signal))
+                .then((value) => ({ index, status: "done", value }))
+                .catch((error) => ({ index, status: "error", error }));
+            active.set(index, { task, promise });
+        }
+    }
+}
+function validateTasks(tasks) {
+    if (tasks.length < 1 || tasks.length > 100) {
+        throw new Error(`Batch task count must be between 1 and 100; received ${tasks.length}.`);
+    }
+    const ids = new Set();
+    for (const task of tasks) {
+        if (!task.id.trim())
+            throw new Error("Batch task id must not be empty.");
+        if (ids.has(task.id))
+            throw new Error(`Batch task ids must be unique; duplicate id: ${task.id}.`);
+        ids.add(task.id);
+    }
+}
+function resolveConcurrency(taskCount, requested) {
+    const concurrency = requested ?? Math.min(taskCount, 10);
+    if (!Number.isInteger(concurrency) || concurrency < 1 || concurrency > 10) {
+        throw new Error(`Batch concurrency must be an integer between 1 and 10; received ${concurrency}.`);
+    }
+    return concurrency;
+}
+function canStart(task, active) {
+    if (task.exclusive)
+        return active.size === 0;
+    for (const entry of active.values()) {
+        if (entry.task.exclusive)
+            return false;
+        if (claimsConflict(task.claims, entry.task.claims))
+            return false;
+    }
+    return true;
+}
+function claimsConflict(left, right) {
+    for (const first of left) {
+        for (const second of right) {
+            if (first.mode === "read" && second.mode === "read")
+                continue;
+            if (pathsOverlap(first.key, second.key))
+                return true;
+        }
+    }
+    return false;
+}
+function pathsOverlap(left, right) {
+    if (left === right)
+        return true;
+    return isInside(left, right) || isInside(right, left);
+}
+function isInside(path, root) {
+    const rel = relative(root, path);
+    return rel !== "" && rel !== ".." && !rel.startsWith(`..${sep}`);
+}
+function abortReason(signal) {
+    return signal.reason instanceof Error
+        ? signal.reason
+        : new Error(signal.reason === undefined ? "Batch execution was cancelled." : String(signal.reason));
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/operations/batch/types.js

@@ -0,0 +1,76 @@
+import { z } from "zod";
+const taskId = z.string().min(1).max(128);
+const path = z.string().min(1);
+const capabilityName = z.string().regex(/^[a-z][a-z0-9-]*(?:\.[a-z][a-z0-9-]*)+$/);
+const editEntry = z.object({
+    oldText: z.string(),
+    newText: z.string(),
+}).strict();
+export const batchCoreTaskSchema = z.discriminatedUnion("operation", [
+    z.object({
+        id: taskId,
+        operation: z.literal("read"),
+        path,
+        offset: z.number().int().positive().optional(),
+        limit: z.number().int().positive().optional(),
+    }).strict(),
+    z.object({
+        id: taskId,
+        operation: z.literal("write"),
+        path,
+        content: z.string(),
+    }).strict(),
+    z.object({
+        id: taskId,
+        operation: z.literal("edit"),
+        path,
+        edits: z.array(editEntry).min(1),
+    }).strict(),
+    z.object({
+        id: taskId,
+        operation: z.literal("rename"),
+        path,
+        newPath: path,
+    }).strict(),
+    z.object({
+        id: taskId,
+        operation: z.literal("delete"),
+        path,
+        recursive: z.boolean().optional(),
+    }).strict(),
+    z.object({
+        id: taskId,
+        operation: z.literal("capability.run"),
+        name: capabilityName,
+        arguments: z.record(z.string(), z.unknown()).optional(),
+    }).strict(),
+    z.object({
+        id: taskId,
+        operation: z.literal("bash.run"),
+        command: z.string().min(1),
+        tty: z.boolean().optional(),
+        columns: z.number().int().min(1).max(1_000).optional(),
+        rows: z.number().int().min(1).max(1_000).optional(),
+        workingDirectory: z.string().optional(),
+        yieldTimeMs: z.number().int().min(0).max(300_000).optional(),
+        timeoutMs: z.number().int().min(1).max(86_400_000).optional(),
+        maxOutputTokens: z.number().int().positive().max(100_000).optional(),
+    }).strict(),
+]);
+export const batchExecuteInputSchema = z.object({
+    tasks: z.array(batchCoreTaskSchema).min(1).max(100),
+    concurrency: z.number().int().min(1).max(10).optional(),
+}).strict().superRefine((input, context) => {
+    const ids = new Set();
+    for (const task of input.tasks) {
+        if (ids.has(task.id)) {
+            context.addIssue({
+                code: "custom",
+                path: ["tasks"],
+                message: `Batch task ids must be unique; duplicate id: ${task.id}.`,
+            });
+            return;
+        }
+        ids.add(task.id);
+    }
+});