@arnilo/prism-tools 0.0.0-stage → 0.13.0

package/coding/src/agent/language/types.ts

@@ -0,0 +1,187 @@
+import {
+  DEFAULT_MAX_LSP_DIAGNOSTICS_PER_FILE,
+  DEFAULT_MAX_LSP_MESSAGE_BYTES,
+  DEFAULT_MAX_LSP_PENDING_REQUESTS,
+  DEFAULT_MAX_LSP_RESULTS_PER_QUERY,
+  DEFAULT_MAX_LSP_SERVERS,
+  DEFAULT_MAX_LSP_TIMEOUT_MS,
+  HARD_MAX_LSP_DIAGNOSTICS_PER_FILE,
+  HARD_MAX_LSP_MESSAGE_BYTES,
+  HARD_MAX_LSP_PENDING_REQUESTS,
+  HARD_MAX_LSP_RESULTS_PER_QUERY,
+  HARD_MAX_LSP_SERVERS,
+  HARD_MAX_LSP_TIMEOUT_MS,
+  LSP_RESTARTS_PER_SERVER,
+  validateCodingLimit,
+} from "../limits.js";
+
+import type { ExecutionPolicy } from "../execution-policy.js";
+export type LanguageIntelligenceErrorCode =
+  | "ERR_PRISM_LSP_FRAMING"
+  | "ERR_PRISM_LSP_SERVER"
+  | "ERR_PRISM_LSP_TIMEOUT"
+  | "ERR_PRISM_LSP_LIMIT"
+  | "ERR_PRISM_LSP_UNSUPPORTED"
+  | "ERR_PRISM_LSP_WORKSPACE";
+
+export class LanguageIntelligenceError extends Error {
+  readonly code: LanguageIntelligenceErrorCode;
+  constructor(code: LanguageIntelligenceErrorCode, message: string) {
+    super(message);
+    this.name = "LanguageIntelligenceError";
+    this.code = code;
+  }
+}
+
+/** Host allow-listed server command; never model-supplied. */
+export interface LanguageServerSpec {
+  readonly command: string;
+  readonly args?: readonly string[];
+  readonly languages: readonly string[];
+  readonly env?: Readonly<Record<string, string>>;
+}
+
+/** LSP 0-based position + workspace-relative file path. */
+export interface LanguageLocation {
+  readonly file: string;
+  readonly line: number;
+  readonly character: number;
+}
+
+export interface LanguageSymbol {
+  readonly name: string;
+  readonly kind: number;
+  readonly file: string;
+  readonly line: number;
+  readonly character: number;
+  readonly containerName?: string;
+}
+
+export interface LanguageDiagnostic {
+  readonly file: string;
+  readonly line: number;
+  readonly character: number;
+  readonly endLine: number;
+  readonly endCharacter: number;
+  readonly severity: "error" | "warning" | "info" | "hint";
+  readonly message: string;
+  readonly source?: string;
+  readonly code?: string | number;
+}
+
+export interface LanguageTextEdit {
+  readonly file: string;
+  readonly newText: string;
+  readonly range: {
+    readonly start: { readonly line: number; readonly character: number };
+    readonly end: { readonly line: number; readonly character: number };
+  };
+}
+
+export interface LanguageWorkspaceEdit {
+  readonly edits: readonly LanguageTextEdit[];
+}
+
+export interface LanguageIntelligenceLimits {
+  readonly maxMessageBytes?: number;
+  readonly maxDiagnosticsPerFile?: number;
+  readonly maxPendingRequests?: number;
+  readonly maxResultsPerQuery?: number;
+  readonly requestTimeoutMs?: number;
+  readonly maxServers?: number;
+  /** Cap restarts after unexpected exit (freeze: 3). */
+  readonly maxRestartsPerServer?: number;
+}
+
+export interface ResolvedLanguageIntelligenceLimits {
+  readonly maxMessageBytes: number;
+  readonly maxDiagnosticsPerFile: number;
+  readonly maxPendingRequests: number;
+  readonly maxResultsPerQuery: number;
+  readonly requestTimeoutMs: number;
+  readonly maxServers: number;
+  readonly maxRestartsPerServer: number;
+}
+
+export function resolveLanguageIntelligenceLimits(options?: LanguageIntelligenceLimits): ResolvedLanguageIntelligenceLimits {
+  return {
+    maxMessageBytes: validateCodingLimit(
+      "maxMessageBytes",
+      options?.maxMessageBytes ?? DEFAULT_MAX_LSP_MESSAGE_BYTES,
+      HARD_MAX_LSP_MESSAGE_BYTES,
+    ),
+    maxDiagnosticsPerFile: validateCodingLimit(
+      "maxDiagnosticsPerFile",
+      options?.maxDiagnosticsPerFile ?? DEFAULT_MAX_LSP_DIAGNOSTICS_PER_FILE,
+      HARD_MAX_LSP_DIAGNOSTICS_PER_FILE,
+    ),
+    maxPendingRequests: validateCodingLimit(
+      "maxPendingRequests",
+      options?.maxPendingRequests ?? DEFAULT_MAX_LSP_PENDING_REQUESTS,
+      HARD_MAX_LSP_PENDING_REQUESTS,
+    ),
+    maxResultsPerQuery: validateCodingLimit(
+      "maxResultsPerQuery",
+      options?.maxResultsPerQuery ?? DEFAULT_MAX_LSP_RESULTS_PER_QUERY,
+      HARD_MAX_LSP_RESULTS_PER_QUERY,
+    ),
+    requestTimeoutMs: validateCodingLimit(
+      "requestTimeoutMs",
+      options?.requestTimeoutMs ?? DEFAULT_MAX_LSP_TIMEOUT_MS,
+      HARD_MAX_LSP_TIMEOUT_MS,
+    ),
+    maxServers: validateCodingLimit("maxServers", options?.maxServers ?? DEFAULT_MAX_LSP_SERVERS, HARD_MAX_LSP_SERVERS),
+    maxRestartsPerServer: validateCodingLimit(
+      "maxRestartsPerServer",
+      options?.maxRestartsPerServer ?? LSP_RESTARTS_PER_SERVER,
+      LSP_RESTARTS_PER_SERVER,
+    ),
+  };
+}
+
+export interface LanguageIntelligence {
+  workspaceSymbols(query: string, opts?: { signal?: AbortSignal }): Promise<readonly LanguageSymbol[]>;
+  definitions(loc: LanguageLocation, opts?: { signal?: AbortSignal }): Promise<readonly LanguageLocation[]>;
+  references(loc: LanguageLocation, opts?: { signal?: AbortSignal }): Promise<readonly LanguageLocation[]>;
+  diagnostics(file?: string, opts?: { signal?: AbortSignal }): Promise<readonly LanguageDiagnostic[]>;
+  hover(loc: LanguageLocation, opts?: { signal?: AbortSignal }): Promise<{ text: string } | undefined>;
+  rename(loc: LanguageLocation & { newName: string }, opts?: { signal?: AbortSignal }): Promise<LanguageWorkspaceEdit>;
+  /**
+   * Re-sync one file after an external edit: full-content didChange with a
+   * monotonic version. No-op when no host server handles the file's language
+   * (throws ERR_PRISM_LSP_UNSUPPORTED only when servers exist but none match).
+   */
+  syncDocument(file: string, opts?: { signal?: AbortSignal }): Promise<{ version: number }>;
+  /**
+   * Bounded push/pull diagnostic refresh for changed files. Generations are
+   * document versions; stale-version results never overwrite newer views.
+   */
+  diagnosticDelta(request: LanguageDiagnosticDeltaRequest, opts?: { signal?: AbortSignal }): Promise<LanguageDiagnosticDeltaResult>;
+  dispose(): Promise<void>;
+}
+
+export interface LanguageDiagnosticDeltaRequest {
+  /** Workspace-relative files to refresh; bounded per request. */
+  readonly files: readonly string[];
+  /** Prior normalized view per file (generation + diagnostics); optional. */
+  readonly previous?: Readonly<Record<string, LanguageFileDiagnostics>>;
+}
+
+export interface LanguageFileDiagnostics {
+  readonly generation: number;
+  readonly diagnostics: readonly import("../diagnostics.js").NormalizedDiagnostic[];
+}
+
+export interface LanguageDiagnosticDeltaResult {
+  /** Per-file delta; stale files (previous generation >= new generation) are omitted. */
+  readonly files: Record<string, import("../diagnostics.js").DiagnosticDelta>;
+  readonly generation: number;
+}
+
+export interface CreateLanguageIntelligenceOptions {
+  readonly workspaceRoot: string;
+  readonly servers: Readonly<Record<string, LanguageServerSpec>>;
+  readonly limits?: LanguageIntelligenceLimits;
+  readonly policy?: ExecutionPolicy;
+  // processes?: ProcessSessions — available after Task 3; host may wire later.
+}

package/coding/src/agent/lifecycle-events.ts

@@ -0,0 +1,121 @@
+/**
+ * Consumer-gated coding lifecycle event vocabulary (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 — MUST NOT be added here
+ * until a consumer exists (scripts/phase10-freeze-manifest.json lifecycle.deferredEvents).
+ *
+ * Types only: no runtime code, so a tool that type-imports the event it emits does not pull the
+ * limits or the emitter (those live in `lifecycle.ts`, which re-exports this module).
+ */
+import type { AgentFinishReason, AgentRunStatus, RunLimitName } from "@arnilo/prism";
+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 interface PlanChangedEvent {
+  readonly type: "plan_changed";
+  /** Workspace-relative plan path; doubles as the plan id on the ACP wire. */
+  readonly planPath: string;
+  /** Complete todo list at this point (same shape as `CodingTodoItem`). */
+  readonly todos: readonly { readonly id: string; readonly text: string; readonly done: boolean }[];
+}
+
+export interface PlanRemovedEvent {
+  readonly type: "plan_removed";
+  /** Workspace-relative plan path; doubles as the plan id on the ACP wire. */
+  readonly planPath: string;
+}
+
+/** Redacted supervisor milestone. Never includes child input, output, or path. */
+export interface SubagentStartedEvent {
+  readonly type: "subagent_started";
+  readonly childId: string;
+  readonly delegationId: string;
+  readonly depth: number;
+}
+
+/**
+ * Redacted child failure attribution. Carried on `subagent_stopped` only when the observer opts into
+ * `includeFailure`, and only for the stop an error produced. Never carries child input, output, paths,
+ * tool arguments, or tool results.
+ */
+export interface SubagentFailure {
+  /** Supervisor-redacted terminal reason, truncated to `DEFAULT_LIFECYCLE_MAX_REASON_BYTES`. */
+  readonly reason: string;
+  /** Fired run-limit axis when the child died on a configured ceiling; counts only, no child text. */
+  readonly limit?: RunLimitName;
+  /** The child's own terminal stop reason, when the run reported one. */
+  readonly stopReason?: AgentFinishReason;
+}
+
+/** Local mirror of the supervisor's per-child outcome vocabulary (no core-supervisor type import). */
+export type SubagentRecoveryOutcome = "idle" | "running" | AgentRunStatus | "rejected";
+
+/**
+ * Per-child recovery counters read from `summary()` at stop. Carried on `subagent_stopped` only when
+ * the observer opts into `includeRecovery` and the source exposes `summary`; integers and enums only.
+ */
+export interface SubagentRecovery {
+  readonly attempts: number;
+  readonly retries: number;
+  readonly failures: number;
+  readonly failureRadius: number;
+  /** `idle` before the first delegation, `running` while one is live, else the terminal outcome. */
+  readonly outcome: SubagentRecoveryOutcome;
+}
+
+/** Terminal redacted supervisor milestone. */
+export interface SubagentStoppedEvent {
+  readonly type: "subagent_stopped";
+  readonly childId: string;
+  readonly delegationId: string;
+  readonly depth: number;
+  readonly status: AgentRunStatus;
+  /** Present only when the observer's `includeFailure` is on and the stop followed a `child_failed`. */
+  readonly failure?: SubagentFailure;
+  /** Present only when the observer's `includeRecovery` is on and the source exposes `summary`. */
+  readonly recovery?: SubagentRecovery;
+}
+
+export type CodingLifecycleEvent =
+  | CodingProcessEvent
+  | FileChangedEvent
+  | WorktreeChangedEvent
+  | PermissionDeniedEvent
+  | ConfigurationChangedEvent
+  | PlanChangedEvent
+  | PlanRemovedEvent
+  | SubagentStartedEvent
+  | SubagentStoppedEvent;

package/coding/src/agent/lifecycle.ts

@@ -0,0 +1,166 @@
+/**
+ * Coding lifecycle limits and the consumer-gated emitter (Phase 10 Task 1 freeze).
+ *
+ * The event vocabulary itself is `./lifecycle-events.js`; this module owns the byte/count caps and
+ * the emitter that enforces them, and re-exports the vocabulary so existing imports keep working.
+ */
+import type { CodingLifecycleEvent } from "./lifecycle-events.js";
+import { validateCodingLimit } from "./limits.js";
+
+export type {
+  CodingLifecycleEvent,
+  ConfigurationChangedEvent,
+  FileChangedEvent,
+  FileChangeOp,
+  PermissionDeniedEvent,
+  PlanChangedEvent,
+  PlanRemovedEvent,
+  SubagentFailure,
+  SubagentRecovery,
+  SubagentRecoveryOutcome,
+  SubagentStartedEvent,
+  SubagentStoppedEvent,
+  WorktreeChangedEvent,
+} from "./lifecycle-events.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 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 class CodingLifecycleError extends Error {
+  readonly code = "ERR_PRISM_LIFECYCLE_LIMIT";
+  constructor(message: string) {
+    super(message);
+    this.name = "CodingLifecycleError";
+  }
+}
+
+function validate(name: string, value: number, hard: number): number {
+  try {
+    return validateCodingLimit(name, value, hard);
+  } catch (error) {
+    throw new CodingLifecycleError(error instanceof Error ? error.message : String(error));
+  }
+}
+
+export function resolveCodingLifecycleLimits(limits?: CodingLifecycleLimits): ResolvedCodingLifecycleLimits {
+  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 supported coding lifecycle kinds. */
+const FROZEN_EVENT_TYPES = new Set<string>([
+  "process_started",
+  "process_exited",
+  "process_killed",
+  "process_released",
+  "process_expired",
+  "process_unknown",
+  "file_changed",
+  "worktree_changed",
+  "permission_denied",
+  "configuration_changed",
+  "plan_changed",
+  "plan_removed",
+  "subagent_started",
+  "subagent_stopped",
+]);
+
+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 function createCodingLifecycleEmitter(options: CreateCodingLifecycleEmitterOptions = {}): CodingLifecycleEmitter {
+  const limits = resolveCodingLifecycleLimits(options.limits);
+  const listeners = new Set<(event: CodingLifecycleEvent) => void>();
+  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]) {
+        // A consumer that throws must not break the producer's success path (a worktree or file is
+        // already changed by the time we get here); the rest of the listeners still receive it.
+        try {
+          listener(event);
+        } catch {
+          // swallowed on purpose: telemetry never fails the operation that produced it
+        }
+      }
+      return true;
+    },
+    on(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+  };
+}

package/coding/src/agent/limits.ts

@@ -0,0 +1,214 @@
+export const DEFAULT_MAX_LINES = 2_000;
+export const HARD_MAX_LINES = 100_000;
+export const DEFAULT_MAX_BYTES = 50 * 1024;
+export const HARD_MAX_BYTES = 1024 * 1024;
+
+export const DEFAULT_MAX_TEXT_SCAN_BYTES = 64 * 1024 * 1024;
+export const HARD_MAX_TEXT_SCAN_BYTES = 1024 * 1024 * 1024;
+export const DEFAULT_MAX_IMAGE_BYTES = 10_000_000;
+export const HARD_MAX_IMAGE_BYTES = 32 * 1024 * 1024;
+
+export const DEFAULT_MAX_WRITE_BYTES = 8 * 1024 * 1024;
+export const HARD_MAX_WRITE_BYTES = 64 * 1024 * 1024;
+export const DEFAULT_MAX_EDIT_FILE_BYTES = 8 * 1024 * 1024;
+export const HARD_MAX_EDIT_FILE_BYTES = 64 * 1024 * 1024;
+export const DEFAULT_MAX_EDIT_INPUT_BYTES = 2 * 1024 * 1024;
+export const HARD_MAX_EDIT_INPUT_BYTES = 16 * 1024 * 1024;
+export const DEFAULT_MAX_EDITS = 100;
+export const HARD_MAX_EDITS = 1_000;
+
+export const DEFAULT_SHELL_TIMEOUT_SECONDS = 600;
+export const HARD_SHELL_TIMEOUT_SECONDS = 3_600;
+export const DEFAULT_MAX_TOTAL_OUTPUT_BYTES = 64 * 1024 * 1024;
+export const HARD_MAX_TOTAL_OUTPUT_BYTES = 1024 * 1024 * 1024;
+
+/** Repository list/search defaults and hard caps (Phase 4 / review-coverage). */
+export const DEFAULT_MAX_REPO_DEPTH = 32;
+export const HARD_MAX_REPO_DEPTH = 128;
+export const DEFAULT_MAX_REPO_ENTRIES = 10_000;
+export const HARD_MAX_REPO_ENTRIES = 100_000;
+export const DEFAULT_MAX_REPO_FILES = 10_000;
+export const HARD_MAX_REPO_FILES = 100_000;
+export const DEFAULT_MAX_REPO_RESULTS = 1_000;
+export const HARD_MAX_REPO_RESULTS = 10_000;
+export const DEFAULT_MAX_REPO_CONCURRENCY = 8;
+export const HARD_MAX_REPO_CONCURRENCY = 32;
+
+export const DEFAULT_MAX_SEARCH_SCAN_BYTES = 64 * 1024 * 1024;
+export const HARD_MAX_SEARCH_SCAN_BYTES = 1024 * 1024 * 1024;
+export const DEFAULT_MAX_SEARCH_FILE_BYTES = 8 * 1024 * 1024;
+export const HARD_MAX_SEARCH_FILE_BYTES = 64 * 1024 * 1024;
+export const DEFAULT_MAX_SEARCH_MATCHES = 1_000;
+export const HARD_MAX_SEARCH_MATCHES = 10_000;
+export const DEFAULT_MAX_SEARCH_PATTERN_BYTES = 512;
+export const HARD_MAX_SEARCH_PATTERN_BYTES = 4_096;
+export const DEFAULT_MAX_SEARCH_LINE_BYTES = 50 * 1024;
+export const HARD_MAX_SEARCH_LINE_BYTES = 1024 * 1024;
+export const DEFAULT_MAX_SEARCH_CONTEXT_LINES = 5;
+export const HARD_MAX_SEARCH_CONTEXT_LINES = 20;
+export const DEFAULT_MAX_SEARCH_TIME_MS = 30_000;
+export const HARD_MAX_SEARCH_TIME_MS = 300_000;
+export const DEFAULT_BINARY_SNIFF_BYTES = 8_192;
+
+/** Structured Git / named-check / PR-handoff defaults and hard caps (Phase 4). */
+export const DEFAULT_MAX_GIT_PATHS = 1_000;
+export const HARD_MAX_GIT_PATHS = 10_000;
+export const DEFAULT_MAX_GIT_REF_BYTES = 1_024;
+export const HARD_MAX_GIT_REF_BYTES = 4_096;
+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;
+export const HARD_MAX_GIT_CHANGED_FILES = 10_000;
+export const DEFAULT_MAX_GIT_PATCH_BYTES = 16 * 1024 * 1024;
+export const HARD_MAX_GIT_PATCH_BYTES = 64 * 1024 * 1024;
+export const DEFAULT_MAX_GIT_WORKTREES = 4;
+export const HARD_MAX_GIT_WORKTREES = 16;
+export const DEFAULT_GIT_TIMEOUT_MS = 120_000;
+export const HARD_GIT_TIMEOUT_MS = 600_000;
+
+export const DEFAULT_MAX_CHECK_NAMES = 8;
+export const HARD_MAX_CHECK_NAMES = 32;
+export const DEFAULT_MAX_CHECK_CONCURRENCY = 1;
+export const HARD_MAX_CHECK_CONCURRENCY = 4;
+export const DEFAULT_CHECK_TIMEOUT_MS = 10 * 60_000;
+export const HARD_CHECK_TIMEOUT_MS = 60 * 60_000;
+export const DEFAULT_MAX_CHECK_DIAGNOSTIC_LINES = 2_000;
+export const HARD_MAX_CHECK_DIAGNOSTIC_LINES = 100_000;
+export const DEFAULT_MAX_CHECK_OUTPUT_BYTES = 4 * 1024 * 1024;
+export const HARD_MAX_CHECK_OUTPUT_BYTES = 64 * 1024 * 1024;
+
+export const DEFAULT_MAX_PR_HANDOFF_BYTES = 256 * 1024;
+export const HARD_MAX_PR_HANDOFF_BYTES = 1024 * 1024;
+export const DEFAULT_MAX_PR_COMMITS = 100;
+export const HARD_MAX_PR_COMMITS = 1_000;
+
+/** Durable coding plan / checkpoint metadata defaults and hard caps (Phase 4 Task 4). */
+export const DEFAULT_MAX_PLAN_BYTES = 256 * 1024;
+export const HARD_MAX_PLAN_BYTES = 1024 * 1024;
+export const DEFAULT_MAX_TODOS = 1_000;
+export const HARD_MAX_TODOS = 10_000;
+export const DEFAULT_MAX_TODO_TEXT_BYTES = 512;
+export const HARD_MAX_TODO_TEXT_BYTES = 4_096;
+export const DEFAULT_MAX_CODING_ARTIFACTS = 16;
+export const HARD_MAX_CODING_ARTIFACTS = 64;
+export const DEFAULT_MAX_CODING_ARTIFACT_BYTES = 256 * 1024 * 1024;
+export const HARD_MAX_CODING_ARTIFACT_BYTES = 2 * 1024 * 1024 * 1024;
+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;
+
+/** Phase 26 Task 0 freeze: host-selected PTY terminal caps (interactive sessions). */
+export const DEFAULT_MAX_TERMINAL_COLUMNS = 120;
+export const HARD_MAX_TERMINAL_COLUMNS = 500;
+export const DEFAULT_MAX_TERMINAL_ROWS = 40;
+export const HARD_MAX_TERMINAL_ROWS = 200;
+export const DEFAULT_MAX_TERMINAL_TERM_BYTES = 64;
+export const HARD_MAX_TERMINAL_TERM_BYTES = 256;
+export const DEFAULT_MAX_TERMINAL_RESIZES_PER_MINUTE = 60;
+export const HARD_MAX_TERMINAL_RESIZES_PER_MINUTE = 600;
+export const DEFAULT_MAX_PTY_ATTACH_TIMEOUT_MS = 30_000;
+export const HARD_MAX_PTY_ATTACH_TIMEOUT_MS = 120_000;
+export const DEFAULT_MAX_PTY_BACKEND_METADATA_BYTES = 4 * 1024;
+export const HARD_MAX_PTY_BACKEND_METADATA_BYTES = 16 * 1024;
+
+/** Phase 26 Task 0 freeze: host index caps (indexed_literal/semantic grep). */
+export const DEFAULT_MAX_INDEX_UPDATE_FILES = 1_000;
+export const HARD_MAX_INDEX_UPDATE_FILES = 10_000;
+export const DEFAULT_MAX_INDEX_UPDATE_BYTES = 16 * 1024 * 1024;
+export const HARD_MAX_INDEX_UPDATE_BYTES = 64 * 1024 * 1024;
+/** Index result cap reuses the repository results caps (1000 / 10000). */
+export const DEFAULT_MAX_INDEX_SNIPPET_BYTES = 4 * 1024;
+export const HARD_MAX_INDEX_SNIPPET_BYTES = 16 * 1024;
+export const DEFAULT_MAX_INDEX_STALE_MAX_AGE_MS = 60_000;
+export const HARD_MAX_INDEX_STALE_MAX_AGE_MS = 300_000;
+export const DEFAULT_MAX_INDEX_QUERY_TIMEOUT_MS = 30_000;
+export const HARD_MAX_INDEX_QUERY_TIMEOUT_MS = 120_000;
+
+/** Diagnostic caps shared by `coding_check` deltas and the `diagnostics` tool. */
+export const DEFAULT_MAX_REVIEW_DIAGNOSTICS = 500;
+export const HARD_MAX_REVIEW_DIAGNOSTICS = 5_000;
+export const DEFAULT_MAX_DIAGNOSTIC_MESSAGE_BYTES = 4 * 1024;
+export const HARD_MAX_DIAGNOSTIC_MESSAGE_BYTES = 16 * 1024;
+
+/** 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;
+
+/** Plan 165 Task 6: `workspace.diff` bounds (files listed, bytes of one file's diff). */
+export const DEFAULT_MAX_WORKSPACE_DIFF_FILES = 200;
+export const HARD_MAX_WORKSPACE_DIFF_FILES = 2_000;
+export const DEFAULT_MAX_WORKSPACE_DIFF_BYTES = 1024 * 1024;
+export const HARD_MAX_WORKSPACE_DIFF_BYTES = 8 * 1024 * 1024;
+
+/** Plan 026 Task 5: durable process/ACP recovery caps (frozen in the phase26 manifest). */
+export const DEFAULT_MAX_RECOVERY_RECORDS = 32;
+export const HARD_MAX_RECOVERY_RECORDS = 128;
+export const DEFAULT_MAX_RECOVERY_LEASE_TTL_MS = 30_000;
+export const HARD_MAX_RECOVERY_LEASE_TTL_MS = 300_000;
+export const DEFAULT_MAX_RECOVERY_ATTACH_TIMEOUT_MS = 30_000;
+export const HARD_MAX_RECOVERY_ATTACH_TIMEOUT_MS = 120_000;
+export const DEFAULT_MAX_RECOVERY_BACKEND_REF_BYTES = 1024;
+export const HARD_MAX_RECOVERY_BACKEND_REF_BYTES = 4 * 1024;
+export const DEFAULT_MAX_RECOVERY_RECORD_BYTES = 64 * 1024;
+export const HARD_MAX_RECOVERY_RECORD_BYTES = 256 * 1024;
+
+/** Validate one configurable coding resource limit. Invalid values fail instead of clamping. */
+export function validateCodingLimit(name: string, value: number, hardCap: number): number {
+  if (!Number.isSafeInteger(value) || value < 1 || value > hardCap) {
+    throw new Error(`${name} must be a positive safe integer at most ${hardCap}`);
+  }
+  return value;
+}
+
+/** Validate a non-negative integer limit (0 allowed), still capped. */
+export function validateCodingLimitAllowZero(name: string, value: number, hardCap: number): number {
+  if (!Number.isSafeInteger(value) || value < 0 || value > hardCap) {
+    throw new Error(`${name} must be a non-negative safe integer at most ${hardCap}`);
+  }
+  return value;
+}