@cuylabs/channel-slack-agent-core 0.1.0

package/dist/types-BqRzb_Cd.d.ts

@@ -0,0 +1,346 @@
+import { Agent, AgentTurnSource, AgentEvent, ApprovalEvent, Logger } from '@cuylabs/agent-core';
+import { SlackActivityInfo, SlackTurnRequestContext, SlackAssistantStatusUpdate, SlackChatStreamStartArgs, SlackUserIdentity, SlackTurnPreparation } from '@cuylabs/channel-slack/core';
+import { h as SlackInteractiveRequestHandler } from './interactive-o_NZb-Xg.js';
+
+/**
+ * Channel-options + adapter contract for the direct Slack adapter
+ * (`createSlackChannelAdapter`).
+ */
+
+type HumanInputEvent = Extract<AgentEvent, {
+    type: "human-input-request";
+}>["request"];
+type SlackToolStartEvent = Extract<AgentEvent, {
+    type: "tool-start";
+}>;
+type MaybePromise<T> = T | Promise<T>;
+/**
+ * Session mapping strategy.
+ *
+ * - `"thread-aware"` *(default)* — Uses the Slack thread_ts as session ID
+ *   when the message is inside a thread; falls back to the channel ID for
+ *   DMs and top-level channel messages. Produces the most natural grouping.
+ *
+ * - `"channel-id"` — Uses the Slack channel / DM ID directly. Every
+ *   message in the same channel/DM shares one session.
+ *
+ * - `"user-per-channel"` — Uses `${channelId}:${userId}`. Each user gets
+ *   an isolated session per channel/DM. Useful for private-context bots.
+ *
+ * - `"user-per-thread"` — Uses `${channelId}:${threadTs}:${userId}` for
+ *   threaded/channel messages and `${channelId}:${userId}` in DMs.
+ *
+ * - `"custom"` — Provide your own mapping via `resolveSessionId`.
+ */
+type SlackSessionStrategy = "thread-aware" | "channel-id" | "user-per-channel" | "user-per-thread" | "custom";
+/**
+ * Controls how the bot posts responses to Slack.
+ *
+ * - `"progressive"` *(default)* — Posts a placeholder message immediately,
+ *   then updates it as the agent emits text. Gives a typing-like experience.
+ *   Uses `chat.update` for mid-stream updates.
+ *
+ * - `"accumulate"` — Waits for the full response before posting. Simpler,
+ *   uses one API call, but the user sees nothing until the agent finishes.
+ *
+ * - `"chat-stream"` — Uses Slack's native `chat.startStream`,
+ *   `chat.appendStream`, and `chat.stopStream` APIs through
+ *   `WebClient.chatStream`. This is the Slack-native streaming path.
+ */
+type SlackStreamingMode = "progressive" | "accumulate" | "chat-stream";
+/**
+ * Configuration for the Slack channel adapter.
+ */
+interface SlackChannelOptions {
+    /**
+     * The agent-core Agent instance to bridge.
+     *
+     * Use `source` instead when you want to bridge a runtime/server-backed chat
+     * adapter that is not a direct `Agent` instance.
+     */
+    agent?: Agent;
+    /**
+     * Generic chat turn source understood by this package.
+     *
+     * Exactly one of `agent` or `source` must be provided.
+     */
+    source?: AgentTurnSource;
+    /**
+     * How to map Slack conversations to agent-core session IDs.
+     * @default "thread-aware"
+     */
+    sessionStrategy?: SlackSessionStrategy;
+    /**
+     * Custom session ID resolver. Required when `sessionStrategy` is `"custom"`.
+     */
+    resolveSessionId?: (info: SlackActivityInfo) => string | Promise<string>;
+    /**
+     * Optional full-request session resolver. Returning `undefined` falls back
+     * to `sessionStrategy` / `resolveSessionId`.
+     *
+     * Prefer this over `resolveSessionId` when session routing needs auth,
+     * prepared text, or other request metadata.
+     */
+    resolveSession?: (request: SlackTurnRequestContext) => string | undefined | Promise<string | undefined>;
+    /**
+     * Surface reasoning events as status updates in Slack.
+     * @default false
+     */
+    showReasoning?: boolean;
+    /**
+     * Surface tool usage as status updates (e.g. "Using tool: search...").
+     * This controls root-agent tool rows. Subagent child tool rows are controlled
+     * separately by `showSubagentToolUsage`.
+     * @default true
+     */
+    showToolUsage?: boolean;
+    /**
+     * Surface subagent child tool activity as Slack task rows. Disabled by
+     * default so delegated workers do not flood the parent turn timeline.
+     * Subagent start/complete/error lifecycle rows still render when
+     * `showToolUsage` is enabled.
+     * @default false
+     */
+    showSubagentToolUsage?: boolean;
+    /**
+     * Include the completed subagent output body in the subagent task row.
+     * Disabled by default because full child results should flow through
+     * `get_agent_results` and the root final answer, not the task timeline.
+     * @default false
+     */
+    showSubagentResultInTask?: boolean;
+    /**
+     * Format the tool-start status text.
+     * @default (toolName) => `🔍 Using tool: ${toolName}...`
+     */
+    formatToolUpdate?: (toolName: string) => string;
+    /**
+     * Format the title shown in Slack task cards for tool activity.
+     * @default (toolName) => toolName
+     */
+    formatToolTitle?: (toolName: string) => string;
+    /**
+     * Format task-card details for a tool-start event. Use this to show safe,
+     * redacted tool arguments in Slack's task UI.
+     * @default details use the tool-start status text
+     */
+    formatToolDetails?: (event: SlackToolStartEvent) => string | undefined;
+    /**
+     * Format the tool-error status text.
+     * @default (toolName) => `⚠️ Tool ${toolName} encountered an error`
+     */
+    formatToolError?: (toolName: string, error: string) => string;
+    /**
+     * Format the reasoning status text.
+     * @default () => "Thinking..."
+     */
+    formatReasoningUpdate?: () => string;
+    /**
+     * Initial Slack thread status set before `prepareTurn` and `source.chat()`
+     * run, when Bolt provides `setStatus` for the classic message/app_mention
+     * listener. Use an object with `loading_messages` to enable Slack's rotating
+     * loading text.
+     *
+     * Return `undefined` from a function resolver to skip the initial status for
+     * a specific turn.
+     *
+     * @default { status: "Thinking..." }
+     */
+    initialStatus?: SlackAssistantStatusUpdate | ((request: SlackTurnRequestContext) => MaybePromise<SlackAssistantStatusUpdate | undefined>);
+    /**
+     * How to handle approval / human-input requests that Slack cannot satisfy
+     * in-channel. When `handleInteractiveRequest` is configured, the handler is
+     * tried first; this fallback is only used when the handler declines.
+     * @default "message-and-error"
+     */
+    interactiveMode?: "message-and-error" | "ignore";
+    /**
+     * Slack-native renderer/resolver hook for approval and human-input requests.
+     *
+     * The adapter provides the current Slack activity, resolved session, user,
+     * and a responder that can post/update Block Kit messages in the originating
+     * thread. Return `true` after rendering/recording the request to keep the
+     * agent turn alive while the request is resolved out-of-band.
+     */
+    handleInteractiveRequest?: SlackInteractiveRequestHandler;
+    /**
+     * Format the fallback message shown when tool approval is required.
+     */
+    formatApprovalRequired?: (request: ApprovalEvent) => string;
+    /**
+     * Format the fallback message shown when human input is required.
+     */
+    formatHumanInputRequired?: (request: HumanInputEvent) => string;
+    /**
+     * How the bot posts responses.
+     * @default "progressive"
+     */
+    streamingMode?: SlackStreamingMode;
+    /**
+     * Minimum number of accumulated characters before issuing a `chat.update`
+     * in progressive mode.
+     * @default 150
+     */
+    progressiveUpdateThreshold?: number;
+    /**
+     * Minimum time between `chat.update` calls in progressive mode.
+     *
+     * Slack recommends waiting at least 3 seconds between updates to longer
+     * messages. Set to `0` to disable time throttling.
+     *
+     * @default 3000
+     */
+    progressiveUpdateIntervalMs?: number;
+    /**
+     * Buffer size passed to Slack's `WebClient.chatStream` helper when
+     * `streamingMode` is `"chat-stream"`.
+     * @default 256
+     */
+    chatStreamBufferSize?: number;
+    /**
+     * Maximum number of Slack task-update chunks the bridge will append to a
+     * single chat stream. Task rows are a bounded UI projection, not a durable
+     * event log.
+     *
+     * @default 200
+     */
+    maxTaskUpdates?: number;
+    /**
+     * Maximum cumulative characters from task titles/details/output that the
+     * bridge will append to one chat stream.
+     *
+     * @default 20000
+     */
+    maxTaskUpdateTextChars?: number;
+    /**
+     * Maximum characters for a single task details/output field.
+     *
+     * @default 500
+     */
+    maxTaskUpdateFieldChars?: number;
+    /**
+     * Start arguments merged into Slack's native chat stream when
+     * `streamingMode` is `"chat-stream"`; useful for Slack-supported authorship
+     * fields such as `icon_emoji`, `icon_url`, and `username`.
+     *
+     * The adapter still owns `channel`, `thread_ts`, recipient ids, and
+     * `buffer_size`.
+     */
+    chatStreamStartArgs?: SlackChatStreamStartArgs;
+    /**
+     * Final arguments merged into `chatStream.stop(...)` when
+     * `streamingMode` is `"chat-stream"`; useful for final blocks such as a
+     * feedback widget.
+     */
+    chatStreamFinalArgs?: {
+        blocks?: unknown[];
+    } & Record<string, unknown>;
+    /**
+     * Convert common markdown constructs emitted by models into Slack mrkdwn.
+     *
+     * @default true
+     */
+    formatChatMarkdown?: boolean;
+    /**
+     * Custom response text formatter. When provided, this takes precedence over
+     * the built-in markdown-to-mrkdwn conversion.
+     */
+    formatMessageText?: (text: string) => string;
+    /**
+     * Maximum time (ms) to wait for the agent before aborting.
+     * @default 120_000
+     */
+    timeout?: number;
+    /**
+     * When `true` (default), replies to channel messages are posted inside the
+     * originating thread. When `false`, replies are posted at channel level.
+     * Has no effect in DMs.
+     * @default true
+     */
+    respondInThread?: boolean;
+    /**
+     * Welcome message sent when the bot is added to a channel or DM.
+     * Set to `null` to disable.
+     */
+    welcomeMessage?: string | null;
+    /**
+     * When `true` (default), `app.event('app_mention')` is registered so the
+     * bot responds to `@mentions` in channels.
+     * @default true
+     */
+    respondToMentions?: boolean;
+    /**
+     * When `true` (default), `app.message()` is registered so the bot
+     * can respond to direct messages and, when enabled, plain channel messages.
+     *
+     * Set to `false` if you only want @mention-triggered responses.
+     * @default true
+     */
+    respondToMessages?: boolean;
+    /**
+     * When `true`, plain channel/group/thread messages from `app.message()` are
+     * forwarded into the agent. Direct messages still work through
+     * `respondToMessages`.
+     *
+     * Keep this disabled unless your Slack app intentionally listens to every
+     * visible channel message. @mentions are handled separately by
+     * `respondToMentions`.
+     * @default false
+     */
+    respondToChannelMessages?: boolean;
+    /**
+     * Resolve additional context to inject into the agent call.
+     *
+     * Use this to customize the system prompt per user, inject Slack identity,
+     * etc. Called before `source.chat()` on every message.
+     */
+    resolveUserContext?: (user: SlackUserIdentity) => {
+        system?: string;
+    } | Promise<{
+        system?: string;
+    }>;
+    /**
+     * Prepare an agent turn from the full Slack request context.
+     *
+     * Prefer this over `resolveUserContext` when you need structured ambient
+     * context for tools/middleware or custom scope attributes.
+     */
+    prepareTurn?: (request: SlackTurnRequestContext) => SlackTurnPreparation | Promise<SlackTurnPreparation>;
+    /**
+     * Resolve the text message forwarded to `source.chat()`.
+     *
+     * Useful when the message text needs normalisation beyond mention-stripping.
+     * Return `undefined` to skip processing this message.
+     */
+    resolveMessage?: (info: SlackActivityInfo) => string | undefined | Promise<string | undefined>;
+    /**
+     * Called on unhandled errors during turn processing.
+     */
+    onError?: (error: Error, info: SlackActivityInfo) => void | Promise<void>;
+    /**
+     * Optional diagnostics logger. Used for best-effort status/update failures
+     * and classic turn utility visibility.
+     */
+    logger?: Logger;
+}
+/**
+ * Slack channel adapter returned by `createSlackChannelAdapter`.
+ */
+interface SlackChannelAdapter {
+    /**
+     * Register all message/event handlers on a Bolt `App`.
+     *
+     * ```ts
+     * const adapter = createSlackChannelAdapter({ agent });
+     * adapter.mount(boltApp);
+     * ```
+     */
+    mount(app: {
+        message: (...args: any[]) => unknown;
+        event: (...args: any[]) => unknown;
+    }): void;
+    /** Resolve or look up the session ID for a given Slack activity. */
+    getSessionId(info: SlackActivityInfo): string | Promise<string>;
+}
+
+export type { SlackChannelAdapter as S, SlackChannelOptions as a, SlackSessionStrategy as b, SlackStreamingMode as c, SlackToolStartEvent as d };

package/dist/types-Crpil4kb.d.ts

@@ -0,0 +1,136 @@
+import { ApprovalAction, ApprovalRememberScope, HumanInputResponse, ApprovalRequest, HumanInputRequest, ApprovalResolution } from '@cuylabs/agent-core';
+import { App } from '@slack/bolt';
+import { S as SlackApprovalRequest, b as SlackHumanInputRequest, g as SlackInteractiveRequestContext, d as SlackInteractiveMessageRef } from './interactive-o_NZb-Xg.js';
+
+type SlackInteractiveRequestStatus = "pending" | "resolved";
+type SlackInteractiveApprovalRequest = ApprovalRequest | SlackApprovalRequest;
+type SlackInteractiveHumanInputRequest = SlackHumanInputRequest & Partial<Pick<HumanInputRequest, "sessionId" | "timestamp" | "toolCallId">>;
+type SlackInteractiveStoredRequest = SlackInteractiveApprovalRequest | SlackInteractiveHumanInputRequest;
+type SlackInteractiveResolution = {
+    kind: "approval";
+    action: ApprovalAction;
+    feedback?: string;
+    rememberScope?: ApprovalRememberScope;
+} | {
+    kind: "human-input";
+    response: HumanInputResponse;
+};
+interface SlackInteractiveMessageTarget {
+    channel: string;
+    ts: string;
+    threadTs?: string;
+    userId: string;
+    teamId?: string;
+}
+interface SlackInteractiveRequestRecord {
+    id: string;
+    kind: SlackInteractiveResolution["kind"];
+    request: SlackInteractiveStoredRequest;
+    status: SlackInteractiveRequestStatus;
+    createdAt: string;
+    updatedAt: string;
+    target?: SlackInteractiveMessageTarget;
+    resolution?: SlackInteractiveResolution;
+}
+interface SlackInteractiveRequestStore {
+    get(requestId: string): Promise<SlackInteractiveRequestRecord | undefined>;
+    upsert(record: SlackInteractiveRequestRecord): Promise<SlackInteractiveRequestRecord>;
+    /**
+     * Attach the Slack message target for an already-upserted request.
+     *
+     * Implementations should return `undefined` when the request does not exist;
+     * callers must upsert before attaching a target.
+     */
+    attachTarget(requestId: string, target: SlackInteractiveMessageTarget): Promise<SlackInteractiveRequestRecord | undefined>;
+    /**
+     * Mark a request resolved. Implementations must be idempotent: resolving an
+     * already-resolved request should return the existing record without
+     * overwriting the original resolution.
+     */
+    resolve(requestId: string, resolution: SlackInteractiveResolution): Promise<SlackInteractiveRequestRecord | undefined>;
+    delete(requestId: string): Promise<void>;
+}
+interface SlackInteractiveActionIds {
+    approvalAllow: string;
+    approvalDeny: string;
+    approvalRemember: string;
+    humanConfirm: string;
+    humanDeny: string;
+    humanOpen: string;
+    humanSubmit: string;
+}
+interface SlackInteractiveActor {
+    userId: string;
+    teamId?: string;
+}
+interface SlackInteractiveRequestWaitOptions {
+    /**
+     * Abort waiting for this request. The controller removes its local waiter and
+     * deletes the pending store record when the signal fires.
+     */
+    signal?: AbortSignal;
+    /**
+     * Override the controller-level request timeout for this request. Use `0` to
+     * disable timeout cleanup for this request.
+     */
+    timeoutMs?: number;
+}
+interface SlackInteractiveControllerOptions {
+    store?: SlackInteractiveRequestStore;
+    /**
+     * Stable namespace for default Slack action IDs. Use this when installing
+     * multiple interactive controllers in the same Slack app.
+     *
+     * @default "agent_slack"
+     */
+    namespace?: string;
+    actionIds?: Partial<SlackInteractiveActionIds>;
+    /**
+     * Default timeout for local waiters and pending store records. This should
+     * usually match the agent-core approval/human-input timeout.
+     *
+     * @default 300000
+     */
+    requestTimeoutMs?: number;
+    /**
+     * Called on every successful Slack resolution after the local waiter, if
+     * present, is resolved. Use this to fan out decisions to agent-server or
+     * another runtime that owns the turn.
+     */
+    onResolve?: (requestId: string, resolution: SlackInteractiveResolution) => void | Promise<void>;
+    /**
+     * Authorization hook for approving/responding to pending requests.
+     *
+     * Defaults to the original Slack requester only. Return `true` for delegated
+     * approvers, channel owners, or admin policy checks.
+     */
+    authorize?: (record: SlackInteractiveRequestRecord, actor: SlackInteractiveActor) => boolean | Promise<boolean>;
+}
+interface SlackInteractiveController {
+    readonly actionIds: SlackInteractiveActionIds;
+    readonly store: SlackInteractiveRequestStore;
+    approval: {
+        onRequest(request: ApprovalRequest, options?: SlackInteractiveRequestWaitOptions): Promise<ApprovalResolution>;
+    };
+    humanInput: {
+        onRequest(request: HumanInputRequest, options?: SlackInteractiveRequestWaitOptions): Promise<HumanInputResponse>;
+    };
+    /** Reject one pending in-process waiter and delete its pending store record. */
+    cancel(requestId: string, reason?: string): Promise<boolean>;
+    /** Shutdown helper: cancel every pending request created by this controller. */
+    cancelAll(reason?: string): Promise<void>;
+    handleInteractiveRequest(context: SlackInteractiveRequestContext): Promise<boolean>;
+    install(app: App): void;
+}
+type SlackInteractivePendingWaiter = {
+    resolve: (resolution: SlackInteractiveResolution) => void;
+    reject: (error: Error) => void;
+    cleanup: () => void;
+};
+interface SlackInteractivePostedMessage {
+    text: string;
+    blocks: unknown[];
+    ref: SlackInteractiveMessageRef;
+}
+
+export type { SlackInteractiveActionIds as S, SlackInteractiveActor as a, SlackInteractiveApprovalRequest as b, SlackInteractiveController as c, SlackInteractiveControllerOptions as d, SlackInteractiveHumanInputRequest as e, SlackInteractiveMessageTarget as f, SlackInteractivePendingWaiter as g, SlackInteractivePostedMessage as h, SlackInteractiveRequestRecord as i, SlackInteractiveRequestStatus as j, SlackInteractiveRequestStore as k, SlackInteractiveRequestWaitOptions as l, SlackInteractiveResolution as m, SlackInteractiveStoredRequest as n };

package/dist/users.d.ts

@@ -0,0 +1 @@
+export * from '@cuylabs/channel-slack/users';

package/dist/users.js

@@ -0,0 +1,10 @@
+import {
+  users_exports
+} from "./chunk-HFT2FXJP.js";
+import {
+  __reExport
+} from "./chunk-I2KLQ2HA.js";
+
+// src/users.ts
+var users_exports2 = {};
+__reExport(users_exports2, users_exports);

package/package.json

@@ -0,0 +1,169 @@
+{
+  "name": "@cuylabs/channel-slack-agent-core",
+  "version": "0.1.0",
+  "description": "Slack adapter for @cuylabs/agent-core built on @cuylabs/channel-slack",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./adapter": {
+      "types": "./dist/adapter.d.ts",
+      "import": "./dist/adapter.js",
+      "default": "./dist/adapter.js"
+    },
+    "./app": {
+      "types": "./dist/app.d.ts",
+      "import": "./dist/app.js",
+      "default": "./dist/app.js"
+    },
+    "./app-surface": {
+      "types": "./dist/app-surface.d.ts",
+      "import": "./dist/app-surface.js",
+      "default": "./dist/app-surface.js"
+    },
+    "./assistant": {
+      "types": "./dist/assistant.d.ts",
+      "import": "./dist/assistant.js",
+      "default": "./dist/assistant.js"
+    },
+    "./bolt": {
+      "types": "./dist/bolt.d.ts",
+      "import": "./dist/bolt.js",
+      "default": "./dist/bolt.js"
+    },
+    "./diagnostics": {
+      "types": "./dist/diagnostics.d.ts",
+      "import": "./dist/diagnostics.js",
+      "default": "./dist/diagnostics.js"
+    },
+    "./express": {
+      "types": "./dist/express.d.ts",
+      "import": "./dist/express.js",
+      "default": "./dist/express.js"
+    },
+    "./express-assistant": {
+      "types": "./dist/express-assistant.d.ts",
+      "import": "./dist/express-assistant.js",
+      "default": "./dist/express-assistant.js"
+    },
+    "./feedback": {
+      "types": "./dist/feedback.d.ts",
+      "import": "./dist/feedback.js",
+      "default": "./dist/feedback.js"
+    },
+    "./history": {
+      "types": "./dist/history.d.ts",
+      "import": "./dist/history.js",
+      "default": "./dist/history.js"
+    },
+    "./interactive": {
+      "types": "./dist/interactive.d.ts",
+      "import": "./dist/interactive.js",
+      "default": "./dist/interactive.js"
+    },
+    "./mcp": {
+      "types": "./dist/mcp.d.ts",
+      "import": "./dist/mcp.js",
+      "default": "./dist/mcp.js"
+    },
+    "./policy": {
+      "types": "./dist/policy.d.ts",
+      "import": "./dist/policy.js",
+      "default": "./dist/policy.js"
+    },
+    "./setup": {
+      "types": "./dist/setup.d.ts",
+      "import": "./dist/setup.js",
+      "default": "./dist/setup.js"
+    },
+    "./shared": {
+      "types": "./dist/shared.d.ts",
+      "import": "./dist/shared.js",
+      "default": "./dist/shared.js"
+    },
+    "./socket": {
+      "types": "./dist/socket.d.ts",
+      "import": "./dist/socket.js",
+      "default": "./dist/socket.js"
+    },
+    "./targets": {
+      "types": "./dist/targets.d.ts",
+      "import": "./dist/targets.js",
+      "default": "./dist/targets.js"
+    },
+    "./users": {
+      "types": "./dist/users.d.ts",
+      "import": "./dist/users.js",
+      "default": "./dist/users.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "dependencies": {
+    "@cuylabs/agent-core": "^7.2.0",
+    "@cuylabs/channel-slack": "^0.1.0"
+  },
+  "peerDependencies": {
+    "@slack/bolt": ">=4.7.3",
+    "@slack/types": ">=2.21.1",
+    "@slack/web-api": ">=7.16.0",
+    "express": ">=4.21.0 || >=5.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@slack/bolt": {
+      "optional": true
+    },
+    "@slack/types": {
+      "optional": true
+    },
+    "@slack/web-api": {
+      "optional": true
+    },
+    "express": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@slack/bolt": "^4.7.3",
+    "@slack/types": "^2.21.1",
+    "@slack/web-api": "^7.16.0",
+    "@types/express": "^5.0.0",
+    "@types/node": "^22.0.0",
+    "express": "^5.2.1",
+    "tsup": "^8.0.0",
+    "typescript": "^5.7.0",
+    "vitest": "^4.0.18"
+  },
+  "keywords": [
+    "ai",
+    "agent",
+    "slack",
+    "channel",
+    "adapter",
+    "agent-core",
+    "bolt"
+  ],
+  "license": "Apache-2.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts src/shared.ts src/adapter.ts src/app.ts src/app-surface.ts src/assistant.ts src/bolt.ts src/diagnostics.ts src/express.ts src/express-assistant.ts src/feedback.ts src/history.ts src/interactive.ts src/mcp.ts src/policy.ts src/setup.ts src/socket.ts src/targets.ts src/users.ts --format esm --dts --clean",
+    "clean": "rm -rf dist",
+    "dev": "tsup src/index.ts src/shared.ts src/adapter.ts src/app.ts src/app-surface.ts src/assistant.ts src/bolt.ts src/diagnostics.ts src/express.ts src/express-assistant.ts src/feedback.ts src/history.ts src/interactive.ts src/mcp.ts src/policy.ts src/setup.ts src/socket.ts src/targets.ts src/users.ts --format esm --dts --watch",
+    "lint": "eslint \"src/**/*.{ts,tsx}\" \"tests/**/*.{ts,tsx}\" --max-warnings=0",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit"
+  }
+}