indusagi 0.13.7 → 0.13.8

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;

package/dist/types/facade/bot/actions/crew/task-store.d.ts

@@ -0,0 +1,88 @@
+export type TaskStatus = "pending" | "in_progress" | "completed";
+export interface TeamTask {
+    id: string;
+    subject: string;
+    description: string;
+    owner?: string;
+    status: TaskStatus;
+    blocks: string[];
+    blockedBy: string[];
+    metadata?: Record<string, unknown>;
+    createdAt: string;
+    updatedAt: string;
+}
+export declare function getTaskListDir(teamDir: string, taskListId: string): string;
+export declare function shortTaskId(id: string): string;
+export declare function formatTaskLine(t: TeamTask, opts?: {
+    blocked?: boolean;
+}): string;
+export declare function listTasks(teamDir: string, taskListId: string): Promise<TeamTask[]>;
+export declare function getTask(teamDir: string, taskListId: string, taskId: string): Promise<TeamTask | null>;
+export declare function createTask(teamDir: string, taskListId: string, input: {
+    subject: string;
+    description: string;
+    owner?: string;
+}): Promise<TeamTask>;
+export declare function updateTask(teamDir: string, taskListId: string, taskId: string, updater: (current: TeamTask) => TeamTask): Promise<TeamTask | null>;
+export declare function isTaskBlocked(teamDir: string, taskListId: string, task: TeamTask): Promise<boolean>;
+export declare function agentHasActiveTask(teamDir: string, taskListId: string, agentName: string): Promise<boolean>;
+/**
+ * Claim a specific task (owner must be empty).
+ * Returns the updated task if claim succeeded, otherwise null.
+ */
+export declare function claimTask(teamDir: string, taskListId: string, taskId: string, agentName: string, opts?: {
+    checkAgentBusy?: boolean;
+}): Promise<TeamTask | null>;
+/**
+ * Start an assigned task (owner matches), marking it in_progress.
+ */
+export declare function startAssignedTask(teamDir: string, taskListId: string, taskId: string, agentName: string): Promise<TeamTask | null>;
+export declare function completeTask(teamDir: string, taskListId: string, taskId: string, agentName: string, result?: string): Promise<TeamTask | null>;
+export declare function unassignTask(teamDir: string, taskListId: string, taskId: string, agentName: string, reason?: string, extraMetadata?: Record<string, unknown>): Promise<TeamTask | null>;
+/** Reset all non-completed tasks owned by agent back to pending + unowned. */
+export declare function unassignTasksForAgent(teamDir: string, taskListId: string, agentName: string, reason?: string): Promise<number>;
+/**
+ * Find and claim the first available task:
+ * - pending
+ * - unowned
+ * - unblocked
+ */
+export declare function claimNextAvailableTask(teamDir: string, taskListId: string, agentName: string, opts?: {
+    checkAgentBusy?: boolean;
+}): Promise<TeamTask | null>;
+export type TaskDependencyOpResult = {
+    ok: true;
+    task: TeamTask;
+    dependency: TeamTask;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Add a dependency edge: taskId is blockedBy depId (and depId blocks taskId).
+ */
+export declare function addTaskDependency(teamDir: string, taskListId: string, taskId: string, depId: string): Promise<TaskDependencyOpResult>;
+/**
+ * Remove dependency edge: taskId no longer blockedBy depId (and depId no longer blocks taskId).
+ */
+export declare function removeTaskDependency(teamDir: string, taskListId: string, taskId: string, depId: string): Promise<TaskDependencyOpResult>;
+export type TaskClearMode = "completed" | "all";
+export interface ClearTasksResult {
+    mode: TaskClearMode;
+    taskListId: string;
+    taskListDir: string;
+    deletedTaskIds: string[];
+    skippedTaskIds: string[];
+    errors: Array<{
+        file: string;
+        error: string;
+    }>;
+}
+/**
+ * Delete task JSON files from the task list directory.
+ *
+ * Safety properties:
+ * - Only deletes `*.json` files inside `<teamDir>/tasks/<taskListId>/`.
+ * - Refuses to operate if the resolved task list directory is not within `teamDir`.
+ */
+export declare function clearTasks(teamDir: string, taskListId: string, mode?: TaskClearMode): Promise<ClearTasksResult>;

package/dist/types/facade/bot/actions/crew/team-attach-claim.d.ts

@@ -0,0 +1,35 @@
+export declare const TEAM_ATTACH_CLAIM_FILE = ".attach-claim.json";
+export declare const TEAM_ATTACH_CLAIM_STALE_MS = 30000;
+export interface TeamAttachClaim {
+    holderSessionId: string;
+    claimedAt: string;
+    heartbeatAt: string;
+    pid: number;
+}
+export declare function assessAttachClaimFreshness(claim: TeamAttachClaim, nowMs?: number, staleMs?: number): {
+    isStale: boolean;
+    ageMs: number;
+};
+export declare function readTeamAttachClaim(teamDir: string): Promise<TeamAttachClaim | null>;
+export type AcquireTeamAttachClaimResult = {
+    ok: true;
+    claim: TeamAttachClaim;
+    replacedClaim?: TeamAttachClaim;
+} | {
+    ok: false;
+    reason: "claimed_by_other";
+    claim: TeamAttachClaim;
+};
+export declare function acquireTeamAttachClaim(teamDir: string, holderSessionId: string, opts?: {
+    force?: boolean;
+    staleMs?: number;
+    nowMs?: number;
+}): Promise<AcquireTeamAttachClaimResult>;
+export type TeamAttachClaimHeartbeatResult = "updated" | "not_owner" | "missing";
+export declare function heartbeatTeamAttachClaim(teamDir: string, holderSessionId: string, opts?: {
+    nowMs?: number;
+}): Promise<TeamAttachClaimHeartbeatResult>;
+export type TeamAttachClaimReleaseResult = "released" | "not_owner" | "none";
+export declare function releaseTeamAttachClaim(teamDir: string, holderSessionId: string, opts?: {
+    force?: boolean;
+}): Promise<TeamAttachClaimReleaseResult>;

package/dist/types/facade/bot/actions/crew/team-config.d.ts

@@ -0,0 +1,54 @@
+export type TeamsStyle = string;
+export interface TeamMember {
+    name: string;
+    role: "lead" | "worker";
+    addedAt: string;
+    status: "online" | "offline";
+    lastSeenAt?: string;
+    /** Optional: teammate session file path (useful for debugging) */
+    sessionFile?: string;
+    /** Optional: teammate working directory */
+    cwd?: string;
+    /** Freeform metadata for future use */
+    meta?: Record<string, unknown>;
+}
+export type TeamHooksFailureAction = "warn" | "followup" | "reopen" | "reopen_followup";
+export type TeamHooksFollowupOwnerPolicy = "member" | "lead" | "none";
+export interface TeamHooksPolicy {
+    failureAction?: TeamHooksFailureAction;
+    maxReopensPerTask?: number;
+    followupOwner?: TeamHooksFollowupOwnerPolicy;
+}
+export interface TeamConfig {
+    version: 1;
+    teamId: string;
+    /** Task list namespace identifier (Claude-style: often teamName or parentSessionId) */
+    taskListId: string;
+    /** Internal leader agent id (mailbox name, member name, etc.) */
+    leadName: string;
+    /** Optional UI/UX style. If omitted, treat as "normal". */
+    style?: TeamsStyle;
+    /** Optional per-team hooks policy override (env remains fallback). */
+    hooks?: TeamHooksPolicy;
+    createdAt: string;
+    updatedAt: string;
+    members: TeamMember[];
+}
+export declare function getTeamConfigPath(teamDir: string): string;
+export declare function loadTeamConfig(teamDir: string): Promise<TeamConfig | null>;
+export declare function ensureTeamConfig(teamDir: string, init: {
+    teamId: string;
+    taskListId: string;
+    leadName: string;
+    style?: TeamsStyle;
+}): Promise<TeamConfig>;
+export declare function setTeamStyle(teamDir: string, style: TeamsStyle): Promise<TeamConfig | null>;
+export declare function updateTeamHooksPolicy(teamDir: string, updater: (current: TeamHooksPolicy) => TeamHooksPolicy | undefined): Promise<TeamConfig | null>;
+export declare function upsertMember(teamDir: string, member: Omit<TeamMember, "name" | "addedAt"> & {
+    name: string;
+    addedAt?: string;
+}): Promise<TeamConfig>;
+export declare function setMemberStatus(teamDir: string, memberName: string, status: "online" | "offline", extra?: {
+    lastSeenAt?: string;
+    meta?: Record<string, unknown>;
+}): Promise<TeamConfig | null>;