@arnilo/prism-coding-agent 0.0.25 → 0.0.27

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/move.d.ts

@@ -1,5 +1,6 @@
 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;
@@ -17,5 +18,7 @@ export interface MoveOperations {
 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

@@ -79,7 +79,7 @@ export function createMoveTool(cwd, options) {
                     paths: [fromPath, toPath],
                     risk: "high",
                     metadata: { overwrite, sessionId: context.sessionId, runId: context.runId, signal: context.signal },
-                }, toolCallId, "move");
+                }, toolCallId, "move", (denied) => options?.onEvent?.({ type: "permission_denied", ...denied }));
                 if (!policyCheck.allowed)
                     return policyCheck.result;
                 const allowedFrom = policyCheck.action.paths?.[0] ?? fromPath;
@@ -126,6 +126,7 @@ export function createMoveTool(cwd, options) {
                     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",

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/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;