@wrongstack/core 0.313.0 → 0.316.1

package/dist/chronicle/sink.d.ts

@@ -8,6 +8,19 @@ import type { ChronicleEvent, ChronicleEventInput } from './types.js';
  */
 export interface ChronicleEventSink {
     append(input: ChronicleEventInput): Promise<ChronicleEvent>;
+    /**
+     * Append many events as ONE unit of work. Optional: adapters that emit a
+     * single event per call have nothing to gain, and leaving it optional keeps
+     * every existing sink (and test double) valid without a shim.
+     *
+     * The SQLite journal wraps each append in `BEGIN IMMEDIATE` and, at
+     * `synchronous = FULL`, fsyncs on commit. Callers that produce a burst —
+     * the file observer reconciling a branch switch, say — turn N transactions
+     * and N fsyncs into one by routing through here. SQLite's binding is
+     * synchronous, so `Promise.all` over N `append()` calls does NOT overlap
+     * them; batching is the only thing that actually helps.
+     */
+    appendBatch?(inputs: readonly ChronicleEventInput[]): Promise<ChronicleEvent[]>;
     flush(): Promise<void>;
     stats(): ChronicleJournalStats;
 }

package/dist/chronicle/sqlite-journal.d.ts

@@ -1,9 +1,9 @@
 import type { ChronicleJournalStats, ChroniclePurgeResult } from './journal.js';
 import { ChronicleStorageQuotaError } from './sqlite-journal-quota.js';
-import { CHRONICLE_SQLITE_FILE, LEGACY_JSONL_BOUNDARY_KEY, LEGACY_JSONL_MIGRATION_KEY, LEGACY_JSONL_QUARANTINE_KEY } from './sqlite-journal-schema.js';
+import { CHRONICLE_SQLITE_FILE, LEGACY_JSONL_BOUNDARY_KEY, LEGACY_JSONL_MIGRATION_KEY } from './sqlite-journal-schema.js';
 import { ChronicleSqliteQueryEngine, type ChronicleSqliteQueryEngineOptions } from './sqlite-query.js';
 import { type ChronicleEvent, type ChronicleEventInput, type ChronicleVerifyResult } from './types.js';
-export { CHRONICLE_SQLITE_FILE, ChronicleStorageQuotaError, LEGACY_JSONL_BOUNDARY_KEY, LEGACY_JSONL_MIGRATION_KEY, LEGACY_JSONL_QUARANTINE_KEY, };
+export { CHRONICLE_SQLITE_FILE, ChronicleStorageQuotaError, LEGACY_JSONL_BOUNDARY_KEY, LEGACY_JSONL_MIGRATION_KEY };
 export interface ChronicleSqliteJournalOptions {
     /** Directory holding the journal, i.e. `<projectDir>/chronicle`. */
     directory: string;
@@ -17,6 +17,24 @@ export interface ChronicleSqliteJournalOptions {
     /** Aggregate SQLite allocation ceiling across the database, WAL, and SHM files. */
     maxBytes?: number | undefined;
     retentionCheckIntervalMs?: number | undefined;
+    /**
+     * WAL durability level. Defaults to `'normal'`.
+     *
+     * In WAL mode `NORMAL` still survives a **process** crash — an aborted
+     * agent, an OOM kill, a `taskkill` — because the WAL is already written;
+     * only an OS crash or power loss can cost the last commits. `FULL` adds an
+     * fsync to every commit to close that last gap.
+     *
+     * This journal is the highest-volume writer in the runtime (measured at
+     * ~7.2GB over 7 days), so that per-commit fsync was the single largest
+     * source of disk I/O in the system — paid continuously, for telemetry that
+     * is reconstructible from the session logs. Every other SQLite store here
+     * (mailbox, kanban, techstack, vector-memory) runs `NORMAL`.
+     *
+     * Set `'full'` when the deployment genuinely needs power-loss durability
+     * for the audit trail.
+     */
+    durability?: 'normal' | 'full' | undefined;
 }
 export interface ChronicleSqlitePurgeOptions {
     retentionDays: number;

package/dist/chunk-25LSLC3G.js

@@ -0,0 +1,334 @@
+import {
+  toErrorMessage
+} from "./chunk-TBRL2RCC.js";
+
+// src/types/errors.ts
+var ERROR_CODES = {
+  // Provider
+  PROVIDER_RATE_LIMITED: "PROVIDER_RATE_LIMITED",
+  PROVIDER_AUTH_FAILED: "PROVIDER_AUTH_FAILED",
+  PROVIDER_OVERLOADED: "PROVIDER_OVERLOADED",
+  PROVIDER_INVALID_REQUEST: "PROVIDER_INVALID_REQUEST",
+  PROVIDER_SERVER_ERROR: "PROVIDER_SERVER_ERROR",
+  PROVIDER_NETWORK_ERROR: "PROVIDER_NETWORK_ERROR",
+  PROVIDER_CONTEXT_OVERFLOW: "PROVIDER_CONTEXT_OVERFLOW",
+  // Tool
+  TOOL_NOT_FOUND: "TOOL_NOT_FOUND",
+  TOOL_PERMISSION_DENIED: "TOOL_PERMISSION_DENIED",
+  TOOL_EXECUTION_FAILED: "TOOL_EXECUTION_FAILED",
+  TOOL_TIMEOUT: "TOOL_TIMEOUT",
+  TOOL_INPUT_INVALID: "TOOL_INPUT_INVALID",
+  // Config
+  CONFIG_INVALID: "CONFIG_INVALID",
+  CONFIG_NOT_FOUND: "CONFIG_NOT_FOUND",
+  CONFIG_PARSE_FAILED: "CONFIG_PARSE_FAILED",
+  CONFIG_MIGRATION_NEEDED: "CONFIG_MIGRATION_NEEDED",
+  // Plugin
+  PLUGIN_LOAD_FAILED: "PLUGIN_LOAD_FAILED",
+  PLUGIN_API_MISMATCH: "PLUGIN_API_MISMATCH",
+  PLUGIN_MISSING_DEPENDENCY: "PLUGIN_MISSING_DEPENDENCY",
+  // Agent
+  AGENT_ITERATION_LIMIT: "AGENT_ITERATION_LIMIT",
+  AGENT_CONTEXT_OVERFLOW: "AGENT_CONTEXT_OVERFLOW",
+  AGENT_ABORTED: "AGENT_ABORTED",
+  AGENT_RUN_FAILED: "AGENT_RUN_FAILED",
+  // Session
+  SESSION_NOT_FOUND: "SESSION_NOT_FOUND",
+  SESSION_CORRUPTED: "SESSION_CORRUPTED",
+  SESSION_WRITE_FAILED: "SESSION_WRITE_FAILED",
+  SESSION_ID_REQUIRED: "SESSION_ID_REQUIRED",
+  // Container / Registry
+  CONTAINER_TOKEN_ALREADY_BOUND: "CONTAINER_TOKEN_ALREADY_BOUND",
+  CONTAINER_TOKEN_NOT_BOUND: "CONTAINER_TOKEN_NOT_BOUND",
+  CONTAINER_CIRCULAR_DEPENDENCY: "CONTAINER_CIRCULAR_DEPENDENCY",
+  REGISTRY_DUPLICATE: "REGISTRY_DUPLICATE",
+  REGISTRY_NOT_FOUND: "REGISTRY_NOT_FOUND",
+  REGISTRY_INVALID: "REGISTRY_INVALID",
+  // File system
+  FS_READ_FAILED: "FS_READ_FAILED",
+  FS_WRITE_FAILED: "FS_WRITE_FAILED",
+  FS_MKDIR_FAILED: "FS_MKDIR_FAILED",
+  FS_DELETE_FAILED: "FS_DELETE_FAILED",
+  FS_ATOMIC_WRITE_FAILED: "FS_ATOMIC_WRITE_FAILED",
+  // SDD (Spec-Driven Development)
+  SDD_VALIDATION_FAILED: "SDD_VALIDATION_FAILED",
+  SDD_PARSE_FAILED: "SDD_PARSE_FAILED",
+  SDD_INVALID_STATE: "SDD_INVALID_STATE",
+  SDD_NOT_READY: "SDD_NOT_READY",
+  // General
+  VALIDATION_ERROR: "VALIDATION_ERROR",
+  PARSE_FAILED: "PARSE_FAILED",
+  UNKNOWN: "UNKNOWN"
+};
+var WrongStackError = class _WrongStackError extends Error {
+  code;
+  subsystem;
+  severity;
+  recoverable;
+  context;
+  constructor(opts) {
+    super(opts.message, { cause: opts.cause });
+    this.name = "WrongStackError";
+    this.code = opts.code;
+    this.subsystem = opts.subsystem;
+    this.severity = opts.severity ?? "error";
+    this.recoverable = opts.recoverable ?? false;
+    this.context = opts.context;
+  }
+  /**
+   * Duck-type guard mirroring {@link ProviderError.isProviderError}.
+   *
+   * `instanceof WrongStackError` is NOT reliable inside this monorepo: the
+   * package builder emits every `@wrongstack/core` subpath (`core`, `types`,
+   * `coordination`, `execution`, `extension`, …) as an independent esbuild
+   * bundle with `splitting: false`, so each entry inlines its OWN copy of this
+   * class. An error constructed by `@wrongstack/providers` (which imports from
+   * `@wrongstack/core/types`) therefore fails `instanceof` against the copy
+   * baked into `@wrongstack/core/core` — which is where the agent loop and the
+   * provider runner live.
+   *
+   * That mismatch silently downgraded every provider failure to a generic
+   * `AgentError` in {@link toWrongStackError}, stripping `kind` / `status` /
+   * `body` and blinding the fallback engine and the provider waiting room.
+   * Use this guard anywhere the error may have crossed a subpath boundary.
+   */
+  static isWrongStackError(err) {
+    if (err instanceof _WrongStackError) return true;
+    if (!err || typeof err !== "object") return false;
+    const e = err;
+    return typeof e["name"] === "string" && e["name"].endsWith("Error") && typeof e["code"] === "string" && typeof e["subsystem"] === "string" && typeof e["severity"] === "string" && typeof e["describe"] === "function";
+  }
+  /**
+   * Render a one-line user-facing description.
+   * Subclasses should override for domain-specific formatting.
+   */
+  describe() {
+    const ctx = this.context ? ` ${formatContext(this.context)}` : "";
+    return `${this.code}: ${this.message}${ctx}`;
+  }
+};
+function formatContext(ctx) {
+  const parts = Object.entries(ctx).filter(([, v]) => v !== void 0).slice(0, 3).map(([k, v]) => `${k}=${String(v)}`);
+  return parts.length > 0 ? `[${parts.join(" ")}]` : "";
+}
+var ToolError = class extends WrongStackError {
+  toolName;
+  constructor(opts) {
+    super({
+      message: opts.message,
+      code: opts.code,
+      subsystem: "tool",
+      recoverable: opts.recoverable,
+      context: { tool: opts.toolName, ...opts.context },
+      cause: opts.cause
+    });
+    this.name = "ToolError";
+    this.toolName = opts.toolName;
+  }
+};
+var ConfigError = class extends WrongStackError {
+  constructor(opts) {
+    super({
+      message: opts.message,
+      code: opts.code,
+      subsystem: "config",
+      severity: "fatal",
+      recoverable: false,
+      context: opts.context,
+      cause: opts.cause
+    });
+    this.name = "ConfigError";
+  }
+};
+var PluginError = class extends WrongStackError {
+  pluginName;
+  constructor(opts) {
+    super({
+      message: opts.message,
+      code: opts.code,
+      subsystem: "plugin",
+      severity: "error",
+      recoverable: opts.code === ERROR_CODES.PLUGIN_MISSING_DEPENDENCY,
+      context: { plugin: opts.pluginName, ...opts.context },
+      cause: opts.cause
+    });
+    this.name = "PluginError";
+    this.pluginName = opts.pluginName;
+  }
+};
+var AgentError = class extends WrongStackError {
+  constructor(opts) {
+    super({
+      message: opts.message,
+      code: opts.code,
+      subsystem: "agent",
+      severity: opts.code === ERROR_CODES.AGENT_ABORTED ? "warning" : "error",
+      recoverable: opts.recoverable ?? opts.code === ERROR_CODES.AGENT_ITERATION_LIMIT,
+      context: opts.context,
+      cause: opts.cause
+    });
+    this.name = "AgentError";
+  }
+};
+function toWrongStackError(err, code = ERROR_CODES.AGENT_RUN_FAILED) {
+  if (WrongStackError.isWrongStackError(err)) return err;
+  const message = toErrorMessage(err);
+  return new AgentError({
+    message,
+    code: code === "UNKNOWN" ? ERROR_CODES.AGENT_RUN_FAILED : code,
+    cause: err
+  });
+}
+var SessionError = class extends WrongStackError {
+  sessionId;
+  constructor(opts) {
+    super({
+      message: opts.message,
+      code: opts.code,
+      subsystem: "session",
+      severity: opts.code === ERROR_CODES.SESSION_WRITE_FAILED ? "error" : "warning",
+      recoverable: opts.code !== ERROR_CODES.SESSION_CORRUPTED,
+      context: { sessionId: opts.sessionId, ...opts.context },
+      cause: opts.cause
+    });
+    this.name = "SessionError";
+    this.sessionId = opts.sessionId;
+  }
+};
+var SddError = class extends WrongStackError {
+  constructor(opts) {
+    super({
+      message: opts.message,
+      code: opts.code,
+      subsystem: "sdd",
+      severity: opts.code === ERROR_CODES.SDD_PARSE_FAILED ? "warning" : "error",
+      recoverable: opts.code === ERROR_CODES.SDD_NOT_READY,
+      context: opts.context,
+      cause: opts.cause
+    });
+    this.name = "SddError";
+  }
+};
+var FsError = class extends WrongStackError {
+  path;
+  constructor(opts) {
+    super({
+      message: opts.message,
+      code: opts.code,
+      subsystem: "fs",
+      severity: "error",
+      recoverable: opts.code !== ERROR_CODES.FS_READ_FAILED,
+      context: { path: opts.path, ...opts.context },
+      cause: opts.cause
+    });
+    this.name = "FsError";
+    this.path = opts.path;
+  }
+};
+var FetchError = class extends WrongStackError {
+  status;
+  constructor(opts) {
+    super({
+      message: opts.message,
+      code: ERROR_CODES.VALIDATION_ERROR,
+      subsystem: "general",
+      severity: "error",
+      recoverable: opts.status === 429 || opts.status >= 500,
+      context: { status: opts.status, ...opts.context },
+      cause: opts.cause
+    });
+    this.name = "FetchError";
+    this.status = opts.status;
+  }
+};
+var ToolValidationError = class extends WrongStackError {
+  constructor(opts) {
+    super({
+      message: opts.message,
+      code: ERROR_CODES.VALIDATION_ERROR,
+      subsystem: "general",
+      severity: "error",
+      recoverable: false,
+      context: { field: opts.field, ...opts.context },
+      cause: opts.cause
+    });
+    this.name = "ToolValidationError";
+  }
+};
+var ParseError = class extends WrongStackError {
+  source;
+  constructor(opts) {
+    super({
+      message: opts.message,
+      code: ERROR_CODES.PARSE_FAILED,
+      subsystem: "general",
+      severity: "error",
+      recoverable: false,
+      context: { source: opts.source, ...opts.context },
+      cause: opts.cause
+    });
+    this.name = "ParseError";
+    this.source = opts.source;
+  }
+};
+function isWrongStackError(err) {
+  return err instanceof WrongStackError;
+}
+function isToolError(err) {
+  return err instanceof ToolError;
+}
+function isConfigError(err) {
+  return err instanceof ConfigError;
+}
+function isPluginError(err) {
+  return err instanceof PluginError;
+}
+function isSessionError(err) {
+  return err instanceof SessionError;
+}
+function isAgentError(err) {
+  return err instanceof AgentError;
+}
+function isFsError(err) {
+  return err instanceof FsError;
+}
+function isToolValidationError(err) {
+  return err instanceof ToolValidationError;
+}
+function isFetchError(err) {
+  return err instanceof FetchError;
+}
+function isParseError(err) {
+  return err instanceof ParseError;
+}
+function isSddError(err) {
+  return err instanceof SddError;
+}
+
+export {
+  ERROR_CODES,
+  WrongStackError,
+  ToolError,
+  ConfigError,
+  PluginError,
+  AgentError,
+  toWrongStackError,
+  SessionError,
+  SddError,
+  FsError,
+  FetchError,
+  ToolValidationError,
+  ParseError,
+  isWrongStackError,
+  isToolError,
+  isConfigError,
+  isPluginError,
+  isSessionError,
+  isAgentError,
+  isFsError,
+  isToolValidationError,
+  isFetchError,
+  isParseError,
+  isSddError
+};
+//# sourceMappingURL=chunk-25LSLC3G.js.map