indusagi 0.12.32 → 0.12.34

package/dist/types/facade/bot/actions/composio/client.d.ts

@@ -0,0 +1,39 @@
+import type { ConnectedAccountListParams, ConnectedAccountListResponse, ToolListParams, ToolkitConnectionsDetails, ToolRouterSessionSearchResponse } from "@composio/core";
+import type { ComposioAgentTool, ComposioAgentToolsOptions, ComposioBaseOptions, ComposioConnectResult, ComposioExecuteResult, ComposioRawTool, ComposioToolListResult } from "./types.js";
+export declare class ComposioService {
+    private readonly options;
+    private readonly provider;
+    private clientPromise;
+    private readonly rawToolCache;
+    private readonly sessionCache;
+    constructor(options?: ComposioBaseOptions);
+    resolveUserId(): Promise<string>;
+    private resolveApiKey;
+    private getClient;
+    getRawToolBySlug(slug: string): Promise<ComposioRawTool>;
+    listRawTools(filters: ToolListParams): Promise<ComposioToolListResult>;
+    private resolveToolListFilters;
+    private resolveSessionSelection;
+    private getSession;
+    listToolkits(input: {
+        toolkits?: string[];
+        search?: string;
+        limit?: number;
+        nextCursor?: string;
+        isConnected?: boolean;
+    }): Promise<ToolkitConnectionsDetails>;
+    searchTools(query: string, toolkits?: string[]): Promise<ToolRouterSessionSearchResponse>;
+    createAgentTools(options: ComposioAgentToolsOptions): Promise<ComposioAgentTool[]>;
+    executeTool(options: ComposioAgentToolsOptions & {
+        toolSlug: string;
+        arguments?: Record<string, unknown>;
+    }): Promise<ComposioExecuteResult>;
+    listAccounts(filters?: ConnectedAccountListParams): Promise<ConnectedAccountListResponse>;
+    connectAccount(options: {
+        toolkit?: string;
+        connectedAccountId?: string;
+        authConfigId?: string;
+        callbackUrl?: string;
+    }): Promise<ComposioConnectResult>;
+}
+export declare function createComposioAgentTools(options: ComposioAgentToolsOptions): Promise<ComposioAgentTool[]>;

package/dist/types/facade/bot/actions/composio/connect.d.ts

@@ -0,0 +1,19 @@
+import type { AgentTool } from "../../types.js";
+import type { ComposioConnectResult, ComposioToolFactoryOptions } from "./types.js";
+declare const composioConnectSchema: import("@sinclair/typebox").TObject<{
+    toolkit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    connectedAccountId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    authConfigId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    callbackUrl: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>;
+export interface ComposioConnectToolDetails extends ComposioConnectResult {
+    userId: string;
+}
+export declare function createComposioConnectTool(options?: ComposioToolFactoryOptions): AgentTool<typeof composioConnectSchema, ComposioConnectToolDetails>;
+export declare const composioConnectTool: AgentTool<import("@sinclair/typebox").TObject<{
+    toolkit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    connectedAccountId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    authConfigId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    callbackUrl: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>, ComposioConnectToolDetails>;
+export {};

package/dist/types/facade/bot/actions/composio/enable.d.ts

@@ -0,0 +1,25 @@
+import type { AgentTool } from "../../types.js";
+import type { ComposioToolFactoryOptions, ComposioToolMetadata } from "./types.js";
+declare const composioEnableSchema: import("@sinclair/typebox").TObject<{
+    toolkits: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+    toolSlugs: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+    authConfigs: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TString>>;
+    connectedAccounts: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TString>>;
+    authConfigId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    connectedAccountId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>;
+export interface ComposioEnableToolDetails {
+    userId: string;
+    enabledTools: ComposioToolMetadata[];
+    activationApplied: boolean;
+}
+export declare function createComposioEnableTool(options?: ComposioToolFactoryOptions): AgentTool<typeof composioEnableSchema, ComposioEnableToolDetails>;
+export declare const composioEnableTool: AgentTool<import("@sinclair/typebox").TObject<{
+    toolkits: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+    toolSlugs: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+    authConfigs: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TString>>;
+    connectedAccounts: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TString>>;
+    authConfigId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    connectedAccountId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>, ComposioEnableToolDetails>;
+export {};

package/dist/types/facade/bot/actions/composio/execute.d.ts

@@ -0,0 +1,26 @@
+import type { AgentTool } from "../../types.js";
+import type { ComposioExecuteResult, ComposioToolFactoryOptions } from "./types.js";
+declare const composioExecuteSchema: import("@sinclair/typebox").TObject<{
+    toolSlug: import("@sinclair/typebox").TString;
+    arguments: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TUnknown>>;
+    toolkits: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+    authConfigs: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TString>>;
+    connectedAccounts: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TString>>;
+    authConfigId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    connectedAccountId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>;
+export interface ComposioExecuteToolDetails extends ComposioExecuteResult {
+    userId: string;
+    toolSlug: string;
+}
+export declare function createComposioExecuteTool(options?: ComposioToolFactoryOptions): AgentTool<typeof composioExecuteSchema, ComposioExecuteToolDetails>;
+export declare const composioExecuteTool: AgentTool<import("@sinclair/typebox").TObject<{
+    toolSlug: import("@sinclair/typebox").TString;
+    arguments: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TUnknown>>;
+    toolkits: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+    authConfigs: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TString>>;
+    connectedAccounts: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TString>>;
+    authConfigId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    connectedAccountId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>, ComposioExecuteToolDetails>;
+export {};

package/dist/types/facade/bot/actions/composio/helpers.d.ts

@@ -0,0 +1,16 @@
+import type { ConnectedAccountListResponse, Tool as ComposioRawTool, ToolRouterSessionSearchResponse, ToolkitConnectionsDetails } from "@composio/core";
+import type { ComposioConnectResult, ComposioExecuteResult, ComposioToolMetadata } from "./types.js";
+export declare const DEFAULT_COMPOSIO_USER_ID = "default";
+export declare function buildComposioToolName(slug: string): string;
+export declare function buildComposioToolDescription(tool: ComposioRawTool): string;
+export declare function extractToolMetadata(tool: Pick<ComposioRawTool, "slug" | "name" | "toolkit" | "isNoAuth" | "version">): ComposioToolMetadata;
+export declare function safeJsonStringify(value: unknown): string;
+export declare function formatExecutionPayload(data: unknown, fallback?: string): string;
+export declare function formatExecuteResult(result: ComposioExecuteResult): string;
+export declare function formatToolkitList(toolkits: ToolkitConnectionsDetails): string;
+export declare function formatRawToolList(items: ComposioRawTool[]): string;
+export declare function formatSearchResults(result: ToolRouterSessionSearchResponse): string;
+export declare function formatConnectedAccounts(accounts: ConnectedAccountListResponse): string;
+export declare function formatConnectResult(result: ComposioConnectResult): string;
+export declare function stableStringify(value: unknown): string;
+export declare function uniqueStrings(values: readonly string[] | undefined): string[];

package/dist/types/facade/bot/actions/composio/index.d.ts

@@ -0,0 +1,9 @@
+export { ComposioService, createComposioAgentTools } from "./client.js";
+export { IndusagiComposioProvider } from "./provider.js";
+export { createComposioToolkitsTool, composioToolkitsTool, type ComposioToolkitsToolDetails, } from "./toolkits.js";
+export { createComposioToolsTool, composioToolsTool, type ComposioToolsToolDetails, } from "./tools.js";
+export { createComposioConnectTool, composioConnectTool, type ComposioConnectToolDetails, } from "./connect.js";
+export { createComposioExecuteTool, composioExecuteTool, type ComposioExecuteToolDetails, } from "./execute.js";
+export { createComposioEnableTool, composioEnableTool, type ComposioEnableToolDetails, } from "./enable.js";
+export { createComposioAccountsTool, composioAccountsTool, type ComposioAccountsToolDetails, } from "./accounts.js";
+export type { ComposioAgentTool, ComposioAgentToolsOptions, ComposioBaseOptions, ComposioClientFactory, ComposioConnectResult, ComposioEnableHandler, ComposioExecuteResult, ComposioServiceLike, ComposioToolExecutionDetails, ComposioToolFactoryOptions, ComposioToolListResult, ComposioToolMetadata, ComposioToolSelection, } from "./types.js";

package/dist/types/facade/bot/actions/composio/provider.d.ts

@@ -0,0 +1,8 @@
+import type { Tool as ComposioRawTool, ToolExecuteResponse } from "@composio/core";
+import { BaseAgenticProvider } from "@composio/core";
+import type { ComposioAgentTool } from "./types.js";
+export declare class IndusagiComposioProvider extends BaseAgenticProvider<ComposioAgentTool[], ComposioAgentTool, unknown> {
+    readonly name = "indusagi-framework";
+    wrapTool(tool: ComposioRawTool, executeTool: (toolSlug: string, input: Record<string, unknown>) => Promise<ToolExecuteResponse>): ComposioAgentTool;
+    wrapTools(tools: ComposioRawTool[], executeTool: (toolSlug: string, input: Record<string, unknown>) => Promise<ToolExecuteResponse>): ComposioAgentTool[];
+}

package/dist/types/facade/bot/actions/composio/toolkits.d.ts

@@ -0,0 +1,22 @@
+import type { AgentTool } from "../../types.js";
+import { ComposioService } from "./client.js";
+import type { ComposioToolFactoryOptions } from "./types.js";
+declare const composioToolkitsSchema: import("@sinclair/typebox").TObject<{
+    search: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    toolkits: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+    limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    nextCursor: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    isConnected: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+}>;
+export type ComposioToolkitsToolDetails = Awaited<ReturnType<ComposioService["listToolkits"]>> & {
+    userId: string;
+};
+export declare function createComposioToolkitsTool(options?: ComposioToolFactoryOptions): AgentTool<typeof composioToolkitsSchema, ComposioToolkitsToolDetails>;
+export declare const composioToolkitsTool: AgentTool<import("@sinclair/typebox").TObject<{
+    search: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    toolkits: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+    limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    nextCursor: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    isConnected: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+}>, ComposioToolkitsToolDetails>;
+export {};

package/dist/types/facade/bot/actions/composio/tools.d.ts

@@ -0,0 +1,28 @@
+import type { ToolRouterSessionSearchResponse } from "@composio/core";
+import type { AgentTool } from "../../types.js";
+import { ComposioService } from "./client.js";
+import type { ComposioToolFactoryOptions } from "./types.js";
+declare const composioToolsSchema: import("@sinclair/typebox").TObject<{
+    query: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    toolkits: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+    toolSlugs: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+    authConfigIds: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+    limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    cursor: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>;
+export interface ComposioToolsToolDetails {
+    mode: "search" | "list";
+    userId: string;
+    searchResults?: ToolRouterSessionSearchResponse;
+    listResults?: Awaited<ReturnType<ComposioService["listRawTools"]>>;
+}
+export declare function createComposioToolsTool(options?: ComposioToolFactoryOptions): AgentTool<typeof composioToolsSchema, ComposioToolsToolDetails>;
+export declare const composioToolsTool: AgentTool<import("@sinclair/typebox").TObject<{
+    query: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    toolkits: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+    toolSlugs: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+    authConfigIds: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+    limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    cursor: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>, ComposioToolsToolDetails>;
+export {};

package/dist/types/facade/bot/actions/composio/types.d.ts

@@ -0,0 +1,137 @@
+import type { ConnectedAccountListParams, ConnectedAccountListResponse, Tool as ComposioRawTool, ToolListParams, ToolRouterCreateSessionConfig, ToolRouterSessionSearchResponse, ToolkitConnectionsDetails } from "@composio/core";
+import type { AgentTool } from "../../types.js";
+export type { ComposioRawTool };
+export interface ComposioToolMetadata {
+    slug: string;
+    name: string;
+    toolkit?: string;
+    isNoAuth?: boolean;
+    version?: string;
+}
+export interface ComposioToolExecutionDetails extends ComposioToolMetadata {
+    successful: boolean;
+    error: string | null;
+    logId?: string;
+    data: Record<string, unknown>;
+}
+export interface ComposioAgentTool extends AgentTool<any, ComposioToolExecutionDetails> {
+    composio: ComposioToolMetadata;
+}
+export interface ComposioToolListResult {
+    items: ComposioRawTool[];
+    nextCursor?: string | null;
+    totalPages?: number;
+}
+export type ComposioRawToolListResponse = ComposioToolListResult | ComposioRawTool[];
+export interface ComposioExecuteResult {
+    data: Record<string, unknown>;
+    error: string | null;
+    successful: boolean;
+    logId?: string;
+    sessionInfo?: unknown;
+}
+export interface ComposioConnectResult {
+    action: "created" | "refreshed" | "already_connected";
+    accountId: string;
+    status: string;
+    redirectUrl?: string | null;
+    toolkit?: string;
+    authConfigId?: string;
+    raw: Record<string, unknown>;
+}
+export interface ComposioConnectionRequestLike {
+    id: string;
+    status?: string;
+    redirectUrl?: string | null;
+    toJSON?: () => {
+        id: string;
+        status?: string;
+        redirectUrl?: string | null;
+    };
+}
+export interface ComposioSessionLike {
+    sessionId: string;
+    tools: (modifiers?: unknown) => Promise<ComposioAgentTool[]>;
+    authorize: (toolkit: string, options?: {
+        callbackUrl?: string;
+    }) => Promise<ComposioConnectionRequestLike>;
+    toolkits: (options?: {
+        toolkits?: string[];
+        nextCursor?: string;
+        limit?: number;
+        isConnected?: boolean;
+        search?: string;
+    }) => Promise<ToolkitConnectionsDetails>;
+    search: (params: {
+        query: string;
+        toolkits?: string[];
+    }) => Promise<ToolRouterSessionSearchResponse>;
+    execute: (toolSlug: string, arguments_?: Record<string, unknown>) => Promise<{
+        data: Record<string, unknown>;
+        error: string | null;
+        logId: string;
+    }>;
+}
+export interface ComposioSdkLike {
+    create(userId: string, config?: ToolRouterCreateSessionConfig): Promise<ComposioSessionLike>;
+    tools: {
+        getRawComposioTools(filters: ToolListParams): Promise<ComposioRawToolListResponse>;
+        getRawComposioToolBySlug(slug: string): Promise<ComposioRawTool>;
+    };
+    connectedAccounts: {
+        list(query?: ConnectedAccountListParams): Promise<ConnectedAccountListResponse>;
+        refresh(nanoid: string, params?: Record<string, unknown> | null): Promise<Record<string, unknown>>;
+    };
+}
+export type ComposioClientFactory = (options: {
+    apiKey?: string;
+    provider: unknown;
+}) => ComposioSdkLike;
+export interface ComposioBaseOptions {
+    apiKey?: string;
+    getApiKey?: () => Promise<string | undefined> | string | undefined;
+    userId?: string;
+    resolveUserId?: () => Promise<string> | string;
+    manageConnections?: boolean;
+    clientFactory?: ComposioClientFactory;
+}
+export interface ComposioToolSelection {
+    toolkits?: string[];
+    toolSlugs?: string[];
+    authConfigs?: Record<string, string>;
+    connectedAccounts?: Record<string, string>;
+    authConfigId?: string;
+    connectedAccountId?: string;
+}
+export interface ComposioAgentToolsOptions extends ComposioBaseOptions, ComposioToolSelection {
+}
+export type ComposioEnableHandler = (tools: ComposioAgentTool[], metadata: ComposioToolMetadata[]) => Promise<void> | void;
+export interface ComposioServiceLike {
+    resolveUserId(): Promise<string>;
+    listToolkits(input: {
+        toolkits?: string[];
+        search?: string;
+        limit?: number;
+        nextCursor?: string;
+        isConnected?: boolean;
+    }): Promise<ToolkitConnectionsDetails>;
+    searchTools(query: string, toolkits?: string[]): Promise<ToolRouterSessionSearchResponse>;
+    listRawTools(filters: ToolListParams): Promise<ComposioToolListResult>;
+    getRawToolBySlug(slug: string): Promise<ComposioRawTool>;
+    createAgentTools(options: ComposioAgentToolsOptions): Promise<ComposioAgentTool[]>;
+    executeTool(options: ComposioAgentToolsOptions & {
+        toolSlug: string;
+        arguments?: Record<string, unknown>;
+    }): Promise<ComposioExecuteResult>;
+    connectAccount(options: {
+        toolkit?: string;
+        connectedAccountId?: string;
+        authConfigId?: string;
+        callbackUrl?: string;
+    }): Promise<ComposioConnectResult>;
+    listAccounts(filters?: ConnectedAccountListParams): Promise<ConnectedAccountListResponse>;
+}
+export interface ComposioToolFactoryOptions extends ComposioBaseOptions {
+    service?: ComposioServiceLike;
+    onEnable?: ComposioEnableHandler;
+}

package/dist/types/facade/bot/actions/crew/activity-tracker.d.ts

@@ -0,0 +1,65 @@
+import type { AgentEvent } from "../../types.js";
+export type TranscriptEntry = {
+    kind: "text";
+    text: string;
+    timestamp: number;
+} | {
+    kind: "tool_start";
+    toolName: string;
+    content: string | null;
+    summary: string | null;
+    timestamp: number;
+} | {
+    kind: "tool_end";
+    toolName: string;
+    content: string | null;
+    summary: string | null;
+    isError: boolean;
+    durationMs: number;
+    timestamp: number;
+} | {
+    kind: "turn_end";
+    turnNumber: number;
+    tokens: number;
+    timestamp: number;
+};
+export declare class TranscriptLog {
+    private entries;
+    push(entry: TranscriptEntry): void;
+    getEntries(): readonly TranscriptEntry[];
+    get length(): number;
+    reset(): void;
+}
+export declare class TranscriptTracker {
+    private logs;
+    private toolStarts;
+    private pendingText;
+    private turnCounts;
+    private lastTokens;
+    handleEvent(name: string, ev: AgentEvent): void;
+    get(name: string): TranscriptLog;
+    reset(name: string): void;
+    private getOrCreate;
+    private flushText;
+}
+type TrackedEventType = "tool_execution_start" | "tool_execution_end" | "agent_end" | "message_end";
+export interface TeammateActivity {
+    toolUseCount: number;
+    currentToolName: string | null;
+    lastToolName: string | null;
+    turnCount: number;
+    totalTokens: number;
+    recentEvents: Array<{
+        type: TrackedEventType;
+        toolName?: string;
+        timestamp: number;
+    }>;
+}
+export declare class ActivityTracker {
+    private data;
+    handleEvent(name: string, ev: AgentEvent): void;
+    get(name: string): TeammateActivity;
+    reset(name: string): void;
+    private getOrCreate;
+}
+export {};

package/dist/types/facade/bot/actions/crew/cleanup.d.ts

@@ -0,0 +1,50 @@
+import { type WorktreeCleanupResult } from "./worktree.js";
+export type CleanupResult = {
+    teamDir: string;
+    worktreeResult: WorktreeCleanupResult;
+    warnings: string[];
+};
+export declare function assertTeamDirWithinTeamsRoot(teamsRootDir: string, teamDir: string): {
+    teamsRootAbs: string;
+    teamDirAbs: string;
+};
+/**
+ * Recursively delete the given teamDir, including proper git worktree + branch removal.
+ *
+ * Steps:
+ * 1. Remove git worktrees and branches via `cleanupWorktrees`
+ * 2. Delete the team directory recursively
+ *
+ * Idempotent — safe to call multiple times.
+ */
+export declare function cleanupTeamDir(teamsRootDir: string, teamDir: string, opts?: {
+    teamId?: string;
+    repoCwd?: string;
+}): Promise<CleanupResult>;
+/**
+ * Garbage-collect stale team directories that have no active workers and are older
+ * than the given threshold.
+ *
+ * A team directory is considered stale when:
+ * - Its config.json `createdAt` (or directory mtime) is older than `maxAgeMs`
+ * - It has no in_progress tasks
+ * - It has no online members
+ *
+ * Returns a summary of what was cleaned up.
+ */
+export declare function gcStaleTeamDirs(opts: {
+    teamsRootDir: string;
+    maxAgeMs: number;
+    repoCwd?: string;
+    dryRun?: boolean;
+    /** Team IDs to skip (e.g. the current session's team). */
+    excludeTeamIds?: ReadonlySet<string>;
+}): Promise<{
+    scanned: number;
+    removed: string[];
+    skipped: Array<{
+        teamId: string;
+        reason: string;
+    }>;
+    warnings: string[];
+}>;

package/dist/types/facade/bot/actions/crew/fs-lock.d.ts

@@ -0,0 +1,11 @@
+export interface LockOptions {
+    /** How long to wait to acquire the lock before failing. */
+    timeoutMs?: number;
+    /** If lock file is older than this, consider it stale and remove it. */
+    staleMs?: number;
+    /** Poll interval while waiting for lock. */
+    pollMs?: number;
+    /** Optional label to help debugging (written into lock file). */
+    label?: string;
+}
+export declare function withLock<T>(lockFilePath: string, fn: () => Promise<T>, opts?: LockOptions): Promise<T>;

package/dist/types/facade/bot/actions/crew/index.d.ts

@@ -0,0 +1,11 @@
+export * from "./activity-tracker.js";
+export * from "./cleanup.js";
+export * from "./fs-lock.js";
+export * from "./mailbox.js";
+export * from "./model-policy.js";
+export * from "./names.js";
+export * from "./protocol.js";
+export * from "./task-store.js";
+export * from "./team-attach-claim.js";
+export * from "./team-config.js";
+export * from "./worktree.js";

package/dist/types/facade/bot/actions/crew/mailbox.d.ts

@@ -0,0 +1,20 @@
+export interface MailboxMessage {
+    from: string;
+    text: string;
+    timestamp: string;
+    read: boolean;
+    color?: string;
+    /** When true, the recipient should deliver this message as a steering interrupt
+     *  even if the agent is mid-turn, rather than queueing for the next idle window. */
+    urgent?: boolean;
+}
+export declare function getInboxPath(teamDir: string, namespace: string, agentName: string): string;
+/** Append a message to an agent's inbox. */
+export declare function writeToMailbox(teamDir: string, namespace: string, recipient: string, msg: Omit<MailboxMessage, "read"> & {
+    read?: boolean;
+}): Promise<void>;
+/**
+ * Read unread messages and mark them as read in a single locked transaction.
+ * This is the worker/leader poll primitive.
+ */
+export declare function popUnreadMessages(teamDir: string, namespace: string, agentName: string): Promise<MailboxMessage[]>;

package/dist/types/facade/bot/actions/crew/model-policy.d.ts

@@ -0,0 +1,22 @@
+export declare function isDeprecatedTeammateModelId(modelId: string): boolean;
+export type TeammateModelSource = "override" | "inherit_leader" | "default";
+export interface ResolvedTeammateModel {
+    source: TeammateModelSource;
+    provider?: string;
+    modelId?: string;
+    warnings: string[];
+}
+export type ResolveTeammateModelResult = {
+    ok: true;
+    value: ResolvedTeammateModel;
+} | {
+    ok: false;
+    error: string;
+    reason: "invalid_override" | "deprecated_override";
+};
+export declare function formatProviderModel(provider: string | undefined, modelId: string | undefined): string | null;
+export declare function resolveTeammateModelSelection(input: {
+    modelOverride?: string;
+    leaderProvider?: string;
+    leaderModelId?: string;
+}): ResolveTeammateModelResult;

package/dist/types/facade/bot/actions/crew/names.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Shared name sanitization.
+ *
+ * Must be stable across leader/worker/mailbox so file paths and mailbox ids match.
+ */
+export declare function sanitizeName(name: string): string;
+/** Pool of person names for auto-generated comrades (soviet style). */
+export declare const COMRADE_NAME_POOL: readonly string[];
+/** Pool of pirate-ish names for auto-generated mateys (pirate style). */
+export declare const PIRATE_NAME_POOL: readonly string[];
+/**
+ * Pick `count` names from the pool that aren't already taken.
+ * Falls back to `<name>-2`, `<name>-3` etc. if pool is exhausted.
+ */
+export declare function pickNamesFromPool(opts: {
+    pool: readonly string[];
+    count: number;
+    taken: ReadonlySet<string>;
+    fallbackBase: string;
+}): string[];
+export declare function pickComradeNames(count: number, taken: ReadonlySet<string>): string[];
+export declare function pickPirateNames(count: number, taken: ReadonlySet<string>): string[];
+/**
+ * Deterministic default names for normal style.
+ * Produces agent1, agent2, ... skipping taken.
+ */
+export declare function pickAgentNames(count: number, taken: ReadonlySet<string>): string[];

package/dist/types/facade/bot/actions/crew/protocol.d.ts

@@ -0,0 +1,74 @@
+import type { TeamTask } from "./task-store.js";
+export declare const TEAM_MAILBOX_NS = "team";
+export declare function taskAssignmentPayload(task: TeamTask, assignedBy: string): {
+    type: "task_assignment";
+    taskId: string;
+    subject: string;
+    description: string;
+    assignedBy: string;
+    timestamp: string;
+};
+export declare function isIdleNotification(text: string): {
+    from: string;
+    timestamp?: string;
+    completedTaskId?: string;
+    completedStatus?: string;
+    failureReason?: string;
+} | null;
+export declare function isShutdownApproved(text: string): {
+    from: string;
+    requestId: string;
+    timestamp?: string;
+} | null;
+export declare function isShutdownRejected(text: string): {
+    from: string;
+    requestId: string;
+    reason: string;
+    timestamp?: string;
+} | null;
+export declare function isPlanApprovalRequest(text: string): {
+    requestId: string;
+    from: string;
+    plan: string;
+    taskId?: string;
+    timestamp?: string;
+} | null;
+export declare function isPeerDmSent(text: string): {
+    from: string;
+    to: string;
+    summary: string;
+    timestamp?: string;
+} | null;
+export declare function isTaskAssignmentMessage(text: string): {
+    taskId: string;
+    subject?: string;
+    description?: string;
+    assignedBy?: string;
+} | null;
+export declare function isShutdownRequestMessage(text: string): {
+    requestId: string;
+    from?: string;
+    reason?: string;
+    timestamp?: string;
+} | null;
+export declare function isSetSessionNameMessage(text: string): {
+    name: string;
+} | null;
+export declare function isAbortRequestMessage(text: string): {
+    requestId: string;
+    from?: string;
+    taskId?: string;
+    reason?: string;
+    timestamp?: string;
+} | null;
+export declare function isPlanApprovedMessage(text: string): {
+    requestId: string;
+    from: string;
+    timestamp: string;
+} | null;
+export declare function isPlanRejectedMessage(text: string): {
+    requestId: string;
+    from: string;
+    feedback: string;
+    timestamp: string;
+} | null;