@arnilo/prism-coding-agent 0.0.96 → 0.1.1

package/dist/lifecycle.d.ts

@@ -0,0 +1,75 @@
+import type { CodingProcessEvent } from "./process/types.js";
+export type FileChangeOp = "write" | "edit" | "delete" | "move";
+export interface FileChangedEvent {
+    readonly type: "file_changed";
+    /** Workspace-relative or policy-checked absolute path. Never a raw file body. */
+    readonly path: string;
+    readonly op: FileChangeOp;
+    readonly toolCallId?: string;
+}
+export interface WorktreeChangedEvent {
+    readonly type: "worktree_changed";
+    readonly action: "add" | "remove";
+    readonly path: string;
+    readonly toolCallId?: string;
+}
+export interface PermissionDeniedEvent {
+    readonly type: "permission_denied";
+    /** Policy decision reason. Never includes raw tool arguments. */
+    readonly reason: string;
+    readonly toolName: string;
+    readonly toolCallId?: string;
+    readonly approvalId?: string;
+}
+export interface ConfigurationChangedEvent {
+    readonly type: "configuration_changed";
+    /** Changed config keys only; values never travel in the event. */
+    readonly keys: readonly string[];
+}
+export type CodingLifecycleEvent = CodingProcessEvent | FileChangedEvent | WorktreeChangedEvent | PermissionDeniedEvent | ConfigurationChangedEvent;
+export declare const DEFAULT_LIFECYCLE_MAX_EVENT_BYTES = 16384;
+export declare const HARD_LIFECYCLE_MAX_EVENT_BYTES = 65536;
+export declare const DEFAULT_LIFECYCLE_MAX_PATH_BYTES = 4096;
+export declare const HARD_LIFECYCLE_MAX_PATH_BYTES = 16384;
+export declare const DEFAULT_LIFECYCLE_MAX_REASON_BYTES = 1024;
+export declare const HARD_LIFECYCLE_MAX_REASON_BYTES = 16384;
+export declare const DEFAULT_LIFECYCLE_MAX_TOOL_NAME_BYTES = 256;
+export declare const HARD_LIFECYCLE_MAX_TOOL_NAME_BYTES = 4096;
+export declare const DEFAULT_LIFECYCLE_MAX_CONFIG_KEYS = 64;
+export declare const HARD_LIFECYCLE_MAX_CONFIG_KEYS = 256;
+export interface CodingLifecycleLimits {
+    readonly maxEventBytes?: number;
+    readonly maxPathBytes?: number;
+    readonly maxReasonBytes?: number;
+    readonly maxToolNameBytes?: number;
+    readonly maxConfigKeys?: number;
+}
+export interface ResolvedCodingLifecycleLimits {
+    readonly maxEventBytes: number;
+    readonly maxPathBytes: number;
+    readonly maxReasonBytes: number;
+    readonly maxToolNameBytes: number;
+    readonly maxConfigKeys: number;
+}
+export declare class CodingLifecycleError extends Error {
+    readonly code = "ERR_PRISM_LIFECYCLE_LIMIT";
+    constructor(message: string);
+}
+export declare function resolveCodingLifecycleLimits(limits?: CodingLifecycleLimits): ResolvedCodingLifecycleLimits;
+export interface CodingLifecycleEmitter {
+    /**
+     * Delivers the event to every registered listener. Returns true when at least one
+     * listener received it. Drops (returns false) without throwing for unknown kinds,
+     * oversized events, or when no listener is registered, so producer success paths
+     * never break on telemetry.
+     */
+    emit(event: CodingLifecycleEvent): boolean;
+    /** Registers a listener; the returned function unregisters it. */
+    on(listener: (event: CodingLifecycleEvent) => void): () => void;
+}
+export interface CreateCodingLifecycleEmitterOptions {
+    readonly limits?: CodingLifecycleLimits;
+    /** Convenience initial listener, equivalent to `on`. */
+    readonly onEvent?: (event: CodingLifecycleEvent) => void;
+}
+export declare function createCodingLifecycleEmitter(options?: CreateCodingLifecycleEmitterOptions): CodingLifecycleEmitter;

package/dist/lifecycle.js

@@ -0,0 +1,102 @@
+/**
+ * Consumer-gated coding lifecycle events (Phase 10 Task 1 freeze).
+ *
+ * Ships only event kinds with a consumer in 0.0.27 (ACP mapper and/or host
+ * `CodingLifecycleEmitter` callback). Deferred kinds — check_started/finished,
+ * task_created/completed, compaction_started/finished, subagent_started/stopped —
+ * MUST NOT be added here until a consumer exists
+ * (scripts/phase10-freeze-manifest.json lifecycle.deferredEvents).
+ */
+import { validateCodingLimit } from "./limits.js";
+export const DEFAULT_LIFECYCLE_MAX_EVENT_BYTES = 16_384;
+export const HARD_LIFECYCLE_MAX_EVENT_BYTES = 65_536;
+export const DEFAULT_LIFECYCLE_MAX_PATH_BYTES = 4_096;
+export const HARD_LIFECYCLE_MAX_PATH_BYTES = 16_384;
+export const DEFAULT_LIFECYCLE_MAX_REASON_BYTES = 1_024;
+export const HARD_LIFECYCLE_MAX_REASON_BYTES = 16_384;
+export const DEFAULT_LIFECYCLE_MAX_TOOL_NAME_BYTES = 256;
+export const HARD_LIFECYCLE_MAX_TOOL_NAME_BYTES = 4_096;
+export const DEFAULT_LIFECYCLE_MAX_CONFIG_KEYS = 64;
+export const HARD_LIFECYCLE_MAX_CONFIG_KEYS = 256;
+export class CodingLifecycleError extends Error {
+    code = "ERR_PRISM_LIFECYCLE_LIMIT";
+    constructor(message) {
+        super(message);
+        this.name = "CodingLifecycleError";
+    }
+}
+function validate(name, value, hard) {
+    try {
+        return validateCodingLimit(name, value, hard);
+    }
+    catch (error) {
+        throw new CodingLifecycleError(error instanceof Error ? error.message : String(error));
+    }
+}
+export function resolveCodingLifecycleLimits(limits) {
+    return {
+        maxEventBytes: validate("maxEventBytes", limits?.maxEventBytes ?? DEFAULT_LIFECYCLE_MAX_EVENT_BYTES, HARD_LIFECYCLE_MAX_EVENT_BYTES),
+        maxPathBytes: validate("maxPathBytes", limits?.maxPathBytes ?? DEFAULT_LIFECYCLE_MAX_PATH_BYTES, HARD_LIFECYCLE_MAX_PATH_BYTES),
+        maxReasonBytes: validate("maxReasonBytes", limits?.maxReasonBytes ?? DEFAULT_LIFECYCLE_MAX_REASON_BYTES, HARD_LIFECYCLE_MAX_REASON_BYTES),
+        maxToolNameBytes: validate("maxToolNameBytes", limits?.maxToolNameBytes ?? DEFAULT_LIFECYCLE_MAX_TOOL_NAME_BYTES, HARD_LIFECYCLE_MAX_TOOL_NAME_BYTES),
+        maxConfigKeys: validate("maxConfigKeys", limits?.maxConfigKeys ?? DEFAULT_LIFECYCLE_MAX_CONFIG_KEYS, HARD_LIFECYCLE_MAX_CONFIG_KEYS),
+    };
+}
+/** Frozen shipped kinds: the six CodingProcessEvent kinds plus the four new kinds. */
+const FROZEN_EVENT_TYPES = new Set([
+    "process_started",
+    "process_exited",
+    "process_killed",
+    "process_released",
+    "process_expired",
+    "process_unknown",
+    "file_changed",
+    "worktree_changed",
+    "permission_denied",
+    "configuration_changed",
+]);
+export function createCodingLifecycleEmitter(options = {}) {
+    const limits = resolveCodingLifecycleLimits(options.limits);
+    const listeners = new Set();
+    if (options.onEvent)
+        listeners.add(options.onEvent);
+    return {
+        emit(event) {
+            if (!event || typeof event !== "object" || !FROZEN_EVENT_TYPES.has(event.type))
+                return false;
+            if (Buffer.byteLength(JSON.stringify(event), "utf8") > limits.maxEventBytes)
+                return false;
+            switch (event.type) {
+                case "file_changed":
+                case "worktree_changed":
+                    if (Buffer.byteLength(event.path, "utf8") > limits.maxPathBytes)
+                        return false;
+                    break;
+                case "permission_denied":
+                    if (Buffer.byteLength(event.reason, "utf8") > limits.maxReasonBytes)
+                        return false;
+                    if (Buffer.byteLength(event.toolName, "utf8") > limits.maxToolNameBytes)
+                        return false;
+                    break;
+                case "configuration_changed":
+                    if (event.keys.length > limits.maxConfigKeys)
+                        return false;
+                    break;
+                default:
+                    break;
+            }
+            if (listeners.size === 0)
+                return false;
+            for (const listener of [...listeners])
+                listener(event);
+            return true;
+        },
+        on(listener) {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+    };
+}
+//# sourceMappingURL=lifecycle.js.map

package/dist/limits.d.ts

@@ -53,6 +53,9 @@ export declare const DEFAULT_MAX_GIT_MESSAGE_BYTES: number;
 export declare const HARD_MAX_GIT_MESSAGE_BYTES: number;
 export declare const DEFAULT_MAX_GIT_OUTPUT_BYTES: number;
 export declare const HARD_MAX_GIT_OUTPUT_BYTES: number;
+/** Phase 9 freeze: `git ls-files` stdout cap for ignore-aware enumeration. */
+export declare const DEFAULT_MAX_LS_FILES_OUTPUT_BYTES: number;
+export declare const HARD_MAX_LS_FILES_OUTPUT_BYTES: number;
 export declare const DEFAULT_MAX_GIT_DIFF_LINES = 10000;
 export declare const HARD_MAX_GIT_DIFF_LINES = 100000;
 export declare const DEFAULT_MAX_GIT_CHANGED_FILES = 1000;
@@ -92,6 +95,44 @@ export declare const DEFAULT_MAX_CHECK_SUMMARY_BYTES = 1024;
 export declare const HARD_MAX_CHECK_SUMMARY_BYTES = 8192;
 export declare const DEFAULT_MAX_CODING_CHECKPOINT_BYTES: number;
 export declare const HARD_MAX_CODING_CHECKPOINT_BYTES: number;
+/** Phase 9 freeze: language-intelligence / LSP client caps. */
+export declare const DEFAULT_MAX_LSP_MESSAGE_BYTES: number;
+export declare const HARD_MAX_LSP_MESSAGE_BYTES: number;
+export declare const DEFAULT_MAX_LSP_DIAGNOSTICS_PER_FILE = 200;
+export declare const HARD_MAX_LSP_DIAGNOSTICS_PER_FILE = 1000;
+export declare const DEFAULT_MAX_LSP_PENDING_REQUESTS = 32;
+export declare const HARD_MAX_LSP_PENDING_REQUESTS = 128;
+export declare const DEFAULT_MAX_LSP_RESULTS_PER_QUERY = 500;
+export declare const HARD_MAX_LSP_RESULTS_PER_QUERY = 5000;
+export declare const DEFAULT_MAX_LSP_TIMEOUT_MS = 30000;
+export declare const HARD_MAX_LSP_TIMEOUT_MS = 120000;
+export declare const DEFAULT_MAX_LSP_SERVERS = 4;
+export declare const HARD_MAX_LSP_SERVERS = 8;
+/** Freeze: restart budget is fixed at 3 (not host-configurable above). */
+export declare const LSP_RESTARTS_PER_SERVER = 3;
+/** Phase 9 freeze: managed process-session caps. */
+export declare const DEFAULT_MAX_PROCESS_SESSIONS = 8;
+export declare const HARD_MAX_PROCESS_SESSIONS = 32;
+export declare const DEFAULT_MAX_PROCESS_INPUT_BYTES: number;
+export declare const HARD_MAX_PROCESS_INPUT_BYTES: number;
+export declare const DEFAULT_MAX_PROCESS_LIFETIME_MS: number;
+export declare const HARD_MAX_PROCESS_LIFETIME_MS: number;
+export declare const DEFAULT_MAX_PROCESS_OUTPUT_CHUNK_BYTES: number;
+export declare const HARD_MAX_PROCESS_OUTPUT_CHUNK_BYTES: number;
+/** Total output reuses existing accumulator ceilings (64 MiB / 1 GiB). */
+export declare const DEFAULT_MAX_PROCESS_TOTAL_OUTPUT_BYTES: number;
+export declare const HARD_MAX_PROCESS_TOTAL_OUTPUT_BYTES: number;
+/** Forge (GitHub adapter) defaults and hard caps (Phase 9 Task 5). */
+export declare const DEFAULT_MAX_FORGE_PAGES_PER_OPERATION = 10;
+export declare const HARD_MAX_FORGE_PAGES_PER_OPERATION = 100;
+export declare const DEFAULT_MAX_FORGE_PAYLOAD_BYTES: number;
+export declare const HARD_MAX_FORGE_PAYLOAD_BYTES: number;
+export declare const DEFAULT_MAX_FORGE_COMMENTS_PER_REVIEW = 100;
+export declare const HARD_MAX_FORGE_COMMENTS_PER_REVIEW = 1000;
+export declare const DEFAULT_MAX_FORGE_REQUEST_CONCURRENCY = 4;
+export declare const HARD_MAX_FORGE_REQUEST_CONCURRENCY = 8;
+export declare const DEFAULT_MAX_FORGE_REQUEST_TIMEOUT_MS = 30000;
+export declare const HARD_MAX_FORGE_REQUEST_TIMEOUT_MS = 120000;
 /** Validate one configurable coding resource limit. Invalid values fail instead of clamping. */
 export declare function validateCodingLimit(name: string, value: number, hardCap: number): number;
 /** Validate a non-negative integer limit (0 allowed), still capped. */

package/dist/limits.js

@@ -53,6 +53,9 @@ export const DEFAULT_MAX_GIT_MESSAGE_BYTES = 64 * 1024;
 export const HARD_MAX_GIT_MESSAGE_BYTES = 256 * 1024;
 export const DEFAULT_MAX_GIT_OUTPUT_BYTES = 4 * 1024 * 1024;
 export const HARD_MAX_GIT_OUTPUT_BYTES = 64 * 1024 * 1024;
+/** Phase 9 freeze: `git ls-files` stdout cap for ignore-aware enumeration. */
+export const DEFAULT_MAX_LS_FILES_OUTPUT_BYTES = 8 * 1024 * 1024;
+export const HARD_MAX_LS_FILES_OUTPUT_BYTES = 64 * 1024 * 1024;
 export const DEFAULT_MAX_GIT_DIFF_LINES = 10_000;
 export const HARD_MAX_GIT_DIFF_LINES = 100_000;
 export const DEFAULT_MAX_GIT_CHANGED_FILES = 1_000;
@@ -92,6 +95,44 @@ export const DEFAULT_MAX_CHECK_SUMMARY_BYTES = 1_024;
 export const HARD_MAX_CHECK_SUMMARY_BYTES = 8_192;
 export const DEFAULT_MAX_CODING_CHECKPOINT_BYTES = 64 * 1024;
 export const HARD_MAX_CODING_CHECKPOINT_BYTES = 512 * 1024;
+/** Phase 9 freeze: language-intelligence / LSP client caps. */
+export const DEFAULT_MAX_LSP_MESSAGE_BYTES = 4 * 1024 * 1024;
+export const HARD_MAX_LSP_MESSAGE_BYTES = 32 * 1024 * 1024;
+export const DEFAULT_MAX_LSP_DIAGNOSTICS_PER_FILE = 200;
+export const HARD_MAX_LSP_DIAGNOSTICS_PER_FILE = 1_000;
+export const DEFAULT_MAX_LSP_PENDING_REQUESTS = 32;
+export const HARD_MAX_LSP_PENDING_REQUESTS = 128;
+export const DEFAULT_MAX_LSP_RESULTS_PER_QUERY = 500;
+export const HARD_MAX_LSP_RESULTS_PER_QUERY = 5_000;
+export const DEFAULT_MAX_LSP_TIMEOUT_MS = 30_000;
+export const HARD_MAX_LSP_TIMEOUT_MS = 120_000;
+export const DEFAULT_MAX_LSP_SERVERS = 4;
+export const HARD_MAX_LSP_SERVERS = 8;
+/** Freeze: restart budget is fixed at 3 (not host-configurable above). */
+export const LSP_RESTARTS_PER_SERVER = 3;
+/** Phase 9 freeze: managed process-session caps. */
+export const DEFAULT_MAX_PROCESS_SESSIONS = 8;
+export const HARD_MAX_PROCESS_SESSIONS = 32;
+export const DEFAULT_MAX_PROCESS_INPUT_BYTES = 64 * 1024;
+export const HARD_MAX_PROCESS_INPUT_BYTES = 1024 * 1024;
+export const DEFAULT_MAX_PROCESS_LIFETIME_MS = 4 * 60 * 60 * 1000;
+export const HARD_MAX_PROCESS_LIFETIME_MS = 24 * 60 * 60 * 1000;
+export const DEFAULT_MAX_PROCESS_OUTPUT_CHUNK_BYTES = 50 * 1024;
+export const HARD_MAX_PROCESS_OUTPUT_CHUNK_BYTES = 1024 * 1024;
+/** Total output reuses existing accumulator ceilings (64 MiB / 1 GiB). */
+export const DEFAULT_MAX_PROCESS_TOTAL_OUTPUT_BYTES = DEFAULT_MAX_TOTAL_OUTPUT_BYTES;
+export const HARD_MAX_PROCESS_TOTAL_OUTPUT_BYTES = HARD_MAX_TOTAL_OUTPUT_BYTES;
+/** Forge (GitHub adapter) defaults and hard caps (Phase 9 Task 5). */
+export const DEFAULT_MAX_FORGE_PAGES_PER_OPERATION = 10;
+export const HARD_MAX_FORGE_PAGES_PER_OPERATION = 100;
+export const DEFAULT_MAX_FORGE_PAYLOAD_BYTES = 1024 * 1024;
+export const HARD_MAX_FORGE_PAYLOAD_BYTES = 8 * 1024 * 1024;
+export const DEFAULT_MAX_FORGE_COMMENTS_PER_REVIEW = 100;
+export const HARD_MAX_FORGE_COMMENTS_PER_REVIEW = 1000;
+export const DEFAULT_MAX_FORGE_REQUEST_CONCURRENCY = 4;
+export const HARD_MAX_FORGE_REQUEST_CONCURRENCY = 8;
+export const DEFAULT_MAX_FORGE_REQUEST_TIMEOUT_MS = 30_000;
+export const HARD_MAX_FORGE_REQUEST_TIMEOUT_MS = 120_000;
 /** Validate one configurable coding resource limit. Invalid values fail instead of clamping. */
 export function validateCodingLimit(name, value, hardCap) {
     if (!Number.isSafeInteger(value) || value < 1 || value > hardCap) {

package/dist/list.js

@@ -1,6 +1,7 @@
+import { CODING_OBSERVATION_EFFECT } from "./effects.js";
 import { enforceExecutionPolicy } from "./execution-policy.js";
-import { createLocalRepositoryOperations, resolveRepositoryLimits, RepositoryError, } from "./repository.js";
 import { HARD_MAX_REPO_DEPTH, HARD_MAX_REPO_RESULTS, validateCodingLimit, validateCodingLimitAllowZero } from "./limits.js";
+import { createLocalRepositoryOperations, RepositoryError, resolveRepositoryLimits, } from "./repository.js";
 function errorResult(toolCallId, message) {
     return {
         toolCallId,
@@ -11,9 +12,7 @@ function errorResult(toolCallId, message) {
 }
 function formatListText(result) {
     if (result.entries.length === 0) {
-        return result.truncated
-            ? `[truncated by ${result.truncatedBy ?? "limit"} before any entries]`
-            : "(no entries)";
+        return result.truncated ? `[truncated by ${result.truncatedBy ?? "limit"} before any entries]` : "(no entries)";
     }
     const lines = result.entries.map((entry) => {
         const size = entry.size !== undefined ? `\t${entry.size}` : "";
@@ -35,7 +34,8 @@ export function createRepoListTool(cwd, options) {
     const ops = options?.operations ?? createLocalRepositoryOperations(limits);
     return {
         name: "repo_list",
-        description: `List repository entries under the workspace with deterministic relative paths. Skips hidden names and excluded basenames (default: ${limits.exclude.join(", ")}) unless overridden. Does not follow symlinks. Results paginate with offset/maxResults (default ${limits.maxResults}). Depth default ${limits.maxDepth}.`,
+        effect: CODING_OBSERVATION_EFFECT,
+        description: `List repository entries under the workspace with deterministic relative paths. Prefer glob when you already know a filename pattern (*.ts, **/src/**). Prefer repo_search to find text inside files. Skips hidden names and excluded basenames (default: ${limits.exclude.join(", ")}) unless overridden. Does not follow symlinks. Results paginate with offset/maxResults (default ${limits.maxResults}). Depth default ${limits.maxDepth}.`,
         parameters: {
             type: "object",
             properties: {
@@ -131,11 +131,7 @@ export function createRepoListTool(cwd, options) {
                 };
             }
             catch (error) {
-                const message = error instanceof RepositoryError
-                    ? error.message
-                    : error instanceof Error
-                        ? error.message
-                        : String(error);
+                const message = error instanceof RepositoryError ? error.message : error instanceof Error ? error.message : String(error);
                 return errorResult(toolCallId, message);
             }
         },

package/dist/move.d.ts

@@ -0,0 +1,24 @@
+import type { ExecutionPolicy, ToolDefinition } from "@arnilo/prism";
+import type { MutationStat } from "./delete.js";
+import type { CodingLifecycleEvent } from "./lifecycle.js";
+export interface MoveOperations {
+    lstat: (absolutePath: string, options?: {
+        signal?: AbortSignal;
+    }) => Promise<MutationStat>;
+    rename: (from: string, to: string, options?: {
+        signal?: AbortSignal;
+    }) => Promise<void>;
+    unlink: (absolutePath: string, options?: {
+        signal?: AbortSignal;
+    }) => Promise<void>;
+    access: (absolutePath: string, options?: {
+        signal?: AbortSignal;
+    }) => Promise<void>;
+}
+export interface MoveToolOptions {
+    executionPolicy?: ExecutionPolicy;
+    operations?: MoveOperations;
+    /** Optional consumer-gated lifecycle listener (file_changed / permission_denied). */
+    onEvent?: (event: CodingLifecycleEvent) => void;
+}
+export declare function createMoveTool(cwd: string, options?: MoveToolOptions): ToolDefinition;

package/dist/move.js

@@ -0,0 +1,150 @@
+import { access, constants } from "node:fs";
+import { dirname } from "node:path";
+import { lstat, rename, unlink } from "node:fs/promises";
+import { promisify } from "node:util";
+import { CODING_LOCAL_EFFECT } from "./effects.js";
+import { enforceExecutionPolicy } from "./execution-policy.js";
+import { withFileMutationQueue } from "./file-mutation-queue.js";
+import { resolveContainedMutationPath } from "./mutation-path.js";
+const accessAsync = promisify(access);
+const defaultMoveOperations = {
+    lstat: async (path) => {
+        const st = await lstat(path);
+        return {
+            isFile: () => st.isFile(),
+            isDirectory: () => st.isDirectory(),
+            isSymbolicLink: () => st.isSymbolicLink(),
+            size: st.size,
+        };
+    },
+    rename: (from, to) => rename(from, to).then(() => { }),
+    unlink: (path) => unlink(path).then(() => { }),
+    access: (path) => accessAsync(path, constants.F_OK),
+};
+function errorResult(toolCallId, message) {
+    return {
+        toolCallId,
+        name: "move",
+        content: [{ type: "text", text: message }],
+        error: { message },
+    };
+}
+async function withDualFileMutationQueue(pathA, pathB, fn) {
+    const [first, second] = pathA <= pathB ? [pathA, pathB] : [pathB, pathA];
+    return withFileMutationQueue(first, () => withFileMutationQueue(second, fn));
+}
+export function createMoveTool(cwd, options) {
+    const ops = options?.operations ?? defaultMoveOperations;
+    return {
+        name: "move",
+        effect: CODING_LOCAL_EFFECT,
+        description: "High-risk: move or rename a file within the workspace. Set overwrite=true to replace an existing destination file only (directories/non-empty dest rejected). Does not create parent directories. No trash — host undo is not automatic.",
+        parameters: {
+            type: "object",
+            properties: {
+                from: { type: "string", description: "Source path (relative or absolute)" },
+                to: { type: "string", description: "Destination path (relative or absolute)" },
+                overwrite: {
+                    type: "boolean",
+                    description: "Replace an existing destination file when true (default false).",
+                },
+            },
+            required: ["from", "to"],
+            additionalProperties: false,
+        },
+        async execute(args, context) {
+            const toolCallId = context.toolCallId;
+            const from = typeof args.from === "string" ? args.from : "";
+            const to = typeof args.to === "string" ? args.to : "";
+            const overwrite = args.overwrite === true;
+            if (from.length === 0)
+                return errorResult(toolCallId, "from is required and must be a non-empty string.");
+            if (to.length === 0)
+                return errorResult(toolCallId, "to is required and must be a non-empty string.");
+            try {
+                let fromPath;
+                try {
+                    fromPath = await resolveContainedMutationPath(cwd, from);
+                }
+                catch (error) {
+                    const err = error;
+                    if (err.code === "ENOENT")
+                        return errorResult(toolCallId, `Source does not exist: ${from}`);
+                    throw error;
+                }
+                const toPath = await resolveContainedMutationPath(cwd, to, { allowMissing: true });
+                const policyCheck = await enforceExecutionPolicy(options?.executionPolicy, {
+                    kind: "move",
+                    operation: "move",
+                    paths: [fromPath, toPath],
+                    risk: "high",
+                    metadata: { overwrite, sessionId: context.sessionId, runId: context.runId, signal: context.signal },
+                }, toolCallId, "move", (denied) => options?.onEvent?.({ type: "permission_denied", ...denied }));
+                if (!policyCheck.allowed)
+                    return policyCheck.result;
+                const allowedFrom = policyCheck.action.paths?.[0] ?? fromPath;
+                const allowedTo = policyCheck.action.paths?.[1] ?? toPath;
+                return await withDualFileMutationQueue(allowedFrom, allowedTo, async () => {
+                    if (context.signal?.aborted)
+                        return errorResult(toolCallId, "Operation aborted");
+                    let fromStat;
+                    try {
+                        fromStat = await ops.lstat(allowedFrom, { signal: context.signal });
+                    }
+                    catch (error) {
+                        const err = error;
+                        if (err.code === "ENOENT")
+                            return errorResult(toolCallId, `Source does not exist: ${from}`);
+                        const message = error instanceof Error ? error.message : String(error);
+                        return errorResult(toolCallId, message);
+                    }
+                    const destParent = dirname(allowedTo);
+                    try {
+                        await ops.access(destParent, { signal: context.signal });
+                    }
+                    catch {
+                        return errorResult(toolCallId, `Destination parent directory does not exist: ${destParent}`);
+                    }
+                    let destStat;
+                    try {
+                        destStat = await ops.lstat(allowedTo, { signal: context.signal });
+                    }
+                    catch (error) {
+                        const err = error;
+                        if (err.code !== "ENOENT") {
+                            const message = error instanceof Error ? error.message : String(error);
+                            return errorResult(toolCallId, message);
+                        }
+                    }
+                    if (destStat) {
+                        if (!overwrite)
+                            return errorResult(toolCallId, `Destination already exists: ${to}. Pass overwrite=true to replace.`);
+                        if (destStat.isDirectory())
+                            return errorResult(toolCallId, `Destination is a directory: ${to}`);
+                        await ops.unlink(allowedTo, { signal: context.signal });
+                    }
+                    if (context.signal?.aborted)
+                        return errorResult(toolCallId, "Operation aborted");
+                    await ops.rename(allowedFrom, allowedTo, { signal: context.signal });
+                    options?.onEvent?.({ type: "file_changed", path: allowedTo, op: "move", toolCallId });
+                    return {
+                        toolCallId,
+                        name: "move",
+                        content: [{ type: "text", text: `Successfully moved ${from} to ${allowedTo}` }],
+                        metadata: {
+                            from: allowedFrom,
+                            to: allowedTo,
+                            bytes: fromStat.isFile() ? fromStat.size : undefined,
+                            overwrite,
+                        },
+                    };
+                });
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                return errorResult(toolCallId, message);
+            }
+        },
+    };
+}
+//# sourceMappingURL=move.js.map

package/dist/mutation-path.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Resolve a mutation target under `root`. Symlink paths are kept as the link
+ * location (not followed). Non-symlink existing paths are realpath'd.
+ */
+export declare function resolveContainedMutationPath(root: string, inputPath: string, options?: {
+    allowMissing?: boolean;
+}): Promise<string>;

package/dist/mutation-path.js

@@ -0,0 +1,51 @@
+import { lstat, realpath } from "node:fs/promises";
+import { isAbsolute, relative, resolve } from "node:path";
+import { resolveToCwd } from "./path-utils.js";
+function isPathInsideRoot(root, target) {
+    const from = resolve(root);
+    const to = resolve(target);
+    if (to === from)
+        return true;
+    const rel = relative(from, to);
+    return rel !== "" && !rel.startsWith("..") && !isAbsolute(rel);
+}
+function isMissingPathError(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        (error.code === "ENOENT" || error.code === "ENOTDIR"));
+}
+/**
+ * Resolve a mutation target under `root`. Symlink paths are kept as the link
+ * location (not followed). Non-symlink existing paths are realpath'd.
+ */
+export async function resolveContainedMutationPath(root, inputPath, options) {
+    const rootResolved = resolve(root);
+    let rootReal;
+    try {
+        rootReal = await realpath(rootResolved);
+    }
+    catch {
+        throw new Error(`workspace root is missing or unreadable: ${rootResolved}`);
+    }
+    const candidate = resolveToCwd(inputPath, rootReal);
+    if (!isPathInsideRoot(rootReal, candidate)) {
+        throw new Error(`path escapes workspace root: ${inputPath}`);
+    }
+    try {
+        const st = await lstat(candidate);
+        if (st.isSymbolicLink())
+            return candidate;
+        const real = await realpath(candidate);
+        if (!isPathInsideRoot(rootReal, real)) {
+            throw new Error(`path resolves outside workspace root: ${inputPath}`);
+        }
+        return real;
+    }
+    catch (error) {
+        if (options?.allowMissing && isMissingPathError(error))
+            return candidate;
+        throw error;
+    }
+}
+//# sourceMappingURL=mutation-path.js.map

package/dist/output-accumulator.d.ts

@@ -46,6 +46,14 @@ export declare class OutputAccumulator {
     cleanupTempFile(): Promise<void>;
     getLastLineBytes(): number;
     getTotalRawBytes(): number;
+    /**
+     * Cursor-paged raw bytes for process sessions.
+     * Reads from spill file when present, otherwise from in-memory chunks.
+     */
+    readRaw(cursor: number, maxBytes: number): {
+        readonly data: Buffer;
+        readonly nextCursor: number;
+    };
     isOutputLimitExceeded(): boolean;
     hasStorageError(): boolean;
     private appendDecodedText;

package/dist/output-accumulator.js

@@ -1,6 +1,6 @@
 /** Streaming UTF-8 output retention with bounded memory and spill storage. */
 import { randomBytes } from "node:crypto";
-import { closeSync, openSync, writeSync } from "node:fs";
+import { closeSync, openSync, readSync, writeSync } from "node:fs";
 import { rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -144,6 +144,50 @@ export class OutputAccumulator {
     getTotalRawBytes() {
         return this.totalRawBytes;
     }
+    /**
+     * Cursor-paged raw bytes for process sessions.
+     * Reads from spill file when present, otherwise from in-memory chunks.
+     */
+    readRaw(cursor, maxBytes) {
+        if (!Number.isSafeInteger(cursor) || cursor < 0) {
+            throw new Error("cursor must be a non-negative safe integer");
+        }
+        if (!Number.isSafeInteger(maxBytes) || maxBytes < 1) {
+            throw new Error("maxBytes must be a positive safe integer");
+        }
+        const total = this.totalRawBytes;
+        if (cursor >= total)
+            return { data: Buffer.alloc(0), nextCursor: cursor };
+        const length = Math.min(maxBytes, total - cursor);
+        if (this.tempFilePath) {
+            const fd = openSync(this.tempFilePath, "r");
+            try {
+                const data = Buffer.alloc(length);
+                const n = readSync(fd, data, 0, length, cursor);
+                return { data: n === length ? data : data.subarray(0, n), nextCursor: cursor + n };
+            }
+            finally {
+                closeSync(fd);
+            }
+        }
+        const data = Buffer.alloc(length);
+        let offset = 0;
+        let skipped = 0;
+        for (const chunk of this.rawChunks) {
+            if (offset >= length)
+                break;
+            if (skipped + chunk.length <= cursor) {
+                skipped += chunk.length;
+                continue;
+            }
+            const start = Math.max(0, cursor - skipped);
+            const take = Math.min(chunk.length - start, length - offset);
+            chunk.copy(data, offset, start, start + take);
+            offset += take;
+            skipped += chunk.length;
+        }
+        return { data: offset === length ? data : data.subarray(0, offset), nextCursor: cursor + offset };
+    }
     isOutputLimitExceeded() {
         return this.exceeded;
     }

package/dist/path-utils.js

@@ -98,7 +98,7 @@ export function resolveReadPath(filePath, cwd) {
 }
 export async function resolveReadPathAsync(filePath, cwd) {
     const resolved = resolveToCwd(filePath, cwd);
-    if ((await pathExists(resolved)))
+    if (await pathExists(resolved))
         return resolved;
     const amPmVariant = tryMacOSScreenshotPath(resolved);
     if (amPmVariant !== resolved && (await pathExists(amPmVariant)))

package/dist/process/index.d.ts

@@ -0,0 +1,3 @@
+export type { CodingProcessEvent, CreateProcessSessionsOptions, ProcessExitResult, ProcessOutputChunk, ProcessSandboxBackend, ProcessSandboxHandle, ProcessSandboxStartRequest, ProcessSession, ProcessSessionLimits, ProcessSessionMetadata, ProcessSessions, ProcessSessionState, ProcessStartRequest, ResolvedProcessSessionLimits, } from "./types.js";
+export { ProcessSessionError, resolveProcessSessionLimits } from "./types.js";
+export { createProcessSessions } from "./sessions.js";

package/dist/process/index.js

@@ -0,0 +1,3 @@
+export { ProcessSessionError, resolveProcessSessionLimits } from "./types.js";
+export { createProcessSessions } from "./sessions.js";
+//# sourceMappingURL=index.js.map

package/dist/process/sessions.d.ts

@@ -0,0 +1,2 @@
+import { type CreateProcessSessionsOptions, type ProcessSessions } from "./types.js";
+export declare function createProcessSessions(options: CreateProcessSessionsOptions): ProcessSessions;