@cline/shared 0.0.38-nightly.1778113663

package/dist/storage/paths.d.ts

@@ -0,0 +1,86 @@
+export declare const AGENT_CONFIG_DIRECTORY_NAME = "agents";
+export declare const HOOKS_CONFIG_DIRECTORY_NAME = "hooks";
+export declare const SKILLS_CONFIG_DIRECTORY_NAME = "skills";
+export declare const RULES_CONFIG_DIRECTORY_NAME = "rules";
+export declare const WORKFLOWS_CONFIG_DIRECTORY_NAME = "workflows";
+export declare const PLUGINS_DIRECTORY_NAME = "plugins";
+export declare const CLINE_MCP_SETTINGS_FILE_NAME = "cline_mcp_settings.json";
+export declare function setHomeDir(dir: string): void;
+export declare function setHomeDirIfUnset(dir: string): void;
+export declare function setClineDir(dir: string): void;
+export declare function setClineDirIfUnset(dir: string): void;
+export declare function resolveClineDir(): string;
+export declare function resolveDocumentsClineDirectoryPath(): string;
+type DocumentsExtensionName = "Agents" | "Hooks" | "Rules" | "Workflows" | "Plugins";
+export declare function resolveDocumentsExtensionPath(name: DocumentsExtensionName): string;
+export declare function resolveClineDataDir(): string;
+export declare function resolveSessionDataDir(): string;
+export declare function resolveTeamDataDir(): string;
+export declare function resolveDbDataDir(): string;
+/**
+ * Path to the dedicated cron/automation database.
+ * Lives alongside `sessions.db` but is a separate file so cron lifecycle,
+ * retention, and query patterns stay decoupled from session storage.
+ */
+export declare function resolveCronDbPath(): string;
+export type CronSpecsScope = "global" | "workspace";
+export interface ResolveCronSpecsDirOptions {
+    /**
+     * Explicit specs directory. Useful for tests and for future hosts that want
+     * to provide their own merged/global/workspace cron source root.
+     */
+    cronSpecsDir?: string;
+    /** Defaults to `global`, i.e. `~/.cline/cron`. */
+    scope?: CronSpecsScope;
+    /** Required when `scope` is `workspace`. */
+    workspaceRoot?: string;
+}
+/**
+ * Global file-based cron spec authoring directory:
+ *   `~/.cline/cron/`
+ */
+export declare function resolveGlobalCronSpecsDir(): string;
+/**
+ * Workspace file-based cron spec authoring directory reserved for future
+ * workspace-scoped automation support:
+ *   `${workspaceRoot}/.cline/cron/`
+ */
+export declare function resolveWorkspaceCronSpecsDir(workspaceRoot: string): string;
+/**
+ * Directory containing file-based cron spec authoring.
+ *
+ * Default: global `~/.cline/cron/`.
+ * One-off: `*.md`
+ * Recurring: `*.cron.md`
+ * Event-driven: `events/*.event.md`
+ *
+ * A string argument is retained as a deprecated compatibility shorthand for
+ * workspace scope. New code should pass `{ scope: "workspace", workspaceRoot }`
+ * or use `resolveWorkspaceCronSpecsDir(workspaceRoot)` directly.
+ */
+export declare function resolveCronSpecsDir(workspaceRoot: string): string;
+export declare function resolveCronSpecsDir(options?: ResolveCronSpecsDirOptions): string;
+/** Directory where per-run markdown reports are written. */
+export declare function resolveCronReportsDir(workspaceRoot: string): string;
+export declare function resolveCronReportsDir(options?: ResolveCronSpecsDirOptions): string;
+/** Directory where event-spec files live inside the cron specs dir. */
+export declare function resolveCronEventsDir(workspaceRoot: string): string;
+export declare function resolveCronEventsDir(options?: ResolveCronSpecsDirOptions): string;
+export declare function resolveProviderSettingsPath(): string;
+export declare function resolveGlobalSettingsPath(): string;
+export declare function resolveMcpSettingsPath(): string;
+export declare function resolveAgentsConfigDirPath(): string;
+export declare function resolveAgentConfigSearchPaths(workspacePath?: string): string[];
+export declare function resolveHooksConfigSearchPaths(workspacePath?: string): string[];
+export declare function resolveSkillsConfigSearchPaths(workspacePath?: string): string[];
+export declare function resolveRulesConfigSearchPaths(workspacePath?: string): string[];
+export declare function resolveWorkflowsConfigSearchPaths(workspacePath?: string): string[];
+export declare function resolvePluginConfigSearchPaths(workspacePath?: string): string[];
+export declare function isPluginModulePath(path: string): boolean;
+export declare function resolvePluginModuleEntries(directoryPath: string): string[] | null;
+export declare function discoverPluginModulePaths(directoryPath: string): string[];
+export declare function resolveConfiguredPluginModulePaths(pluginPaths: ReadonlyArray<string>, cwd: string): string[];
+export declare function ensureParentDir(filePath: string): void;
+export declare function ensureFileExists(filePath: string): void;
+export declare function ensureHookLogDir(filePath?: string): string;
+export {};

package/dist/team/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./schema";
+export * from "./types";

package/dist/team/schema.d.ts

@@ -0,0 +1,411 @@
+/**
+ * Team tool schemas.
+ *
+ * Zod schemas, constants, and schema-derived types for the team tool surface.
+ */
+import { z } from "zod";
+export declare const DEFAULT_OUTCOME_REQUIRED_SECTIONS: string[];
+export declare const TEAM_AWAIT_TIMEOUT_MS: number;
+export declare const TEAM_RUN_MESSAGE_PREVIEW_LIMIT = 240;
+export declare const TEAM_RUN_TEXT_PREVIEW_LIMIT = 400;
+export declare const TeamTeammateSpecSchema: z.ZodObject<{
+    agentId: z.ZodString;
+    rolePrompt: z.ZodString;
+    modelId: z.ZodOptional<z.ZodString>;
+    maxIterations: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const TeamSpawnTeammateInputSchema: z.ZodObject<{
+    agentId: z.ZodString;
+    rolePrompt: z.ZodString;
+}, z.core.$strict>;
+export declare const TeamShutdownTeammateInputSchema: z.ZodObject<{
+    agentId: z.ZodString;
+    reason: z.ZodPreprocess<z.ZodOptional<z.ZodString>>;
+}, z.core.$strip>;
+export declare const TeamStatusInputSchema: z.ZodObject<{}, z.core.$strip>;
+type TeamTaskAction = "create" | "list" | "claim" | "complete" | "block";
+export declare const TEAM_TASK_IGNORED_FIELDS_BY_ACTION: Partial<Record<TeamTaskAction, readonly string[]>>;
+export declare const TeamTaskInputSchema: z.ZodObject<{
+    action: z.ZodEnum<{
+        create: "create";
+        list: "list";
+        claim: "claim";
+        complete: "complete";
+        block: "block";
+    }>;
+    title: z.ZodPreprocess<z.ZodOptional<z.ZodString>>;
+    description: z.ZodPreprocess<z.ZodOptional<z.ZodString>>;
+    dependsOn: z.ZodPreprocess<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    assignee: z.ZodPreprocess<z.ZodOptional<z.ZodString>>;
+    status: z.ZodPreprocess<z.ZodOptional<z.ZodEnum<{
+        completed: "completed";
+        pending: "pending";
+        in_progress: "in_progress";
+        blocked: "blocked";
+    }>>>;
+    taskId: z.ZodPreprocess<z.ZodOptional<z.ZodString>>;
+    summary: z.ZodPreprocess<z.ZodOptional<z.ZodString>>;
+    reason: z.ZodPreprocess<z.ZodOptional<z.ZodString>>;
+}, z.core.$strip>;
+export declare const TeamRunTaskInputSchema: z.ZodObject<{
+    agentId: z.ZodString;
+    task: z.ZodString;
+    taskId: z.ZodPreprocess<z.ZodOptional<z.ZodString>>;
+    runMode: z.ZodPreprocess<z.ZodOptional<z.ZodEnum<{
+        sync: "sync";
+        async: "async";
+    }>>>;
+    continueConversation: z.ZodPreprocess<z.ZodOptional<z.ZodBoolean>>;
+}, z.core.$strip>;
+export declare const TeamListRunsInputSchema: z.ZodObject<{
+    status: z.ZodPreprocess<z.ZodOptional<z.ZodEnum<{
+        running: "running";
+        completed: "completed";
+        failed: "failed";
+        cancelled: "cancelled";
+        queued: "queued";
+        interrupted: "interrupted";
+    }>>>;
+    agentId: z.ZodPreprocess<z.ZodOptional<z.ZodString>>;
+    includeCompleted: z.ZodPreprocess<z.ZodOptional<z.ZodBoolean>>;
+}, z.core.$strip>;
+export declare const TeamCancelRunInputSchema: z.ZodObject<{
+    runId: z.ZodString;
+    reason: z.ZodPreprocess<z.ZodOptional<z.ZodString>>;
+}, z.core.$strip>;
+export declare const TeamAwaitRunsInputSchema: z.ZodObject<{
+    runId: z.ZodPreprocess<z.ZodOptional<z.ZodString>>;
+}, z.core.$strict>;
+export declare const TeamSendMessageInputSchema: z.ZodObject<{
+    toAgentId: z.ZodString;
+    subject: z.ZodString;
+    body: z.ZodString;
+    taskId: z.ZodPreprocess<z.ZodOptional<z.ZodString>>;
+}, z.core.$strip>;
+export declare const TeamBroadcastInputSchema: z.ZodObject<{
+    subject: z.ZodString;
+    body: z.ZodString;
+    taskId: z.ZodPreprocess<z.ZodOptional<z.ZodString>>;
+}, z.core.$strip>;
+export declare const TeamReadMailboxInputSchema: z.ZodObject<{
+    unreadOnly: z.ZodPreprocess<z.ZodOptional<z.ZodBoolean>>;
+}, z.core.$strip>;
+export declare const TeamMissionLogInputSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        error: "error";
+        done: "done";
+        blocked: "blocked";
+        progress: "progress";
+        handoff: "handoff";
+        decision: "decision";
+    }>;
+    summary: z.ZodString;
+    taskId: z.ZodPreprocess<z.ZodOptional<z.ZodString>>;
+    evidence: z.ZodPreprocess<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    nextAction: z.ZodPreprocess<z.ZodOptional<z.ZodString>>;
+}, z.core.$strip>;
+export declare const TeamCleanupInputSchema: z.ZodObject<{}, z.core.$strip>;
+export declare const TeamCreateOutcomeInputSchema: z.ZodObject<{
+    title: z.ZodString;
+    requiredSections: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const TeamAttachOutcomeFragmentInputSchema: z.ZodObject<{
+    outcomeId: z.ZodString;
+    section: z.ZodString;
+    sourceRunId: z.ZodPreprocess<z.ZodOptional<z.ZodString>>;
+    content: z.ZodString;
+}, z.core.$strip>;
+export declare const TeamReviewOutcomeFragmentInputSchema: z.ZodObject<{
+    fragmentId: z.ZodString;
+    approved: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const TeamFinalizeOutcomeInputSchema: z.ZodObject<{
+    outcomeId: z.ZodString;
+}, z.core.$strip>;
+export declare const TeamListOutcomesInputSchema: z.ZodObject<{}, z.core.$strip>;
+export type TeamSpawnTeammateInput = z.infer<typeof TeamSpawnTeammateInputSchema>;
+export type TeamShutdownTeammateInput = z.infer<typeof TeamShutdownTeammateInputSchema>;
+export type TeamStatusInput = z.infer<typeof TeamStatusInputSchema>;
+export type TeamTaskInput = z.infer<typeof TeamTaskInputSchema>;
+export type TeamRunTaskInput = z.infer<typeof TeamRunTaskInputSchema>;
+export type TeamListRunsInput = z.infer<typeof TeamListRunsInputSchema>;
+export type TeamCancelRunInput = z.infer<typeof TeamCancelRunInputSchema>;
+export type TeamAwaitRunsInput = z.infer<typeof TeamAwaitRunsInputSchema>;
+export type TeamSendMessageInput = z.infer<typeof TeamSendMessageInputSchema>;
+export type TeamBroadcastInput = z.infer<typeof TeamBroadcastInputSchema>;
+export type TeamReadMailboxInput = z.infer<typeof TeamReadMailboxInputSchema>;
+export type TeamMissionLogInput = z.infer<typeof TeamMissionLogInputSchema>;
+export type TeamCleanupInput = z.infer<typeof TeamCleanupInputSchema>;
+export type TeamCreateOutcomeInput = z.infer<typeof TeamCreateOutcomeInputSchema>;
+export type TeamAttachOutcomeFragmentInput = z.infer<typeof TeamAttachOutcomeFragmentInputSchema>;
+export type TeamReviewOutcomeFragmentInput = z.infer<typeof TeamReviewOutcomeFragmentInputSchema>;
+export type TeamFinalizeOutcomeInput = z.infer<typeof TeamFinalizeOutcomeInputSchema>;
+export type TeamListOutcomesInput = z.infer<typeof TeamListOutcomesInputSchema>;
+export type TeamTeammateSpec = z.infer<typeof TeamTeammateSpecSchema>;
+export declare const TeamStatusToolResultSchema: z.ZodObject<{
+    teamId: z.ZodString;
+    teamName: z.ZodString;
+    members: z.ZodArray<z.ZodObject<{
+        agentId: z.ZodString;
+        role: z.ZodEnum<{
+            lead: "lead";
+            teammate: "teammate";
+        }>;
+        description: z.ZodOptional<z.ZodString>;
+        status: z.ZodEnum<{
+            idle: "idle";
+            running: "running";
+            stopped: "stopped";
+        }>;
+    }, z.core.$strip>>;
+    taskCounts: z.ZodRecord<z.ZodEnum<{
+        completed: "completed";
+        pending: "pending";
+        in_progress: "in_progress";
+        blocked: "blocked";
+    }>, z.ZodNumber>;
+    unreadMessages: z.ZodNumber;
+    missionLogEntries: z.ZodNumber;
+    activeRuns: z.ZodNumber;
+    queuedRuns: z.ZodNumber;
+    outcomeCounts: z.ZodRecord<z.ZodEnum<{
+        draft: "draft";
+        in_review: "in_review";
+        finalized: "finalized";
+    }>, z.ZodNumber>;
+}, z.core.$strip>;
+export declare const TeamTaskListItemToolResultSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodString;
+    status: z.ZodEnum<{
+        completed: "completed";
+        pending: "pending";
+        in_progress: "in_progress";
+        blocked: "blocked";
+    }>;
+    createdAt: z.ZodPreprocess<z.ZodString>;
+    updatedAt: z.ZodPreprocess<z.ZodString>;
+    createdBy: z.ZodString;
+    assignee: z.ZodOptional<z.ZodString>;
+    dependsOn: z.ZodArray<z.ZodString>;
+    summary: z.ZodOptional<z.ZodString>;
+    isReady: z.ZodBoolean;
+    blockedBy: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare const TeamTaskToolResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    action: z.ZodLiteral<"create">;
+    taskId: z.ZodString;
+    status: z.ZodEnum<{
+        completed: "completed";
+        pending: "pending";
+        in_progress: "in_progress";
+        blocked: "blocked";
+    }>;
+    ignoredFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    note: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"list">;
+    tasks: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        description: z.ZodString;
+        status: z.ZodEnum<{
+            completed: "completed";
+            pending: "pending";
+            in_progress: "in_progress";
+            blocked: "blocked";
+        }>;
+        createdAt: z.ZodPreprocess<z.ZodString>;
+        updatedAt: z.ZodPreprocess<z.ZodString>;
+        createdBy: z.ZodString;
+        assignee: z.ZodOptional<z.ZodString>;
+        dependsOn: z.ZodArray<z.ZodString>;
+        summary: z.ZodOptional<z.ZodString>;
+        isReady: z.ZodBoolean;
+        blockedBy: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"claim">;
+    taskId: z.ZodString;
+    status: z.ZodEnum<{
+        completed: "completed";
+        pending: "pending";
+        in_progress: "in_progress";
+        blocked: "blocked";
+    }>;
+    nextStep: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"complete">;
+    taskId: z.ZodString;
+    status: z.ZodEnum<{
+        completed: "completed";
+        pending: "pending";
+        in_progress: "in_progress";
+        blocked: "blocked";
+    }>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"block">;
+    taskId: z.ZodString;
+    status: z.ZodEnum<{
+        completed: "completed";
+        pending: "pending";
+        in_progress: "in_progress";
+        blocked: "blocked";
+    }>;
+}, z.core.$strip>], "action">;
+export declare const TeamRunTaskToolResultSchema: z.ZodObject<{
+    agentId: z.ZodString;
+    mode: z.ZodEnum<{
+        sync: "sync";
+        async: "async";
+    }>;
+    status: z.ZodEnum<{
+        running: "running";
+        queued: "queued";
+        dispatched: "dispatched";
+        joined: "joined";
+    }>;
+    dispatched: z.ZodBoolean;
+    message: z.ZodString;
+    deduped: z.ZodOptional<z.ZodBoolean>;
+    runId: z.ZodOptional<z.ZodString>;
+    text: z.ZodOptional<z.ZodString>;
+    iterations: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const TeamRunResultSummarySchema: z.ZodObject<{
+    textPreview: z.ZodString;
+    iterations: z.ZodNumber;
+    finishReason: z.ZodString;
+    durationMs: z.ZodNumber;
+    usage: z.ZodObject<{
+        inputTokens: z.ZodNumber;
+        outputTokens: z.ZodNumber;
+        cacheReadTokens: z.ZodOptional<z.ZodNumber>;
+        cacheWriteTokens: z.ZodOptional<z.ZodNumber>;
+        totalCost: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const TeamRunToolSummarySchema: z.ZodObject<{
+    id: z.ZodString;
+    agentId: z.ZodString;
+    taskId: z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<{
+        running: "running";
+        completed: "completed";
+        failed: "failed";
+        cancelled: "cancelled";
+        queued: "queued";
+        interrupted: "interrupted";
+    }>;
+    messagePreview: z.ZodString;
+    priority: z.ZodNumber;
+    retryCount: z.ZodNumber;
+    maxRetries: z.ZodNumber;
+    nextAttemptAt: z.ZodOptional<z.ZodPreprocess<z.ZodString>>;
+    continueConversation: z.ZodOptional<z.ZodBoolean>;
+    startedAt: z.ZodPreprocess<z.ZodString>;
+    endedAt: z.ZodOptional<z.ZodPreprocess<z.ZodString>>;
+    leaseOwner: z.ZodOptional<z.ZodString>;
+    heartbeatAt: z.ZodOptional<z.ZodPreprocess<z.ZodString>>;
+    lastProgressAt: z.ZodOptional<z.ZodPreprocess<z.ZodString>>;
+    lastProgressMessage: z.ZodOptional<z.ZodString>;
+    currentActivity: z.ZodOptional<z.ZodString>;
+    error: z.ZodOptional<z.ZodString>;
+    resultSummary: z.ZodOptional<z.ZodObject<{
+        textPreview: z.ZodString;
+        iterations: z.ZodNumber;
+        finishReason: z.ZodString;
+        durationMs: z.ZodNumber;
+        usage: z.ZodObject<{
+            inputTokens: z.ZodNumber;
+            outputTokens: z.ZodNumber;
+            cacheReadTokens: z.ZodOptional<z.ZodNumber>;
+            cacheWriteTokens: z.ZodOptional<z.ZodNumber>;
+            totalCost: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const TeamMailboxMessageToolResultSchema: z.ZodObject<{
+    id: z.ZodString;
+    teamId: z.ZodString;
+    fromAgentId: z.ZodString;
+    toAgentId: z.ZodString;
+    subject: z.ZodString;
+    body: z.ZodString;
+    taskId: z.ZodOptional<z.ZodString>;
+    sentAt: z.ZodPreprocess<z.ZodString>;
+    readAt: z.ZodOptional<z.ZodPreprocess<z.ZodString>>;
+}, z.core.$strip>;
+export declare const TeamOutcomeToolResultSchema: z.ZodObject<{
+    id: z.ZodString;
+    teamId: z.ZodString;
+    title: z.ZodString;
+    status: z.ZodEnum<{
+        draft: "draft";
+        in_review: "in_review";
+        finalized: "finalized";
+    }>;
+    requiredSections: z.ZodArray<z.ZodString>;
+    createdBy: z.ZodString;
+    createdAt: z.ZodPreprocess<z.ZodString>;
+    finalizedAt: z.ZodOptional<z.ZodPreprocess<z.ZodString>>;
+}, z.core.$strip>;
+export declare const TeamCreateOutcomeToolResultSchema: z.ZodObject<{
+    outcomeId: z.ZodString;
+    status: z.ZodEnum<{
+        draft: "draft";
+        in_review: "in_review";
+        finalized: "finalized";
+    }>;
+    requiredSections: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare const TeamSimpleAgentStatusToolResultSchema: z.ZodObject<{
+    agentId: z.ZodString;
+    status: z.ZodString;
+}, z.core.$strip>;
+export declare const TeamCancelRunToolResultSchema: z.ZodObject<{
+    runId: z.ZodString;
+    status: z.ZodEnum<{
+        running: "running";
+        completed: "completed";
+        failed: "failed";
+        cancelled: "cancelled";
+        queued: "queued";
+        interrupted: "interrupted";
+    }>;
+}, z.core.$strip>;
+export declare const TeamSendMessageToolResultSchema: z.ZodObject<{
+    id: z.ZodString;
+    toAgentId: z.ZodString;
+}, z.core.$strip>;
+export declare const TeamBroadcastToolResultSchema: z.ZodObject<{
+    delivered: z.ZodNumber;
+}, z.core.$strip>;
+export declare const TeamMissionLogToolResultSchema: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>;
+export declare const TeamCleanupToolResultSchema: z.ZodObject<{
+    status: z.ZodString;
+}, z.core.$strip>;
+export declare const TeamOutcomeFragmentToolResultSchema: z.ZodObject<{
+    fragmentId: z.ZodString;
+    status: z.ZodString;
+}, z.core.$strip>;
+export declare const TeamFinalizeOutcomeToolResultSchema: z.ZodObject<{
+    outcomeId: z.ZodString;
+    status: z.ZodEnum<{
+        draft: "draft";
+        in_review: "in_review";
+        finalized: "finalized";
+    }>;
+}, z.core.$strip>;
+export type TeamRunResultSummary = z.infer<typeof TeamRunResultSummarySchema>;
+export type TeamRunToolSummary = z.infer<typeof TeamRunToolSummarySchema>;
+export type TeamTaskToolResult = z.infer<typeof TeamTaskToolResultSchema>;
+export type TeamRunTaskToolResult = z.infer<typeof TeamRunTaskToolResultSchema>;
+export type TeamStatusToolResult = z.infer<typeof TeamStatusToolResultSchema>;
+export type TeamMailboxMessageToolResult = z.infer<typeof TeamMailboxMessageToolResultSchema>;
+export type TeamOutcomeToolResult = z.infer<typeof TeamOutcomeToolResultSchema>;
+export type TeamCreateOutcomeToolResult = z.infer<typeof TeamCreateOutcomeToolResultSchema>;
+export {};

package/dist/team/types.d.ts

@@ -0,0 +1,196 @@
+/**
+ * Team data types and interfaces.
+ *
+ * These are the pure data-shape contracts for the multi-agent team system.
+ * They intentionally avoid referencing @cline/agents types so that shared
+ * can remain dependency-free of the agents package.
+ */
+export type TeamTaskStatus = "pending" | "in_progress" | "blocked" | "completed";
+export interface TeamTask {
+    id: string;
+    title: string;
+    description: string;
+    status: TeamTaskStatus;
+    createdAt: Date;
+    updatedAt: Date;
+    createdBy: string;
+    assignee?: string;
+    dependsOn: string[];
+    summary?: string;
+}
+export interface TeamTaskListItem extends TeamTask {
+    isReady: boolean;
+    blockedBy: string[];
+}
+export type MissionLogKind = "progress" | "handoff" | "blocked" | "decision" | "done" | "error";
+export interface MissionLogEntry {
+    id: string;
+    ts: Date;
+    teamId: string;
+    agentId: string;
+    taskId?: string;
+    kind: MissionLogKind;
+    summary: string;
+    evidence?: string[];
+    nextAction?: string;
+}
+export interface TeamMailboxMessage {
+    id: string;
+    teamId: string;
+    fromAgentId: string;
+    toAgentId: string;
+    subject: string;
+    body: string;
+    taskId?: string;
+    sentAt: Date;
+    readAt?: Date;
+}
+export interface TeamMemberSnapshot {
+    agentId: string;
+    role: "lead" | "teammate";
+    description?: string;
+    status: "idle" | "running" | "stopped";
+}
+export interface TeammateLifecycleSpec {
+    rolePrompt: string;
+    modelId?: string;
+    maxIterations?: number;
+    runtimeAgentId?: string;
+    conversationId?: string;
+    parentAgentId?: string | null;
+}
+export type TeamRunStatus = "queued" | "running" | "completed" | "failed" | "cancelled" | "interrupted";
+/**
+ * Shared representation of a teammate run record.
+ *
+ * The `result` field is typed as `unknown` at the shared contract level
+ * because the concrete type (`AgentResult`) lives in `@cline/agents`.
+ * Consuming packages narrow this via their own type assertions.
+ */
+export interface TeamRunRecord {
+    id: string;
+    agentId: string;
+    taskId?: string;
+    status: TeamRunStatus;
+    message: string;
+    priority: number;
+    retryCount: number;
+    maxRetries: number;
+    nextAttemptAt?: Date;
+    continueConversation?: boolean;
+    startedAt: Date;
+    endedAt?: Date;
+    leaseOwner?: string;
+    heartbeatAt?: Date;
+    lastProgressAt?: Date;
+    lastProgressMessage?: string;
+    currentActivity?: string;
+    result?: unknown;
+    error?: string;
+}
+export type TeamOutcomeStatus = "draft" | "in_review" | "finalized";
+export interface TeamOutcome {
+    id: string;
+    teamId: string;
+    title: string;
+    status: TeamOutcomeStatus;
+    requiredSections: string[];
+    createdBy: string;
+    createdAt: Date;
+    finalizedAt?: Date;
+}
+export type TeamOutcomeFragmentStatus = "draft" | "reviewed" | "rejected";
+export interface TeamOutcomeFragment {
+    id: string;
+    teamId: string;
+    outcomeId: string;
+    section: string;
+    sourceAgentId: string;
+    sourceRunId?: string;
+    content: string;
+    status: TeamOutcomeFragmentStatus;
+    reviewedBy?: string;
+    reviewedAt?: Date;
+    createdAt: Date;
+}
+export interface TeamRuntimeSnapshot {
+    teamId: string;
+    teamName: string;
+    members: TeamMemberSnapshot[];
+    taskCounts: Record<TeamTaskStatus, number>;
+    unreadMessages: number;
+    missionLogEntries: number;
+    activeRuns: number;
+    queuedRuns: number;
+    outcomeCounts: Record<TeamOutcomeStatus, number>;
+}
+export interface TeamRuntimeState {
+    teamId: string;
+    teamName: string;
+    members: TeamMemberSnapshot[];
+    tasks: TeamTask[];
+    mailbox: TeamMailboxMessage[];
+    missionLog: MissionLogEntry[];
+    runs: TeamRunRecord[];
+    outcomes: TeamOutcome[];
+    outcomeFragments: TeamOutcomeFragment[];
+}
+export interface AppendMissionLogInput {
+    agentId: string;
+    taskId?: string;
+    kind: MissionLogKind;
+    summary: string;
+    evidence?: string[];
+    nextAction?: string;
+}
+export interface CreateTeamTaskInput {
+    title: string;
+    description: string;
+    createdBy: string;
+    dependsOn?: string[];
+    assignee?: string;
+}
+export interface CreateTeamOutcomeInput {
+    title: string;
+    requiredSections: string[];
+    createdBy: string;
+}
+export interface AttachTeamOutcomeFragmentInput {
+    outcomeId: string;
+    section: string;
+    sourceAgentId: string;
+    sourceRunId?: string;
+    content: string;
+}
+export interface ReviewTeamOutcomeFragmentInput {
+    fragmentId: string;
+    reviewedBy: string;
+    approved: boolean;
+}
+export interface RouteToTeammateOptions {
+    taskId?: string;
+    fromAgentId?: string;
+    continueConversation?: boolean;
+}
+export declare enum TeamMessageType {
+    TaskStart = "task_start",
+    TaskEnd = "task_end",
+    AgentEvent = "agent_event",
+    TeammateSpawned = "teammate_spawned",
+    TeammateShutdown = "teammate_shutdown",
+    TeamTaskUpdated = "team_task_updated",
+    TeamMessage = "team_message",
+    TeamMissionLog = "team_mission_log",
+    TeamTaskCompleted = "team_task_completed",
+    RunStarted = "run_started",
+    RunQueued = "run_queued",
+    RunProgress = "run_progress",
+    RunCompleted = "run_completed",
+    RunFailed = "run_failed",
+    RunCancelled = "run_cancelled",
+    RunInterrupted = "run_interrupted",
+    OutcomeCreated = "outcome_created",
+    OutcomeFragmentAttached = "outcome_fragment_attached",
+    OutcomeFragmentReviewed = "outcome_fragment_reviewed",
+    OutcomeFinalized = "outcome_finalized"
+}