aisnitch 0.2.19 → 0.2.21

package/dist/index.js

@@ -119,6 +119,399 @@ function sanitizeToken(value) {
 import { homedir } from "os";
 import { z as z2 } from "zod";
 
+// src/core/errors.ts
+var AISnitchError = class _AISnitchError extends Error {
+  /**
+   * Machine-readable error code for programmatic handling.
+   * Format: `SUBCATEGORY_SPECIFIC_DETAIL` (uppercase with underscores).
+   */
+  code;
+  /**
+   * Arbitrary context bag forwarded to the logger for structured debugging.
+   */
+  context;
+  constructor(message, code, context) {
+    super(message);
+    this.name = "AISnitchError";
+    this.code = code;
+    this.context = context;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _AISnitchError);
+    }
+  }
+  /**
+   * Full error chain for logging: `[name] code — message`.
+   */
+  toString() {
+    return `${this.name} [${this.code}] \u2014 ${this.message}`;
+  }
+  /**
+   * JSON serialization friendly to pino serializers.
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      context: this.context,
+      stack: this.stack
+    };
+  }
+};
+var AdapterError = class _AdapterError extends AISnitchError {
+  constructor(message, code, context) {
+    super(message, code, context);
+    this.name = "AdapterError";
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _AdapterError);
+    }
+  }
+  /**
+   * Factory for adapter-specific errors with auto-generated codes.
+   */
+  static withAutoCode(message, tool, context) {
+    const sanitizedTool = tool.replace(/[^a-z0-9]/gi, "_").toUpperCase();
+    const code = `ADAPTER_${sanitizedTool}_ERROR`;
+    return new _AdapterError(message, code, { tool, ...context });
+  }
+};
+var PipelineError = class _PipelineError extends AISnitchError {
+  constructor(message, code, context) {
+    super(message, code, context);
+    this.name = "PipelineError";
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _PipelineError);
+    }
+  }
+};
+var ValidationError = class _ValidationError extends AISnitchError {
+  constructor(message, code, context) {
+    super(message, code, context);
+    this.name = "ValidationError";
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _ValidationError);
+    }
+  }
+};
+var NetworkError = class _NetworkError extends AISnitchError {
+  constructor(message, code, context) {
+    super(message, code, context);
+    this.name = "NetworkError";
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _NetworkError);
+    }
+  }
+};
+var TimeoutError = class _TimeoutError extends AISnitchError {
+  constructor(message, code, context) {
+    super(message, code, context);
+    this.name = "TimeoutError";
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _TimeoutError);
+    }
+  }
+};
+function isAISnitchError(error) {
+  return error instanceof AISnitchError;
+}
+function isRetryableError(error) {
+  if (!isAISnitchError(error)) {
+    if (error instanceof Error) {
+      const code = error.code;
+      const retryableCodes = /* @__PURE__ */ new Set([
+        "ECONNREFUSED",
+        "ECONNRESET",
+        "ETIMEDOUT",
+        "ENOTFOUND",
+        "EHOSTUNREACH",
+        "EPIPE",
+        "EPERM"
+        // sometimes transient on macOS file locks
+      ]);
+      if (typeof code === "string" && retryableCodes.has(code)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  const retryableCategories = /* @__PURE__ */ new Set(["TIMEOUT", "NETWORK"]);
+  for (const category of retryableCategories) {
+    if (error.code.startsWith(category)) {
+      return true;
+    }
+  }
+  const retryablePatterns = [
+    /^ADAPTER_.*_(FILE_IO|NETWORK|PROCESS_DETECT)_ERROR$/,
+    /^PIPELINE_.*_(RETRY|RECONNECT)_ERROR$/
+  ];
+  for (const pattern of retryablePatterns) {
+    if (pattern.test(error.code)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// src/core/circuit-breaker.ts
+var CircuitOpenError = class _CircuitOpenError extends AISnitchError {
+  constructor(circuitId, state) {
+    super(
+      `Circuit "${circuitId}" is OPEN \u2014 operation rejected`,
+      "CIRCUIT_OPEN",
+      { circuitId, failures: state.failures, lastFailureAt: state.lastFailureAt }
+    );
+    this.circuitId = circuitId;
+    this.state = state;
+    this.name = "CircuitOpenError";
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _CircuitOpenError);
+    }
+  }
+  toString() {
+    return `${this.name} [${this.code}] "${this.circuitId}" \u2014 failures=${this.state.failures}`;
+  }
+};
+var DEFAULT_OPTIONS = {
+  failureThreshold: 5,
+  halfOpenAfterMs: 3e4,
+  id: "unnamed",
+  resetOnSuccess: true,
+  shouldCountAsFailure: isRetryableError,
+  windowMs: 6e4
+};
+var CircuitBreaker = class {
+  failures = 0;
+  lastFailureAt = null;
+  state = "closed";
+  halfOpenTestStartedAt = null;
+  options;
+  constructor(options = {}) {
+    this.options = {
+      ...DEFAULT_OPTIONS,
+      ...options,
+      // Re-spread to ensure all fields have defaults
+      failureThreshold: options.failureThreshold ?? DEFAULT_OPTIONS.failureThreshold,
+      halfOpenAfterMs: options.halfOpenAfterMs ?? DEFAULT_OPTIONS.halfOpenAfterMs,
+      id: options.id ?? DEFAULT_OPTIONS.id,
+      resetOnSuccess: options.resetOnSuccess ?? DEFAULT_OPTIONS.resetOnSuccess,
+      shouldCountAsFailure: options.shouldCountAsFailure ?? DEFAULT_OPTIONS.shouldCountAsFailure,
+      windowMs: options.windowMs ?? DEFAULT_OPTIONS.windowMs
+    };
+  }
+  /**
+   * Executes an async operation through the circuit breaker.
+   *
+   * - If the circuit is CLOSED → runs `fn` and updates state based on result
+   * - If the circuit is HALF-OPEN → runs `fn` once to test recovery
+   * - If the circuit is OPEN → throws `CircuitOpenError` immediately (no call)
+   *
+   * @param fn - The async operation to protect
+   * @returns The result of `fn` if successful
+   * @throws CircuitOpenError if the circuit is OPEN
+   * @throws The error from `fn` if it throws (and `shouldCountAsFailure` returns true)
+   */
+  async execute(fn) {
+    switch (this.state) {
+      case "closed":
+        return this.executeClosed(fn);
+      case "half-open":
+        return this.executeHalfOpen(fn);
+      case "open":
+        if (this.shouldTransitionToHalfOpen()) {
+          this.transitionToHalfOpen();
+          return this.executeHalfOpen(fn);
+        }
+        throw new CircuitOpenError(this.options.id, this.getState());
+    }
+  }
+  /**
+   * Returns the current observable circuit state.
+   */
+  getState() {
+    return {
+      failures: this.failures,
+      lastFailureAt: this.lastFailureAt,
+      state: this.state
+    };
+  }
+  /**
+   * Forces the circuit to CLOSED (resets failure count and state).
+   * Useful for manual recovery after a known-fix or after a maintenance window.
+   */
+  reset() {
+    this.failures = 0;
+    this.lastFailureAt = null;
+    this.state = "closed";
+    this.halfOpenTestStartedAt = null;
+    logger.debug({ circuitId: this.options.id }, "Circuit breaker manually reset");
+  }
+  /**
+   * Pre-warms the circuit by performing one test call in HALF-OPEN state.
+   * If the circuit is already HALF-OPEN, this does nothing.
+   * If the circuit is CLOSED, this does nothing.
+   */
+  async preWarm(fn) {
+    if (this.state !== "open") {
+      return;
+    }
+    this.transitionToHalfOpen();
+    try {
+      await fn();
+      this.transitionToClosed();
+    } catch {
+      this.transitionToOpen();
+    }
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Private methods
+  // ─────────────────────────────────────────────────────────────────────────
+  async executeClosed(fn) {
+    try {
+      const result = await fn();
+      this.onSuccess();
+      return result;
+    } catch (error) {
+      this.onFailure(error);
+      throw error;
+    }
+  }
+  async executeHalfOpen(fn) {
+    this.halfOpenTestStartedAt = Date.now();
+    try {
+      const result = await fn();
+      this.transitionToClosed();
+      return result;
+    } catch (error) {
+      this.transitionToOpen();
+      throw error;
+    }
+  }
+  onSuccess() {
+    if (this.options.resetOnSuccess) {
+      this.failures = 0;
+      this.lastFailureAt = null;
+    } else {
+      this.failures = Math.max(0, this.failures - 1);
+      if (this.failures === 0) {
+        this.lastFailureAt = null;
+      }
+    }
+    logger.debug(
+      {
+        circuitId: this.options.id,
+        failures: this.failures
+      },
+      "Circuit breaker operation succeeded"
+    );
+  }
+  onFailure(error) {
+    if (!this.options.shouldCountAsFailure(error)) {
+      logger.debug(
+        { circuitId: this.options.id, error },
+        "Circuit breaker operation failed but error is not counted as failure"
+      );
+      return;
+    }
+    this.failures += 1;
+    this.lastFailureAt = Date.now();
+    if (this.failures >= this.options.failureThreshold) {
+      this.transitionToOpen();
+    } else {
+      logger.debug(
+        {
+          circuitId: this.options.id,
+          failures: this.failures,
+          threshold: this.options.failureThreshold
+        },
+        "Circuit breaker recorded failure"
+      );
+    }
+  }
+  transitionToOpen() {
+    if (this.state === "open") {
+      return;
+    }
+    this.state = "open";
+    this.halfOpenTestStartedAt = null;
+    logger.warn(
+      {
+        circuitId: this.options.id,
+        failures: this.failures,
+        windowMs: this.options.windowMs
+      },
+      "\u{1F534} Circuit breaker OPEN \u2014 blocking operations"
+    );
+  }
+  transitionToHalfOpen() {
+    this.state = "half-open";
+    this.halfOpenTestStartedAt = Date.now();
+    logger.info(
+      { circuitId: this.options.id },
+      "\u{1F7E1} Circuit breaker HALF-OPEN \u2014 testing recovery"
+    );
+  }
+  transitionToClosed() {
+    this.state = "closed";
+    this.failures = 0;
+    this.lastFailureAt = null;
+    this.halfOpenTestStartedAt = null;
+    logger.info(
+      { circuitId: this.options.id },
+      "\u{1F7E2} Circuit breaker CLOSED \u2014 recovery successful"
+    );
+  }
+  shouldTransitionToHalfOpen() {
+    if (this.lastFailureAt === null) {
+      return true;
+    }
+    const elapsed = Date.now() - this.lastFailureAt;
+    return elapsed >= this.options.halfOpenAfterMs;
+  }
+};
+var SHARED_BREAKERS = Object.freeze({
+  /**
+   * Breaker for adapter event emission.
+   * Threshold: 5 failures in 60s → open for 30s → half-open test.
+   */
+  adapterEmit: new CircuitBreaker({
+    id: "adapter.emit",
+    failureThreshold: 5,
+    halfOpenAfterMs: 3e4,
+    shouldCountAsFailure: isRetryableError,
+    windowMs: 6e4
+  }),
+  /**
+   * Breaker for file system operations (transcript reading, config loading).
+   * More tolerant: 10 failures in 60s → open for 30s.
+   */
+  fileSystem: new CircuitBreaker({
+    id: "filesystem",
+    failureThreshold: 10,
+    halfOpenAfterMs: 3e4,
+    windowMs: 6e4
+  }),
+  /**
+   * Breaker for HTTP/HTTPS requests.
+   * Stricter: 3 failures in 30s → open for 15s.
+   */
+  httpRequest: new CircuitBreaker({
+    id: "http-request",
+    failureThreshold: 3,
+    halfOpenAfterMs: 15e3,
+    windowMs: 3e4
+  }),
+  /**
+   * Breaker for process detection operations.
+   * Most tolerant: 20 failures in 60s → open for 10s.
+   */
+  processDetection: new CircuitBreaker({
+    id: "process-detection",
+    failureThreshold: 20,
+    halfOpenAfterMs: 1e4,
+    windowMs: 6e4
+  })
+});
+
 // src/core/events/schema.ts
 import { validate as isUuid, v7 as uuidv7, version as uuidVersion } from "uuid";
 import { z } from "zod";
@@ -157,6 +550,8 @@ var TOOL_NAMES = [
   "kiro",
   "augment-code",
   "mistral",
+  "zed",
+  "pi",
   "unknown"
 ];
 var ERROR_TYPES = [
@@ -198,47 +593,58 @@ function createUuidV7() {
   return uuidv7();
 }
 var ToolInputSchema = z.strictObject({
-  filePath: z.string().min(1).optional(),
-  command: z.string().min(1).optional()
+  filePath: z.string().min(1).max(4096).optional(),
+  command: z.string().min(1).max(1e4).optional()
 }).refine(
   (value) => value.filePath !== void 0 || value.command !== void 0,
   "toolInput must include filePath or command"
 );
+var ThinkingContentSchema = z.string().max(1e5).describe("Raw thinking/reasoning content from the AI model");
+var ToolCallNameSchema = z.string().min(1).max(100).describe("Name of the tool being invoked (e.g., Edit, Bash, Grep)");
+var FinalMessageSchema = z.string().max(5e4).describe("End-of-run summary or completion message");
+var ToolResultSchema = z.string().max(1e4).describe("Tool execution result or output");
+var MessageContentSchema = z.string().max(1e5).describe("Raw text content from AI messages");
 var ToolNameSchema = z.enum(TOOL_NAMES);
 var AISnitchEventTypeSchema = z.enum(AISNITCH_EVENT_TYPES);
 var ErrorTypeSchema = z.enum(ERROR_TYPES);
 var CESPCategorySchema = z.enum(CESP_CATEGORIES);
 var EventDataSchema = z.strictObject({
   state: AISnitchEventTypeSchema,
-  project: z.string().min(1).optional(),
-  projectPath: z.string().min(1).optional(),
+  project: z.string().min(1).max(255).optional(),
+  projectPath: z.string().min(1).max(4096).optional(),
   duration: z.number().int().min(0).optional(),
-  toolName: z.string().min(1).optional(),
+  toolName: z.string().min(1).max(100).optional(),
   toolInput: ToolInputSchema.optional(),
-  activeFile: z.string().min(1).optional(),
-  model: z.string().min(1).optional(),
+  activeFile: z.string().min(1).max(4096).optional(),
+  model: z.string().min(1).max(200).optional(),
   tokensUsed: z.number().int().min(0).optional(),
-  errorMessage: z.string().min(1).optional(),
+  errorMessage: z.string().min(1).max(1e4).optional(),
   errorType: ErrorTypeSchema.optional(),
   raw: z.record(z.string(), z.unknown()).optional(),
-  terminal: z.string().min(1).optional(),
-  cwd: z.string().min(1).optional(),
+  terminal: z.string().min(1).max(100).optional(),
+  cwd: z.string().min(1).max(4096).optional(),
   pid: z.number().int().positive().optional(),
-  instanceId: z.string().min(1).optional(),
+  instanceId: z.string().min(1).max(255).optional(),
   instanceIndex: z.number().int().min(1).optional(),
-  instanceTotal: z.number().int().min(1).optional()
+  instanceTotal: z.number().int().min(1).optional(),
+  // New fields for enhanced content capture
+  thinkingContent: ThinkingContentSchema.optional(),
+  toolCallName: ToolCallNameSchema.optional(),
+  finalMessage: FinalMessageSchema.optional(),
+  toolResult: ToolResultSchema.optional(),
+  messageContent: MessageContentSchema.optional()
 });
 var AISnitchEventSchema = z.strictObject({
   specversion: z.literal("1.0"),
   id: z.string().refine(isUuidV7, "id must be a valid UUIDv7 string"),
-  source: z.string().refine(
+  source: z.string().max(2e3).refine(
     isValidUriReference,
     "source must be a valid non-empty CloudEvents URI-reference"
   ),
   type: AISnitchEventTypeSchema,
   time: ISO_TIMESTAMP_SCHEMA,
   "aisnitch.tool": ToolNameSchema,
-  "aisnitch.sessionid": z.string().min(1),
+  "aisnitch.sessionid": z.string().min(1).max(500),
   "aisnitch.seqnum": z.number().int().min(1),
   data: EventDataSchema
 });
@@ -352,20 +758,29 @@ var BaseAdapter = class {
     });
     let published;
     try {
-      published = await this.publishEventImplementation(event, {
-        cwd: context.cwd,
-        env: context.env,
-        hookPayload: context.hookPayload,
-        pid: context.pid,
-        sessionId,
-        source: context.source,
-        transcriptPath: context.transcriptPath
+      published = await SHARED_BREAKERS.adapterEmit.execute(async () => {
+        return await this.publishEventImplementation(event, {
+          cwd: context.cwd,
+          env: context.env,
+          hookPayload: context.hookPayload,
+          pid: context.pid,
+          sessionId,
+          source: context.source,
+          transcriptPath: context.transcriptPath
+        });
       });
     } catch (error) {
-      logger.error(
-        { error, eventType: type, adapter: this.name, sessionId },
-        "\u{1F4D6} Failed to publish event \u2014 swallowing to prevent daemon crash"
-      );
+      if (error instanceof Error && error.name === "CircuitOpenError") {
+        logger.warn(
+          { error, eventType: type, adapter: this.name },
+          "\u{1F4D6} Adapter emit blocked by open circuit \u2014 event dropped"
+        );
+      } else {
+        logger.error(
+          { error, eventType: type, adapter: this.name, sessionId },
+          "\u{1F4D6} Failed to publish event \u2014 swallowing to prevent daemon crash"
+        );
+      }
       published = false;
     }
     if (published) {
@@ -1379,7 +1794,11 @@ var ClaudeCodeAdapter = class extends BaseAdapter {
         return;
       }
       case "SessionEnd": {
-        await this.emitStateChange("session.end", sharedData, context);
+        const finalMessage = extractFinalMessageFromPayload(payload);
+        await this.emitStateChange("session.end", {
+          ...sharedData,
+          finalMessage
+        }, context);
         return;
       }
       case "UserPromptSubmit":
@@ -1396,12 +1815,22 @@ var ClaudeCodeAdapter = class extends BaseAdapter {
         return;
       }
       case "PreToolUse": {
-        await this.emitStateChange("agent.tool_call", sharedData, context);
+        const toolCallName = extractToolNameFromPayload(payload);
+        await this.emitStateChange("agent.tool_call", {
+          ...sharedData,
+          toolCallName
+        }, context);
         return;
       }
       case "PostToolUse": {
+        const toolCallName = extractToolNameFromPayload(payload);
+        const toolResult = extractToolResultFromPayload(payload);
         const emittedType = isClaudeCodingTool(sharedData.toolName) ? "agent.coding" : "agent.tool_call";
-        await this.emitStateChange(emittedType, sharedData, context);
+        await this.emitStateChange(emittedType, {
+          ...sharedData,
+          toolCallName,
+          toolResult
+        }, context);
         return;
       }
       case "PostToolUseFailure":
@@ -1603,21 +2032,50 @@ function extractClaudeTranscriptObservations(payload, transcriptPath) {
   };
   const observations = [];
   if (contentParts.some((part) => part.type === "thinking")) {
+    const thinkingParts = contentParts.filter((part) => part.type === "thinking");
+    const thinkingText = thinkingParts.map((part) => {
+      const text = part.text;
+      return typeof text === "string" ? text : void 0;
+    }).filter((text) => text !== void 0).join("\n");
     observations.push({
       context: sharedContext,
-      data: sharedData,
+      data: {
+        ...sharedData,
+        thinkingContent: thinkingText.length > 0 ? thinkingText : void 0
+      },
       type: "agent.thinking"
     });
   }
   if (contentParts.some(
     (part) => part.type === "text" && typeof part.text === "string" && part.text.trim().length > 0
   )) {
+    const messageTexts = contentParts.filter((part) => part.type === "text").map((part) => part.text).filter((text) => text.trim().length > 0);
+    const messageContent = messageTexts.join("\n");
     observations.push({
       context: sharedContext,
-      data: sharedData,
+      data: {
+        ...sharedData,
+        messageContent: messageContent.length > 0 ? messageContent : void 0
+      },
       type: "agent.streaming"
     });
   }
+  const toolUseParts = contentParts.filter(
+    (part) => part.type === "tool_use" || part.type === "toolUse"
+  );
+  if (toolUseParts.length > 0) {
+    const toolName = getString(toolUseParts[0], "name") ?? getString(toolUseParts[0], "tool");
+    if (toolName) {
+      observations.push({
+        context: sharedContext,
+        data: {
+          ...sharedData,
+          toolCallName: toolName
+        },
+        type: "agent.tool_call"
+      });
+    }
+  }
   return observations;
 }
 function extractClaudeContentParts(payload) {
@@ -1740,6 +2198,51 @@ function getString(payload, key) {
   const value = payload[key];
   return typeof value === "string" && value.trim().length > 0 ? value : void 0;
 }
+function extractToolNameFromPayload(payload) {
+  const directToolName = getString(payload, "tool_name") ?? getString(payload, "toolName");
+  if (directToolName) {
+    return directToolName;
+  }
+  const toolUse = getRecord(payload.tool_use) ?? getRecord(payload.toolUse);
+  if (toolUse) {
+    return getString(toolUse, "name") ?? getString(toolUse, "tool");
+  }
+  const toolInput = getRecord(payload.tool_input) ?? getRecord(payload.toolInput);
+  if (toolInput) {
+    return getString(toolInput, "tool_name") ?? getString(toolInput, "type");
+  }
+  return void 0;
+}
+function extractToolResultFromPayload(payload) {
+  const directResult = getString(payload, "result") ?? getString(payload, "output");
+  if (directResult) {
+    return directResult;
+  }
+  const toolResult = getRecord(payload.tool_result) ?? getRecord(payload.toolResult);
+  if (toolResult) {
+    return getString(toolResult, "content") ?? getString(toolResult, "output");
+  }
+  const errorField = getString(payload, "error") ?? getString(payload, "error_message");
+  if (errorField) {
+    return errorField;
+  }
+  return void 0;
+}
+function extractFinalMessageFromPayload(payload) {
+  const directMessage = getString(payload, "final_message") ?? getString(payload, "finalMessage") ?? getString(payload, "summary") ?? getString(payload, "completion_message");
+  if (directMessage) {
+    return directMessage;
+  }
+  const result = getString(payload, "result") ?? getString(payload, "output") ?? getString(payload, "message");
+  if (result) {
+    return result;
+  }
+  const stats = getRecord(payload.stats);
+  if (stats) {
+    return getString(stats, "summary") ?? getString(stats, "completion_summary");
+  }
+  return void 0;
+}
 
 // src/adapters/copilot-cli.ts
 import { execFile as execFileCallback3 } from "child_process";
@@ -6713,7 +7216,11 @@ var OpenCodeAdapter = class extends BaseAdapter {
         return;
       }
       case "session.deleted": {
-        await this.emitStateChange("session.end", sharedData, context);
+        const finalMessage = extractOpenCodeFinalMessage(payload);
+        await this.emitStateChange("session.end", {
+          ...sharedData,
+          finalMessage
+        }, context);
         return;
       }
       case "session.error": {
@@ -6738,12 +7245,22 @@ var OpenCodeAdapter = class extends BaseAdapter {
         return;
       }
       case "tool.execute.before": {
-        await this.emitStateChange("agent.tool_call", sharedData, context);
+        const toolCallName = extractOpenCodeToolName(payload);
+        await this.emitStateChange("agent.tool_call", {
+          ...sharedData,
+          toolCallName
+        }, context);
         return;
       }
       case "tool.execute.after": {
+        const toolCallName = extractOpenCodeToolName(payload);
+        const toolResult = extractOpenCodeToolResult(payload);
         const emittedType = isOpenCodeCodingTool(sharedData.toolName) ? "agent.coding" : "agent.tool_call";
-        await this.emitStateChange(emittedType, sharedData, context);
+        await this.emitStateChange(emittedType, {
+          ...sharedData,
+          toolCallName,
+          toolResult
+        }, context);
         return;
       }
       default: {
@@ -6910,68 +7427,597 @@ function getString10(payload, key) {
   const value = payload[key];
   return typeof value === "string" && value.trim().length > 0 ? value : void 0;
 }
-
-// src/adapters/registry.ts
-var AdapterRegistry = class {
-  adapters = /* @__PURE__ */ new Map();
-  /**
-   * Registers one built-in or community adapter instance.
-   */
-  register(adapter) {
-    if (this.adapters.has(adapter.name)) {
-      throw new Error(`Adapter "${adapter.name}" is already registered.`);
-    }
-    this.adapters.set(adapter.name, adapter);
+function extractOpenCodeFinalMessage(payload) {
+  const directMessage = getString10(payload, "final_message") ?? getString10(payload, "finalMessage") ?? getString10(payload, "summary") ?? getString10(payload, "completion_message");
+  if (directMessage) {
+    return directMessage;
   }
-  /**
-   * Returns one adapter instance by its tool name.
-   */
-  get(toolName) {
-    return this.adapters.get(toolName);
+  const result = getString10(payload, "result") ?? getString10(payload, "output") ?? getString10(getRecord9(payload.properties), "result");
+  if (result) {
+    return result;
   }
-  /**
-   * Lists every registered adapter.
-   */
-  list() {
-    return [...this.adapters.values()];
+  return void 0;
+}
+function extractOpenCodeToolResult(payload) {
+  const directResult = getString10(payload, "result") ?? getString10(payload, "output") ?? getString10(payload, "toolResult");
+  if (directResult) {
+    return directResult;
   }
-  /**
-   * Returns one status snapshot per registered adapter.
-   */
-  getStatus() {
-    return this.list().map((adapter) => adapter.getStatus());
+  const toolResult = getRecord9(payload.tool_result) ?? getRecord9(payload.toolResult);
+  if (toolResult) {
+    return getString10(toolResult, "content") ?? getString10(toolResult, "output");
   }
-  /**
-   * Starts every adapter enabled in the current AISnitch config.
-   * 📖 Each adapter is started independently — one failure does not prevent
-   * the others from starting.
-   */
-  async startAll(config) {
-    for (const adapter of this.list()) {
-      if (config.adapters[adapter.name]?.enabled !== true) {
-        continue;
-      }
-      try {
-        await adapter.start();
-      } catch (error) {
-        logger.error(
-          { error, adapter: adapter.name },
-          `\u{1F4D6} Failed to start adapter "${adapter.name}" \u2014 skipping`
-        );
-      }
+  const props = getRecord9(payload.properties);
+  if (props) {
+    const nestedResult = getRecord9(props.tool_result) ?? getRecord9(props.toolResult);
+    if (nestedResult) {
+      return getString10(nestedResult, "content") ?? getString10(nestedResult, "output");
     }
   }
-  /**
-   * Stops every adapter in reverse registration order.
-   * 📖 Each adapter is stopped independently — one failure does not prevent
-   * the others from being stopped.
-   */
-  async stopAll() {
-    const adapters = this.list().reverse();
-    for (const adapter of adapters) {
-      try {
-        await adapter.stop();
-      } catch (error) {
+  return void 0;
+}
+
+// src/adapters/pi.ts
+import { execFile as execFile12 } from "child_process";
+import { join as join11 } from "path";
+import { promisify as promisify12 } from "util";
+var execFileAsync = promisify12(execFile12);
+var PiAdapter = class extends BaseAdapter {
+  displayName = "Pi (MiniMax)";
+  name = "pi";
+  strategies = [
+    "process-detect",
+    "api-client",
+    "log-watch"
+  ];
+  apiPort = 7890;
+  logPath;
+  poller = null;
+  activePiSessions = /* @__PURE__ */ new Map();
+  lastCheckedTime = 0;
+  constructor(options) {
+    super(options);
+    this.logPath = join11(
+      options.homeDirectory ?? process.env.HOME ?? "",
+      ".pi",
+      "agent.log"
+    );
+  }
+  start() {
+    if (this.getStatus().running) {
+      return Promise.resolve();
+    }
+    this.setRunning(true);
+    this.startPolling();
+    logger.info({ adapter: this.name }, "Pi adapter started");
+    return Promise.resolve();
+  }
+  stop() {
+    if (this.poller !== null) {
+      clearInterval(this.poller);
+      this.poller = null;
+    }
+    this.setRunning(false);
+    logger.info({ adapter: this.name }, "Pi adapter stopped");
+    return Promise.resolve();
+  }
+  async handleHook(payload) {
+    const normalized = this.parseNormalizedHookPayload(payload);
+    if (normalized === null) {
+      return;
+    }
+    const context = {
+      cwd: normalized.cwd,
+      pid: normalized.pid,
+      sessionId: normalized.sessionId,
+      source: "pi-hook"
+    };
+    const eventType = this.mapEventType(normalized.type ?? "");
+    const eventData = this.buildEventData(eventType, normalized);
+    await this.emit(eventType, eventData, context);
+  }
+  startPolling() {
+    this.poller = setInterval(() => {
+      void this.pollPiActivity();
+    }, 2e3);
+  }
+  async pollPiActivity() {
+    const running = await this.detectPiInstance();
+    if (!running) {
+      for (const [sessionId, activity] of this.activePiSessions) {
+        if (activity.state !== "idle") {
+          activity.state = "idle";
+          await this.emitIdle(sessionId);
+        }
+      }
+      return;
+    }
+    try {
+      const response = await fetch(
+        `http://127.0.0.1:${this.apiPort}/api/status`,
+        {
+          signal: AbortSignal.timeout(500)
+        }
+      );
+      if (response.ok) {
+        const data = await response.json();
+        await this.processPiApiResponse(data);
+      }
+    } catch {
+      await this.checkMiniMaxApi();
+    }
+  }
+  async detectPiInstance() {
+    try {
+      const result = await execFileAsync("pgrep", ["-l", "pi|minimax"]);
+      if (result.stdout.includes("pi") || result.stdout.includes("minimax")) {
+        return true;
+      }
+    } catch {
+    }
+    try {
+      const response = await fetch(
+        `http://127.0.0.1:${this.apiPort}/health`,
+        {
+          signal: AbortSignal.timeout(200)
+        }
+      );
+      if (response.ok) {
+        return true;
+      }
+    } catch {
+    }
+    return false;
+  }
+  async checkMiniMaxApi() {
+    try {
+      const response = await fetch("http://127.0.0.1:3000/api/agent/status", {
+        signal: AbortSignal.timeout(500)
+      });
+      if (response.ok) {
+        const data = await response.json();
+        await this.processPiApiResponse(data);
+      }
+    } catch {
+    }
+  }
+  async processPiApiResponse(data) {
+    const rawSession = data.sessionId ?? data.project ?? "default";
+    const sessionId = `pi:${rawSession.replace(/[^a-zA-Z0-9-_]/g, "-")}`;
+    let activity = this.activePiSessions.get(sessionId);
+    if (!activity) {
+      activity = { sessionId, state: "idle" };
+      this.activePiSessions.set(sessionId, activity);
+      await this.emitSessionStart(sessionId, data);
+    }
+    const rawState = data.state ?? "idle";
+    const state = rawState;
+    if (state !== activity.state) {
+      switch (state) {
+        case "thinking": {
+          const rawThinking = data.thinking;
+          if (rawThinking) {
+            await this.emitThinking(sessionId, rawThinking);
+          }
+          break;
+        }
+        case "tool": {
+          const rawFilePath = data.filePath;
+          const rawCommand = data.command;
+          const rawToolName = data.toolName ?? "unknown";
+          await this.emitToolCall(
+            sessionId,
+            {
+              filePath: rawFilePath ?? "",
+              command: rawCommand ?? ""
+            },
+            rawToolName
+          );
+          break;
+        }
+        case "output": {
+          const rawOutput = data.output;
+          if (rawOutput) {
+            await this.emitOutput(sessionId, rawOutput);
+          }
+          break;
+        }
+        case "error": {
+          const rawError = data.error ?? "Unknown error";
+          await this.emitError(sessionId, rawError);
+          break;
+        }
+        case "idle":
+          await this.emitIdle(sessionId);
+          break;
+      }
+      activity.state = state;
+    }
+  }
+  async emitSessionStart(sessionId, data) {
+    const rawProject = data.project ?? "pi-project";
+    const rawModel = data.model ?? "minimax/moonshot";
+    const eventData = {
+      state: "session.start",
+      project: rawProject,
+      model: rawModel,
+      raw: data
+    };
+    await this.emit("session.start", eventData, { sessionId });
+  }
+  async emitThinking(sessionId, content) {
+    if (!content) return;
+    const eventData = {
+      state: "agent.thinking",
+      thinkingContent: content
+    };
+    await this.emit("agent.thinking", eventData, { sessionId });
+  }
+  async emitToolCall(sessionId, toolInput, toolName) {
+    const eventData = {
+      state: "agent.tool_call",
+      toolCallName: toolName,
+      toolInput,
+      activeFile: toolInput.filePath
+    };
+    await this.emit("agent.tool_call", eventData, { sessionId });
+  }
+  async emitOutput(sessionId, content) {
+    if (!content) return;
+    const eventData = {
+      state: "agent.streaming",
+      messageContent: content
+    };
+    await this.emit("agent.streaming", eventData, { sessionId });
+  }
+  async emitError(sessionId, errorMessage) {
+    const eventData = {
+      state: "agent.error",
+      errorMessage,
+      errorType: "api_error"
+    };
+    await this.emit("agent.error", eventData, { sessionId });
+  }
+  async emitIdle(sessionId) {
+    const eventData = {
+      state: "agent.idle"
+    };
+    await this.emit("agent.idle", eventData, { sessionId });
+  }
+  mapEventType(type) {
+    const mapping = {
+      "session.start": "session.start",
+      "session.end": "session.end",
+      "task.start": "task.start",
+      "task.complete": "task.complete",
+      thinking: "agent.thinking",
+      tool: "agent.tool_call",
+      coding: "agent.coding",
+      output: "agent.streaming",
+      message: "agent.streaming",
+      ask: "agent.asking_user",
+      error: "agent.error",
+      idle: "agent.idle",
+      compact: "agent.compact"
+    };
+    return mapping[type] ?? "agent.streaming";
+  }
+  buildEventData(eventType, payload) {
+    const data = payload.data ?? {};
+    return {
+      state: eventType,
+      project: data.project,
+      activeFile: data.activeFile,
+      model: data.model,
+      toolInput: data.toolInput,
+      toolCallName: data.toolCallName,
+      thinkingContent: data.thinkingContent,
+      messageContent: data.messageContent,
+      finalMessage: data.finalMessage,
+      toolResult: data.toolResult,
+      errorMessage: data.errorMessage,
+      errorType: data.errorType,
+      raw: data.raw
+    };
+  }
+};
+
+// src/adapters/zed.ts
+import { readFile as readFile10 } from "fs/promises";
+import { basename as basename9, join as join12 } from "path";
+var ZedAdapter = class extends BaseAdapter {
+  displayName = "Zed AI";
+  name = "zed";
+  strategies = [
+    "process-detect",
+    "api-client"
+  ];
+  logPaths;
+  apiPort = 9876;
+  pollIntervalMs;
+  poller = null;
+  lastEventTime = 0;
+  activeZedSessions = /* @__PURE__ */ new Map();
+  constructor(options) {
+    super(options);
+    this.pollIntervalMs = 2e3;
+    this.logPaths = [
+      join12(options.homeDirectory ?? process.env.HOME ?? "", ".config", "zed", "logs", "agent.log"),
+      "/tmp/zed-agent.log"
+    ];
+  }
+  start() {
+    if (this.getStatus().running) {
+      return Promise.resolve();
+    }
+    this.setRunning(true);
+    this.startPolling();
+    logger.info({ adapter: this.name }, "Zed adapter started");
+    return Promise.resolve();
+  }
+  stop() {
+    if (this.poller !== null) {
+      clearInterval(this.poller);
+      this.poller = null;
+    }
+    this.setRunning(false);
+    logger.info({ adapter: this.name }, "Zed adapter stopped");
+    return Promise.resolve();
+  }
+  async handleHook(payload) {
+    const normalized = this.parseNormalizedHookPayload(payload);
+    if (normalized === null) {
+      return;
+    }
+    const context = {
+      cwd: normalized.cwd,
+      pid: normalized.pid,
+      sessionId: normalized.sessionId,
+      source: "zed-hook"
+    };
+    const eventType = this.mapEventType(normalized.type ?? "");
+    const eventData = this.buildEventData(eventType, normalized);
+    await this.emit(eventType, eventData, context);
+  }
+  startPolling() {
+    this.poller = setInterval(() => {
+      void this.pollZedStatus();
+    }, this.pollIntervalMs);
+  }
+  async pollZedStatus() {
+    try {
+      const response = await fetch(`http://127.0.0.1:${this.apiPort}/api/agent/status`, {
+        signal: AbortSignal.timeout(1e3)
+      });
+      if (response.ok) {
+        const data = await response.json();
+        if (data.sessionId && typeof data.sessionId === "string") {
+          const sessionId = `zed:${data.sessionId}`;
+          if (!this.activeZedSessions.has(sessionId)) {
+            this.activeZedSessions.set(sessionId, sessionId);
+            await this.emitSessionStart(sessionId, data);
+          }
+          if (data.state === "thinking" && this.lastEventTime < Date.now() - 5e3) {
+            const rawThinking = data.thinking;
+            if (rawThinking) {
+              await this.emitThinking(sessionId, rawThinking);
+            }
+          } else if (data.state === "tool" && data.toolName) {
+            const rawFilePath = data.filePath;
+            const rawCommand = data.command;
+            const rawToolName = data.toolName ?? "unknown";
+            await this.emitToolCall(
+              sessionId,
+              {
+                filePath: rawFilePath ?? "",
+                command: rawCommand ?? ""
+              },
+              rawToolName
+            );
+          } else if (data.state === "idle") {
+            await this.emitIdle(sessionId);
+          }
+        }
+      }
+    } catch {
+      await this.checkLogFiles();
+    }
+  }
+  async checkLogFiles() {
+    for (const logPath of this.logPaths) {
+      try {
+        const content = await readFile10(logPath, "utf8");
+        await this.parseLogContent(content);
+      } catch {
+      }
+    }
+  }
+  async parseLogContent(content) {
+    const lines = content.split("\n").filter((line) => line.trim());
+    for (const line of lines) {
+      if (this.lastEventTime > 0 && this.lastEventTime >= Date.now() - 2e3) {
+        continue;
+      }
+      const event = this.extractZedEventFromLog(line);
+      if (event) {
+        await this.handleHook(event);
+        this.lastEventTime = Date.now();
+      }
+    }
+  }
+  extractZedEventFromLog(line) {
+    try {
+      const parsed = JSON.parse(line);
+      if (!parsed.type || typeof parsed.type !== "string") {
+        return null;
+      }
+      const rawSessionId = parsed.sessionId;
+      const rawWorkspace = parsed.workspace;
+      const sessionId = rawSessionId ? rawSessionId : rawWorkspace ? `zed:${basename9(rawWorkspace)}` : `zed:${Date.now()}`;
+      const rawCwd = parsed.cwd ?? rawWorkspace;
+      return {
+        type: parsed.type,
+        sessionId,
+        cwd: rawCwd,
+        data: {
+          project: parsed.project ?? rawWorkspace ? basename9(String(rawWorkspace)) : void 0,
+          model: parsed.model,
+          state: parsed.type,
+          thinkingContent: parsed.thinking,
+          toolCallName: parsed.toolName,
+          toolInput: parsed.toolInput,
+          messageContent: parsed.message ?? parsed.output,
+          errorMessage: parsed.error,
+          raw: parsed
+        }
+      };
+    } catch {
+      if (line.includes("[zed:agent]")) {
+        const cleaned = line.replace(/^\[.*?\] \[.*?\] /, "");
+        if (cleaned.includes("Thinking:")) {
+          return { type: "thinking", thinkingContent: cleaned.replace("Thinking:", "").trim() };
+        }
+        if (cleaned.includes("Executing tool:")) {
+          return { type: "tool", toolCallName: cleaned.replace("Executing tool:", "").trim() };
+        }
+        if (cleaned.includes("Error:")) {
+          return { type: "error", errorMessage: cleaned.replace("Error:", "").trim() };
+        }
+      }
+      return null;
+    }
+  }
+  async emitSessionStart(sessionId, _data) {
+    const eventData = {
+      state: "session.start",
+      project: sessionId.split(":")[1] ?? "unknown"
+    };
+    await this.emit("session.start", eventData, { sessionId });
+  }
+  async emitThinking(sessionId, content) {
+    if (!content) return;
+    const eventData = {
+      state: "agent.thinking",
+      thinkingContent: content
+    };
+    await this.emit("agent.thinking", eventData, { sessionId });
+    this.lastEventTime = Date.now();
+  }
+  async emitToolCall(sessionId, toolInput, toolName) {
+    const eventData = {
+      state: "agent.tool_call",
+      toolCallName: toolName,
+      toolInput,
+      activeFile: toolInput.filePath
+    };
+    await this.emit("agent.tool_call", eventData, { sessionId });
+    this.lastEventTime = Date.now();
+  }
+  async emitIdle(sessionId) {
+    const eventData = {
+      state: "agent.idle"
+    };
+    await this.emit("agent.idle", eventData, { sessionId });
+  }
+  mapEventType(type) {
+    const mapping = {
+      "session.start": "session.start",
+      "session.end": "session.end",
+      "task.start": "task.start",
+      "task.complete": "task.complete",
+      thinking: "agent.thinking",
+      tool: "agent.tool_call",
+      coding: "agent.coding",
+      output: "agent.streaming",
+      message: "agent.streaming",
+      ask: "agent.asking_user",
+      error: "agent.error",
+      idle: "agent.idle",
+      compact: "agent.compact"
+    };
+    return mapping[type] ?? "agent.streaming";
+  }
+  buildEventData(eventType, payload) {
+    const data = payload.data ?? {};
+    return {
+      state: eventType,
+      project: data.project,
+      activeFile: data.activeFile,
+      model: data.model,
+      toolInput: data.toolInput,
+      toolCallName: data.toolCallName,
+      thinkingContent: data.thinkingContent,
+      messageContent: data.messageContent,
+      finalMessage: data.finalMessage,
+      toolResult: data.toolResult,
+      errorMessage: data.errorMessage,
+      errorType: data.errorType,
+      raw: data.raw
+    };
+  }
+};
+
+// src/adapters/registry.ts
+var AdapterRegistry = class {
+  adapters = /* @__PURE__ */ new Map();
+  /**
+   * Registers one built-in or community adapter instance.
+   */
+  register(adapter) {
+    if (this.adapters.has(adapter.name)) {
+      throw new Error(`Adapter "${adapter.name}" is already registered.`);
+    }
+    this.adapters.set(adapter.name, adapter);
+  }
+  /**
+   * Returns one adapter instance by its tool name.
+   */
+  get(toolName) {
+    return this.adapters.get(toolName);
+  }
+  /**
+   * Lists every registered adapter.
+   */
+  list() {
+    return [...this.adapters.values()];
+  }
+  /**
+   * Returns one status snapshot per registered adapter.
+   */
+  getStatus() {
+    return this.list().map((adapter) => adapter.getStatus());
+  }
+  /**
+   * Starts every adapter enabled in the current AISnitch config.
+   * 📖 Each adapter is started independently — one failure does not prevent
+   * the others from starting.
+   */
+  async startAll(config) {
+    for (const adapter of this.list()) {
+      if (config.adapters[adapter.name]?.enabled !== true) {
+        continue;
+      }
+      try {
+        await adapter.start();
+      } catch (error) {
+        logger.error(
+          { error, adapter: adapter.name },
+          `\u{1F4D6} Failed to start adapter "${adapter.name}" \u2014 skipping`
+        );
+      }
+    }
+  }
+  /**
+   * Stops every adapter in reverse registration order.
+   * 📖 Each adapter is stopped independently — one failure does not prevent
+   * the others from being stopped.
+   */
+  async stopAll() {
+    const adapters = this.list().reverse();
+    for (const adapter of adapters) {
+      try {
+        await adapter.stop();
+      } catch (error) {
         logger.warn(
           { error, adapter: adapter.name },
           `\u{1F4D6} Error stopping adapter "${adapter.name}" \u2014 continuing`
@@ -6982,16 +8028,16 @@ var AdapterRegistry = class {
 };
 
 // src/adapters/generic-pty.ts
-import { basename as basename10 } from "path";
+import { basename as basename11 } from "path";
 import { spawn as spawnPty } from "@lydell/node-pty";
 import stripAnsi from "strip-ansi";
 
 // src/core/engine/context-detector.ts
 import { execFile as execFileCallback12 } from "child_process";
-import { basename as basename9 } from "path";
-import { promisify as promisify12 } from "util";
+import { basename as basename10 } from "path";
+import { promisify as promisify13 } from "util";
 import pidCwd3 from "pid-cwd";
-var execFile12 = promisify12(execFileCallback12);
+var execFile13 = promisify13(execFileCallback12);
 var TERM_PROGRAM_MAP = {
   Apple_Terminal: "Terminal.app",
   Hyper: "Hyper",
@@ -7034,9 +8080,11 @@ var TOOL_BINARY_MAP = {
   "openhands": "openhands",
   "openclaw": "openclaw",
   "opencode": "opencode",
+  "pi": "pi",
   "qwen-code": "qwen",
   "unknown": "unknown",
-  "windsurf": "windsurf"
+  "windsurf": "windsurf",
+  "zed": "zed"
 };
 var ContextDetector = class {
   cache = /* @__PURE__ */ new Map();
@@ -7102,7 +8150,7 @@ var ContextDetector = class {
           return "unknown";
         }
         const nextPid = Number.parseInt(parentPidToken, 10);
-        const normalizedProcessName = basename9(commandText).replace(/\.app$/u, "");
+        const normalizedProcessName = basename10(commandText).replace(/\.app$/u, "");
         const mappedTerminal = PROCESS_NAME_MAP[normalizedProcessName] ?? PROCESS_NAME_MAP[commandText.trim()];
         if (mappedTerminal) {
           return mappedTerminal;
@@ -7286,7 +8334,7 @@ var ContextDetector = class {
     return cwd ?? void 0;
   }
   async defaultExecCommand(command, args, options = {}) {
-    const result = await execFile12(command, [...args], {
+    const result = await execFile13(command, [...args], {
       encoding: "utf8",
       timeout: options.timeoutMs ?? this.commandTimeoutMs,
       maxBuffer: 1024 * 1024
@@ -7366,7 +8414,7 @@ var GenericPTYSession = class {
       {
         cwd: this.cwd,
         pid: pty.pid,
-        project: basename10(this.cwd) || this.cwd,
+        project: basename11(this.cwd) || this.cwd,
         projectPath: this.cwd,
         raw: {
           args: this.args,
@@ -7377,7 +8425,7 @@ var GenericPTYSession = class {
         toolInput: {
           command: this.commandLine
         },
-        toolName: basename10(this.command) || this.command
+        toolName: basename11(this.command) || this.command
       }
     );
     await this.emitEvent(
@@ -7387,7 +8435,7 @@ var GenericPTYSession = class {
       {
         cwd: this.cwd,
         pid: pty.pid,
-        project: basename10(this.cwd) || this.cwd,
+        project: basename11(this.cwd) || this.cwd,
         projectPath: this.cwd,
         raw: {
           args: this.args,
@@ -7537,7 +8585,7 @@ var GenericPTYSession = class {
     await this.emitEvent(pty.pid, sessionId, observation.type, {
       cwd: this.cwd,
       pid: pty.pid,
-      project: basename10(this.cwd) || this.cwd,
+      project: basename11(this.cwd) || this.cwd,
       projectPath: this.cwd,
       terminal,
       ...observation.data
@@ -7647,7 +8695,7 @@ function analyzeTerminalOutputChunk(input) {
         } : {
           command: input.commandLine
         },
-        toolName: activeFile ? "file-edit" : basename10(input.commandLine) || "shell"
+        toolName: activeFile ? "file-edit" : basename11(input.commandLine) || "shell"
       },
       fingerprint: createPtyFingerprint("agent.coding", normalizedText, activeFile),
       type: "agent.coding"
@@ -7677,7 +8725,7 @@ function normalizePtyEnvironment(env) {
   );
 }
 function inferWrappedToolName(command, args) {
-  const commandBaseName = basename10(command).toLowerCase();
+  const commandBaseName = basename11(command).toLowerCase();
   const fullCommandLine = [commandBaseName, ...args].join(" ").toLowerCase();
   const toolMatchers = [
     ["aider", /\baider\b/u],
@@ -7763,7 +8811,9 @@ function createDefaultAdapters(options) {
     new KiloAdapter(options),
     new CodexAdapter(options),
     new OpenClawAdapter(options),
-    new OpenCodeAdapter(options)
+    new OpenCodeAdapter(options),
+    new PiAdapter(options),
+    new ZedAdapter(options)
   ];
 }
 
@@ -7811,10 +8861,10 @@ var DEFAULT_CONFIG = {
 };
 
 // src/core/config/loader.ts
-import { mkdir, readFile as readFile10, writeFile } from "fs/promises";
+import { mkdir, readFile as readFile11, writeFile } from "fs/promises";
 import { createServer } from "net";
 import { homedir as homedir2 } from "os";
-import { dirname as dirname5, join as join11, resolve } from "path";
+import { dirname as dirname5, join as join13, resolve } from "path";
 function getAISnitchHomePath(options = {}) {
   if (options.configPath && options.configPath.trim().length > 0) {
     return dirname5(resolve(options.configPath));
@@ -7823,13 +8873,13 @@ function getAISnitchHomePath(options = {}) {
   if (configuredHome && configuredHome.trim().length > 0) {
     return resolve(configuredHome);
   }
-  return join11(options.homeDirectory ?? homedir2(), ".aisnitch");
+  return join13(options.homeDirectory ?? homedir2(), ".aisnitch");
 }
 function getConfigPath(options = {}) {
   if (options.configPath && options.configPath.trim().length > 0) {
     return resolve(options.configPath);
   }
-  return join11(getAISnitchHomePath(options), "config.json");
+  return join13(getAISnitchHomePath(options), "config.json");
 }
 async function ensureConfigDir(options = {}) {
   const directoryPath = getAISnitchHomePath(options);
@@ -7839,7 +8889,7 @@ async function ensureConfigDir(options = {}) {
 async function loadConfig(options = {}) {
   const configPath = getConfigPath(options);
   try {
-    const rawConfig = await readFile10(configPath, "utf8");
+    const rawConfig = await readFile11(configPath, "utf8");
     const parsedJson = JSON.parse(rawConfig);
     return ConfigSchema.parse(parsedJson);
   } catch (error) {
@@ -8102,7 +9152,7 @@ import { WebSocket, WebSocketServer } from "ws";
 
 // src/package-info.ts
 var AISNITCH_PACKAGE_NAME = "aisnitch";
-var AISNITCH_VERSION = "0.2.19";
+var AISNITCH_VERSION = "0.2.21";
 var AISNITCH_DESCRIPTION = "Universal bridge for AI coding tool activity \u2014 capture, normalize, stream.";
 function getPackageScaffoldInfo() {
   return {
@@ -8639,7 +9689,7 @@ var UDSServer = class {
 };
 
 // src/core/engine/pipeline.ts
-import { join as join12 } from "path";
+import { join as join14 } from "path";
 import { z as z4 } from "zod";
 
 // src/core/events/cesp.ts
@@ -8679,7 +9729,7 @@ function getSocketPath(aisnitchHomePath) {
   if (process.platform === "win32") {
     return "\\\\.\\pipe\\aisnitch.sock";
   }
-  return join12(aisnitchHomePath, "aisnitch.sock");
+  return join14(aisnitchHomePath, "aisnitch.sock");
 }
 var Pipeline = class {
   eventBus = new EventBus();
@@ -8884,6 +9934,30 @@ var Pipeline = class {
   getEventBus() {
     return this.eventBus;
   }
+  /**
+   * Returns the adapter registry for graceful shutdown coordination.
+   */
+  getAdapterRegistry() {
+    return this.adapterRegistry ?? void 0;
+  }
+  /**
+   * Returns the HTTP receiver for graceful shutdown coordination.
+   */
+  getHttpReceiver() {
+    return this.httpReceiver;
+  }
+  /**
+   * Returns the UDS server for graceful shutdown coordination.
+   */
+  getUdsServer() {
+    return this.udsServer;
+  }
+  /**
+   * Returns the WebSocket server for graceful shutdown coordination.
+   */
+  getWsServer() {
+    return this.wsServer;
+  }
   getHealthSnapshot() {
     const status = this.getStatus();
     return {
@@ -8964,6 +10038,483 @@ var Pipeline = class {
   }
 };
 
+// src/core/timeout.ts
+var DEFAULT_TIMEOUTS = Object.freeze({
+  /**
+   * File read/write operations (JSONL transcripts, config files).
+   * Default: 5 seconds
+   */
+  fileOperation: 5e3,
+  /**
+   * HTTP requests to health endpoint or external APIs.
+   * Default: 30 seconds
+   */
+  httpRequest: 3e4,
+  /**
+   * Process detection commands (`pgrep`, `ps aux`).
+   * Default: 3 seconds
+   */
+  processDetection: 3e3,
+  /**
+   * Adapter startup (file watchers, hook bridges, pollers).
+   * Default: 10 seconds
+   */
+  adapterStartup: 1e4,
+  /**
+   * Adapter shutdown (graceful cleanup, watcher close).
+   * Default: 5 seconds — after this, resources are force-closed
+   */
+  adapterShutdown: 5e3,
+  /**
+   * Daemon graceful shutdown (stop all components in order).
+   * Default: 30 seconds
+   */
+  daemonShutdown: 3e4,
+  /**
+   * WebSocket connection establishment.
+   * Default: 10 seconds
+   */
+  wsConnection: 1e4,
+  /**
+   * Overall pipeline start (all components).
+   * Default: 15 seconds
+   */
+  pipelineStartup: 15e3
+});
+function withTimeout(promise, timeoutMs, context) {
+  if (timeoutMs <= 0) {
+    throw new TimeoutError(
+      `Invalid timeout value: ${timeoutMs}ms (must be > 0)`,
+      "TIMEOUT_INVALID_VALUE",
+      { context, timeoutMs }
+    );
+  }
+  return Promise.race([
+    promise,
+    new Promise((_, reject) => {
+      const timeoutId = setTimeout(() => {
+        reject(
+          new TimeoutError(
+            `Operation exceeded ${timeoutMs}ms deadline`,
+            "TIMEOUT_EXCEEDED",
+            { context, timeoutMs }
+          )
+        );
+      }, timeoutMs);
+      timeoutId.unref();
+    })
+  ]);
+}
+async function timeoutWarning(promise, timeoutMs, context) {
+  try {
+    return await withTimeout(promise, timeoutMs, context);
+  } catch (error) {
+    if (error instanceof TimeoutError) {
+      logger.warn(
+        { context: error.context, timeoutMs: error.context },
+        `Best-effort operation timed out after ${timeoutMs}ms`
+      );
+      return await promise;
+    }
+    throw error;
+  }
+}
+function getTimeout(name) {
+  return DEFAULT_TIMEOUTS[name];
+}
+function isTimeoutError(error) {
+  return error instanceof TimeoutError;
+}
+
+// src/core/graceful-shutdown.ts
+async function withShutdownTimeout(fn, timeoutMs, component) {
+  if (timeoutMs <= 0) {
+    await fn();
+    return;
+  }
+  const timeoutPromise = new Promise((resolve2) => {
+    setTimeout(() => {
+      resolve2("timed_out");
+    }, timeoutMs).unref();
+  });
+  const result = await Promise.race([
+    fn().then(() => "completed"),
+    timeoutPromise
+  ]);
+  if (result === "timed_out") {
+    logger.warn(
+      { component, timeoutMs },
+      `Graceful shutdown exceeded ${timeoutMs}ms timeout \u2014 forcing through`
+    );
+  }
+}
+async function shutdownInOrder(components, timeouts, label) {
+  const getTimeout2 = (key) => {
+    return timeouts[key] ?? DEFAULT_TIMEOUTS.daemonShutdown;
+  };
+  const stopSafely = async (key, fn) => {
+    const timeoutMs = getTimeout2(key);
+    try {
+      await withShutdownTimeout(fn, timeoutMs, `${label}.${key}`);
+    } catch (error) {
+      logger.warn(
+        { error, key, label },
+        `Error during shutdown of ${key} \u2014 continuing with remaining components`
+      );
+    }
+  };
+  if (components.cleanupFns) {
+    for (const cleanupFn of components.cleanupFns) {
+      try {
+        await withShutdownTimeout(
+          async () => {
+            const result = cleanupFn();
+            if (result instanceof Promise) {
+              await result;
+            }
+          },
+          1e3,
+          `${label}.cleanup`
+        );
+      } catch (error) {
+        logger.warn({ error, label }, "Cleanup function failed");
+      }
+    }
+  }
+  if (components.eventBus) {
+    components.eventBus.unsubscribeAll();
+  }
+  await stopSafely("wsServer", () => components.wsServer.stop());
+  await stopSafely("udsServer", () => components.udsServer.stop());
+  await stopSafely("httpReceiver", () => components.httpReceiver.stop());
+  if (components.adapterRegistry) {
+    await stopSafely("adapterRegistry", () => components.adapterRegistry.stopAll());
+  }
+}
+var GracefulShutdownManager = class {
+  /**
+   * Creates a new shutdown manager.
+   *
+   * @param options - Configuration options
+   * @param options.onShutdown - Async function called when shutdown is triggered
+   * @param options.exitCode - Exit code to use (default: 0 for graceful, 1 for errors)
+   * @param options.exitDelayMs - Delay before `process.exit()` (default: 100ms for flush)
+   */
+  constructor(options) {
+    this.options = options;
+  }
+  shuttingDown = false;
+  pendingHandlers = /* @__PURE__ */ new Set();
+  /**
+   * Synchronous handler function suitable for `process.on()`.
+   *
+   * Multiple calls are safe — only the first call executes `onShutdown`.
+   * Subsequent calls queue to the internal pending set and run after the
+   * first shutdown completes.
+   */
+  get handler() {
+    return (signal) => {
+      if (!this.shuttingDown) {
+        this.shuttingDown = true;
+        void this.runShutdown(signal);
+      } else {
+        this.pendingHandlers.add(() => {
+          void this.runShutdown(signal);
+        });
+      }
+    };
+  }
+  /**
+   * Manually triggers shutdown from async code (e.g., TUI quit button).
+   *
+   * @param signal - Signal name (for logging)
+   */
+  shutdown(signal = "manual") {
+    this.handler(signal);
+  }
+  /**
+   * Returns whether shutdown is currently in progress.
+   */
+  isShuttingDown() {
+    return this.shuttingDown;
+  }
+  async runShutdown(signal) {
+    const exitCode = this.options.exitCode ?? (signal === "uncaughtException" || signal === "unhandledRejection" ? 1 : 0);
+    const exitDelayMs = this.options.exitDelayMs ?? 100;
+    try {
+      await this.options.onShutdown(signal);
+    } catch (error) {
+      logger.error(
+        { error, signal },
+        "Error during graceful shutdown \u2014 forcing exit"
+      );
+    } finally {
+      await new Promise((resolve2) => {
+        setTimeout(resolve2, exitDelayMs).unref();
+      });
+      for (const pendingHandler of this.pendingHandlers) {
+        pendingHandler();
+      }
+      process.exit(exitCode);
+    }
+  }
+};
+async function withOverallShutdownTimeout(shutdownPromise, timeoutMs, label) {
+  try {
+    await withTimeout(shutdownPromise, timeoutMs, `${label}-overall-shutdown`);
+  } catch (error) {
+    if (isTimeoutError(error)) {
+      logger.error(
+        { timeoutMs, label },
+        `Overall shutdown timeout exceeded \u2014 forcing process exit`
+      );
+    }
+    process.exit(1);
+  }
+}
+
+// src/core/result.ts
+function isOk(result) {
+  return result.success === true;
+}
+function isErr(result) {
+  return result.success === false;
+}
+function ok(value) {
+  return Object.freeze({ success: true, value });
+}
+function err(error) {
+  return Object.freeze({ success: false, error });
+}
+function mapOk(result, fn) {
+  if (!result.success) {
+    return result;
+  }
+  return ok(fn(result.value));
+}
+function mapErr(result, fn) {
+  if (result.success) {
+    return result;
+  }
+  return err(fn(result.error));
+}
+async function flatMap(result, fn) {
+  if (!result.success) {
+    return result;
+  }
+  const mapped = await fn(result.value);
+  if (!mapped.success) {
+    return mapped;
+  }
+  return ok(mapped.value);
+}
+async function fromPromise(promise, mapError) {
+  try {
+    const value = await promise;
+    return ok(value);
+  } catch (reason) {
+    return err(mapError(reason));
+  }
+}
+function fromSync(fn, mapError) {
+  try {
+    return ok(fn());
+  } catch (reason) {
+    return err(mapError(reason));
+  }
+}
+
+// src/core/retry.ts
+var DefaultRetryOptions = {
+  attempts: 3,
+  backoff: 2,
+  context: "unknown",
+  delayMs: 500,
+  jitter: true,
+  maxTotalDelayMs: 3e4,
+  shouldRetry: isRetryableError
+};
+function sleep(ms) {
+  return new Promise((resolve2) => {
+    setTimeout(resolve2, ms).unref();
+  });
+}
+function computeDelay(attempt, baseDelayMs, backoff, jitter) {
+  const exponentialDelay = baseDelayMs * Math.pow(backoff, attempt - 1);
+  if (!jitter) {
+    return exponentialDelay;
+  }
+  const jitterFactor = 0.75 + Math.random() * 0.5;
+  return Math.round(exponentialDelay * jitterFactor);
+}
+async function withRetry(fn, options) {
+  const {
+    attempts = DefaultRetryOptions.attempts,
+    backoff = DefaultRetryOptions.backoff,
+    delayMs = DefaultRetryOptions.delayMs,
+    maxTotalDelayMs = DefaultRetryOptions.maxTotalDelayMs,
+    jitter = DefaultRetryOptions.jitter,
+    shouldRetry = DefaultRetryOptions.shouldRetry
+  } = options;
+  let lastError;
+  let totalDelayMs = 0;
+  const shouldRetryWithDefault = shouldRetry ?? DefaultRetryOptions.shouldRetry;
+  for (let attempt = 1; attempt <= attempts; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      const retryable = shouldRetryWithDefault(error);
+      const attemptsRemaining = attempt < attempts;
+      if (!retryable || !attemptsRemaining) {
+        if (!retryable) {
+          logger.debug(
+            { attempt, context: options.context, error },
+            "Non-retryable error \u2014 giving up immediately"
+          );
+        } else {
+          logger.error(
+            { attempt, attempts, context: options.context, error },
+            "All retry attempts exhausted"
+          );
+        }
+        throw error;
+      }
+      const delay = computeDelay(attempt, delayMs, backoff, jitter ?? false);
+      totalDelayMs += delay;
+      if (totalDelayMs > maxTotalDelayMs) {
+        logger.warn(
+          { attempt, delay, totalDelayMs, maxTotalDelayMs, context: options.context },
+          "Retry max total delay exceeded \u2014 giving up"
+        );
+        throw lastError;
+      }
+      logger.debug(
+        { attempt, attempts, delay, nextDelayMs: delay, context: options.context },
+        `Operation failed \u2014 retrying in ${delay}ms`
+      );
+      await sleep(delay);
+    }
+  }
+  throw lastError;
+}
+function fireAndForgetRetry(fn, options) {
+  void withRetry(fn, {
+    ...options,
+    attempts: options.attempts ?? 2
+  }).catch((error) => {
+    logger.warn(
+      { error, context: options.context },
+      "Fire-and-forget retry also failed \u2014 giving up silently"
+    );
+  });
+}
+function withRetryOn(fn, options) {
+  return ((...args) => withRetry(() => fn(...args), options));
+}
+
+// src/core/safety.ts
+var MAX_PORT = 65535;
+var MIN_PORT = 1;
+var MAX_PATH_LENGTH = 4096;
+var MAX_GENERIC_STRING_LENGTH = 1e4;
+var MAX_LABEL_LENGTH = 255;
+function getString11(record, key) {
+  const value = record[key];
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function getStringWithMaxLength(record, key, maxLength) {
+  const value = getString11(record, key);
+  if (value === void 0) {
+    return void 0;
+  }
+  return value.length > maxLength ? value.slice(0, maxLength) : value;
+}
+function getNumber9(record, key) {
+  const value = record[key];
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return void 0;
+  }
+  return value;
+}
+function getSafeInteger(record, key, options = {}) {
+  const value = getNumber9(record, key);
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!Number.isInteger(value)) {
+    return void 0;
+  }
+  if (options.min !== void 0 && value < options.min) {
+    return void 0;
+  }
+  if (options.max !== void 0 && value > options.max) {
+    return void 0;
+  }
+  return value;
+}
+function getPositiveNumber(record, key) {
+  const value = getNumber9(record, key);
+  return value !== void 0 && value > 0 ? value : void 0;
+}
+function getBoolean2(record, key) {
+  const value = record[key];
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "string") {
+    const lower = value.toLowerCase();
+    if (lower === "true" || lower === "1") {
+      return true;
+    }
+    if (lower === "false" || lower === "0") {
+      return false;
+    }
+  }
+  return void 0;
+}
+function getArray(record, key) {
+  const value = record[key];
+  return Array.isArray(value) ? value : void 0;
+}
+function getObject(record, key) {
+  const value = record[key];
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return void 0;
+  }
+  return value;
+}
+function isValidPort(port) {
+  return port !== void 0 && Number.isInteger(port) && port >= MIN_PORT && port <= MAX_PORT;
+}
+function isValidPathLength(path) {
+  return path !== void 0 && path.length > 0 && path.length <= MAX_PATH_LENGTH;
+}
+function isValidStringLength(value, maxLength) {
+  return value !== void 0 && value.length <= maxLength;
+}
+function isRecord11(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  const proto = Object.prototype.toString.call(value);
+  return proto === "[object Object]";
+}
+function isNotNull(value) {
+  return value != null;
+}
+function getPort(record, key) {
+  const value = getSafeInteger(record, key, { min: MIN_PORT, max: MAX_PORT });
+  return value;
+}
+function getSeqnum(record, key) {
+  return getSafeInteger(record, key, { min: 1 });
+}
+
 // src/tui/index.tsx
 import { render } from "ink";
 import { withFullScreen } from "fullscreen-ink";
@@ -9025,7 +10576,7 @@ function getEventDetailSegments(event) {
       break;
     case "agent.asking_user":
       segments.push(
-        getString11(raw, "notification_type") ?? getString11(raw, "notificationType") ?? getString11(raw, "type")
+        getString12(raw, "notification_type") ?? getString12(raw, "notificationType") ?? getString12(raw, "type")
       );
       segments.push(event.data.errorMessage ?? extractLooseString3(raw, [
         "message",
@@ -9099,10 +10650,10 @@ function extractContentPart(raw, partType, valueKey) {
   }
   for (const part of content) {
     const record = getRecord10(part);
-    if (!record || getString11(record, "type") !== partType) {
+    if (!record || getString12(record, "type") !== partType) {
       continue;
     }
-    const value = getString11(record, valueKey);
+    const value = getString12(record, valueKey);
     if (value) {
       return value;
     }
@@ -9114,12 +10665,12 @@ function extractLooseString3(raw, keys) {
     return void 0;
   }
   for (const key of keys) {
-    const directValue = getString11(raw, key);
+    const directValue = getString12(raw, key);
     if (directValue) {
       return directValue;
     }
     const nestedRecord = getRecord10(raw[key]);
-    const nestedValue = getString11(nestedRecord, "text") ?? getString11(nestedRecord, "message") ?? getString11(nestedRecord, "content");
+    const nestedValue = getString12(nestedRecord, "text") ?? getString12(nestedRecord, "message") ?? getString12(nestedRecord, "content");
     if (nestedValue) {
       return nestedValue;
     }
@@ -9133,13 +10684,13 @@ function truncateSegment(value) {
   }
   return `${normalized.slice(0, DETAIL_SEGMENT_LIMIT - 1)}\u2026`;
 }
-function isRecord11(value) {
+function isRecord12(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function getRecord10(value) {
-  return isRecord11(value) ? value : void 0;
+  return isRecord12(value) ? value : void 0;
 }
-function getString11(payload, key) {
+function getString12(payload, key) {
   if (!payload) {
     return void 0;
   }
@@ -9167,9 +10718,11 @@ var TOOL_COLORS = {
   "openhands": "#facc15",
   "openclaw": "#ef4444",
   "opencode": "#10b981",
+  "pi": "#1db954",
   "qwen-code": "#22c55e",
   "unknown": "#94a3b8",
-  "windsurf": "#a855f7"
+  "windsurf": "#a855f7",
+  "zed": "#e85d04"
 };
 var EVENT_COLORS = {
   "agent.asking_user": "#ef4444",
@@ -11018,10 +12571,12 @@ export {
   AISNITCH_EVENT_TYPES,
   AISNITCH_PACKAGE_NAME,
   AISNITCH_VERSION,
+  AISnitchError,
   AISnitchEventSchema,
   AISnitchEventTypeSchema,
   AUTO_UPDATE_MANAGERS,
   AdapterConfigSchema,
+  AdapterError,
   AdapterRegistry,
   AiderAdapter,
   App,
@@ -11030,6 +12585,8 @@ export {
   CESPCategorySchema,
   CESP_CATEGORIES,
   CESP_MAP,
+  CircuitBreaker,
+  CircuitOpenError,
   ClaudeCodeAdapter,
   CodexAdapter,
   ConfigSchema,
@@ -11037,8 +12594,10 @@ export {
   CopilotCLIAdapter,
   CursorAdapter,
   DEFAULT_CONFIG,
+  DEFAULT_TIMEOUTS,
   DEFAULT_TUI_FILTERS,
   DEFAULT_VISIBLE_EVENT_COUNT,
+  DefaultRetryOptions,
   DevinAdapter,
   ERROR_TYPES,
   EVENT_COLORS,
@@ -11050,33 +12609,51 @@ export {
   EventLine,
   EventStream,
   FilterBar,
+  FinalMessageSchema,
   GeminiCLIAdapter,
   GenericPTYSession,
   GlobalBadge,
   GooseAdapter,
+  GracefulShutdownManager,
   HTTPReceiver,
   Header,
   HelpOverlay,
   KiloAdapter,
   LOG_LEVELS,
+  MAX_GENERIC_STRING_LENGTH,
+  MAX_LABEL_LENGTH,
+  MAX_PATH_LENGTH,
+  MAX_PORT,
+  MIN_PORT,
   ManagedDaemonApp,
+  MessageContentSchema,
+  NetworkError,
   OpenClawAdapter,
   OpenCodeAdapter,
   Panel,
   PanelStack,
+  PiAdapter,
   Pipeline,
+  PipelineError,
   RingBuffer,
   SESSION_STALE_AFTER_MS,
+  SHARED_BREAKERS,
   SessionPanel,
   StatusBar,
   TOOL_COLORS,
   TOOL_NAMES,
   TUI_THEME,
   TUI_VIEW_MODES,
+  ThinkingContentSchema,
+  TimeoutError,
+  ToolCallNameSchema,
   ToolInputSchema,
   ToolNameSchema,
+  ToolResultSchema,
   UDSServer,
+  ValidationError,
   WSServer,
+  ZedAdapter,
   analyzeTerminalOutputChunk,
   appendEventToStream,
   applyEventFilters,
@@ -11090,6 +12667,9 @@ export {
   deriveGlobalActivityStatus,
   deriveSessions,
   ensureConfigDir,
+  err,
+  fireAndForgetRetry,
+  flatMap,
   formatEventDetail,
   formatEventLine,
   formatEventTime,
@@ -11097,16 +12677,42 @@ export {
   formatSessionLabelFromEvent,
   formatSessionShortId,
   formatWelcomeLine,
+  fromPromise,
+  fromSync,
   getAISnitchHomePath,
+  getArray,
+  getBoolean2 as getBoolean,
   getCESPCategory,
   getConfigPath,
+  getNumber9 as getNumber,
+  getObject,
   getPackageScaffoldInfo,
   getPendingFrozenEventCount,
+  getPort,
+  getPositiveNumber,
+  getSafeInteger,
+  getSeqnum,
   getSocketPath,
+  getString11 as getString,
+  getStringWithMaxLength,
+  getTimeout,
   getVisibleEventWindow,
+  isAISnitchError,
+  isErr,
   isGenericSessionId,
+  isNotNull,
+  isOk,
+  isRecord11 as isRecord,
+  isRetryableError,
+  isTimeoutError,
+  isValidPathLength,
+  isValidPort,
+  isValidStringLength,
   loadConfig,
   logger,
+  mapErr,
+  mapOk,
+  ok,
   parseAiderHistoryMarkdown,
   renderAttachedTui,
   renderForegroundTui,
@@ -11115,8 +12721,16 @@ export {
   resolveSessionId,
   saveConfig,
   setLoggerLevel,
+  shutdownInOrder,
+  sleep,
+  timeoutWarning,
   useEventStream,
   useKeyBinds,
-  useSessions
+  useSessions,
+  withOverallShutdownTimeout,
+  withRetry,
+  withRetryOn,
+  withShutdownTimeout,
+  withTimeout
 };
 //# sourceMappingURL=index.js.map