@levelcode/sdk 0.2.2 → 0.2.4

package/dist/common/src/util/file.d.ts

@@ -0,0 +1,133 @@
+import { z } from 'zod/v4';
+import type { LevelCodeFileSystem } from '../types/filesystem';
+import type { SkillsMap } from '../types/skill';
+export declare const FileTreeNodeSchema: z.ZodType<FileTreeNode>;
+export interface FileTreeNode {
+    name: string;
+    type: 'file' | 'directory';
+    filePath: string;
+    lastReadTime?: number;
+    children?: FileTreeNode[];
+}
+export interface DirectoryNode extends FileTreeNode {
+    type: 'directory';
+    children: FileTreeNode[];
+}
+export interface FileNode extends FileTreeNode {
+    type: 'file';
+    lastReadTime: number;
+}
+export declare const FileVersionSchema: z.ZodObject<{
+    path: z.ZodString;
+    content: z.ZodString;
+}, z.core.$strip>;
+export type FileVersion = z.infer<typeof FileVersionSchema>;
+export declare const customToolDefinitionsSchema: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+    inputSchema: z.ZodCustom<Record<string, unknown> | z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, Record<string, unknown> | z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+    endsAgentStep: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    description: z.ZodOptional<z.ZodString>;
+    exampleInputs: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodAny>>>;
+}, z.core.$strip>>>;
+export type CustomToolDefinitions = NonNullable<z.input<typeof customToolDefinitionsSchema>>;
+export declare const ProjectFileContextSchema: z.ZodObject<{
+    projectRoot: z.ZodString;
+    cwd: z.ZodString;
+    fileTree: z.ZodArray<z.ZodCustom<FileTreeNode, FileTreeNode>>;
+    fileTokenScores: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    tokenCallers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>>;
+    knowledgeFiles: z.ZodRecord<z.ZodString, z.ZodString>;
+    userKnowledgeFiles: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    agentTemplates: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    customToolDefinitions: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        inputSchema: z.ZodCustom<Record<string, unknown> | z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, Record<string, unknown> | z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        endsAgentStep: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        description: z.ZodOptional<z.ZodString>;
+        exampleInputs: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodAny>>>;
+    }, z.core.$strip>>>;
+    skills: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    gitChanges: z.ZodObject<{
+        status: z.ZodString;
+        diff: z.ZodString;
+        diffCached: z.ZodString;
+        lastCommitMessages: z.ZodString;
+    }, z.core.$strip>;
+    changesSinceLastChat: z.ZodRecord<z.ZodString, z.ZodString>;
+    shellConfigFiles: z.ZodRecord<z.ZodString, z.ZodString>;
+    systemInfo: z.ZodObject<{
+        platform: z.ZodString;
+        shell: z.ZodString;
+        nodeVersion: z.ZodString;
+        arch: z.ZodString;
+        homedir: z.ZodString;
+        cpus: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type ProjectFileContext = {
+    projectRoot: string;
+    cwd: string;
+    fileTree: FileTreeNode[];
+    fileTokenScores: Record<string, Record<string, number>>;
+    tokenCallers?: Record<string, Record<string, string[]>>;
+    knowledgeFiles: Record<string, string>;
+    userKnowledgeFiles?: Record<string, string>;
+    agentTemplates: Record<string, any>;
+    customToolDefinitions: CustomToolDefinitions;
+    skills?: SkillsMap;
+    gitChanges: {
+        status: string;
+        diff: string;
+        diffCached: string;
+        lastCommitMessages: string;
+    };
+    changesSinceLastChat: Record<string, string>;
+    shellConfigFiles: Record<string, string>;
+    systemInfo: {
+        platform: string;
+        shell: string;
+        nodeVersion: string;
+        arch: string;
+        homedir: string;
+        cpus: number;
+    };
+};
+export declare const fileRegex: RegExp;
+export declare const fileWithNoPathRegex: RegExp;
+export declare const parseFileBlocks: (fileBlocks: string) => Record<string, string>;
+export declare const getStubProjectFileContext: () => ProjectFileContext;
+export declare const createMarkdownFileBlock: (filePath: string, content: string) => string;
+export declare const parseMarkdownCodeBlock: (content: string) => string;
+export declare const createSearchReplaceBlock: (search: string, replace: string) => string;
+export declare function printFileTree(nodes: FileTreeNode[], depth?: number): string;
+export declare function printFileTreeWithTokens(nodes: FileTreeNode[], fileTokenScores: Record<string, Record<string, number>>, path?: string[]): string;
+/**
+ * Ensures the given file contents ends with a newline character.
+ * @param contents - The file contents
+ * @returns the file contents with a newline character.
+ */
+export declare const ensureEndsWithNewline: (contents: string | null) => string | null;
+/**
+ * Node-compatible file existence check.
+ * Uses fs.stat instead of Bun-specific fs.exists.
+ */
+export declare function fileExists(params: {
+    filePath: string;
+    fs: LevelCodeFileSystem;
+}): Promise<boolean>;
+export declare const ensureDirectoryExists: (params: {
+    baseDir: string;
+    fs: LevelCodeFileSystem;
+}) => Promise<void>;
+/**
+ * Removes markdown code block syntax if present, including any language tag
+ */
+export declare const cleanMarkdownCodeBlock: (content: string) => string;
+export declare function isValidFilePath(path: string): boolean;
+export declare function isDir(params: {
+    path: string;
+    fs: LevelCodeFileSystem;
+}): Promise<boolean>;
+/**
+ * Returns true if the `toPath` is a subdirectory of `fromPath`.
+ */
+export declare function isSubdir(fromPath: string, toPath: string): boolean;
+export declare function isValidProjectRoot(dir: string): boolean;

package/dist/common/src/util/format-code-search.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Formats code search output to group matches by file.
+ *
+ * Input format: ./file.ts:line content
+ * Output format:
+ * ./file.ts:
+ * line content
+ * another line content
+ * yet another line content
+ *
+ * (double newline between distinct files)
+ *
+ * @param stdout The raw stdout from ripgrep
+ * @returns Formatted output with matches grouped by file
+ */
+export declare function formatCodeSearchOutput(stdout: string): string;

package/dist/common/src/util/lru-cache.d.ts

@@ -0,0 +1,30 @@
+/**
+ * A simple Least Recently Used (LRU) cache implementation using a Map.
+ * It leverages the fact that Map objects maintain insertion order.
+ */
+export declare class LRUCache<K, V> {
+    private maxSize;
+    private cache;
+    constructor(maxSize: number);
+    /**
+     * Retrieves an item from the cache. If found, marks it as recently used.
+     * @param key The key of the item to retrieve.
+     * @returns The value associated with the key, or undefined if not found.
+     */
+    get(key: K): V | undefined;
+    /**
+     * Adds or updates an item in the cache. If the cache exceeds maxSize,
+     * the least recently used item is evicted.
+     * @param key The key of the item to set.
+     * @param value The value to associate with the key.
+     */
+    set(key: K, value: V): void;
+    /**
+     * Returns the current number of items in the cache.
+     */
+    get size(): number;
+    /**
+     * Clears all items from the cache.
+     */
+    clear(): void;
+}

package/dist/common/src/util/messages.d.ts

@@ -0,0 +1,46 @@
+import type { Logger } from '../types/contracts/logger';
+import type { JSONValue } from '../types/json';
+import type { AssistantMessage, Message, SystemMessage, UserMessage } from '../types/messages/levelcode-message';
+import type { ToolResultOutput } from '../types/messages/content-part';
+import type { ProviderMetadata } from '../types/messages/provider-metadata';
+import type { ModelMessage } from 'ai';
+export declare function toContentString(msg: ModelMessage): string;
+export declare function withCacheControl<T extends {
+    providerOptions?: ProviderMetadata;
+}>(obj: T): T;
+export declare function withoutCacheControl<T extends {
+    providerOptions?: ProviderMetadata;
+}>(obj: T): T;
+export declare function convertCbToModelMessages({ messages, includeCacheControl, logger, }: {
+    messages: Message[];
+    includeCacheControl?: boolean;
+    logger?: Logger;
+}): ModelMessage[];
+export type SystemContent = string | SystemMessage['content'][number] | SystemMessage['content'];
+export declare function systemContent(content: SystemContent): SystemMessage['content'];
+export declare function systemMessage(params: SystemContent | ({
+    content: SystemContent;
+} & Omit<SystemMessage, 'role' | 'content'>)): SystemMessage;
+export type UserContent = string | UserMessage['content'][number] | UserMessage['content'];
+export declare function userContent(content: UserContent): UserMessage['content'];
+export declare function userMessage(params: UserContent | ({
+    content: UserContent;
+} & Omit<UserMessage, 'role' | 'content'>)): UserMessage;
+export type AssistantContent = string | AssistantMessage['content'][number] | AssistantMessage['content'];
+export declare function assistantContent(content: AssistantContent): AssistantMessage['content'];
+export declare function assistantMessage(params: AssistantContent | ({
+    content: AssistantContent;
+} & Omit<AssistantMessage, 'role' | 'content'>)): AssistantMessage;
+export declare function jsonToolResult<T extends JSONValue>(value: T): [
+    Extract<ToolResultOutput, {
+        type: 'json';
+    }> & {
+        value: T;
+    }
+];
+export declare function mediaToolResult(params: {
+    data: string;
+    mediaType: string;
+}): [Extract<ToolResultOutput, {
+    type: 'media';
+}>];

package/dist/common/src/util/model-utils.d.ts

@@ -0,0 +1,8 @@
+import type { Model } from '../old-constants';
+/**
+ * Check if a model is explicitly defined in the models constant object.
+ * This is used to determine if a model should allow fallbacks or support cache control.
+ * @param model - The model to check
+ * @returns boolean - True if the model is explicitly defined, false otherwise
+ */
+export declare function isExplicitlyDefinedModel(model: Model): boolean;

package/dist/common/src/util/object.d.ts

@@ -0,0 +1,22 @@
+type RemoveUndefined<T extends object> = {
+    [K in keyof T as T[K] extends undefined ? never : K]: Exclude<T[K], undefined>;
+};
+export declare const removeUndefinedProps: <T extends object>(obj: T) => RemoveUndefined<T>;
+export declare const removeNullOrUndefinedProps: <T extends object>(obj: T, exceptions?: string[]) => T;
+export declare const addObjects: <T extends {
+    [key: string]: number;
+}>(obj1: T, obj2: T) => T;
+export declare const subtractObjects: <T extends {
+    [key: string]: number;
+}>(obj1: T, obj2: T) => T;
+export declare const hasChanges: <T extends object>(obj: T, partial: Partial<T>) => boolean;
+export declare const hasSignificantDeepChanges: <T extends object>(obj: T, partial: Partial<T>, epsilonForNumbers: number) => boolean;
+export declare const filterObject: <T extends object>(obj: T, predicate: (value: any, key: keyof T) => boolean) => { [P in keyof T]: T[P]; };
+/**
+ * Asserts that a condition is true. If the condition is false, it throws an error with the provided message.
+ * @param condition The condition to check
+ * @param message The error message to display if the condition is false
+ * @throws {Error} If the condition is false
+ */
+export declare function assert(condition: boolean, message: string): asserts condition;
+export {};

package/dist/common/src/util/promise.d.ts

@@ -0,0 +1,16 @@
+export declare const INITIAL_RETRY_DELAY = 1000;
+export declare function withRetry<T>(operation: () => Promise<T>, options?: {
+    maxRetries?: number;
+    retryIf?: (error: any) => boolean;
+    onRetry?: (error: any, attempt: number) => void;
+    retryDelayMs?: number;
+}): Promise<T>;
+export declare const sleep: (ms: number) => Promise<unknown>;
+/**
+ * Wraps a promise with a timeout
+ * @param promise The promise to wrap
+ * @param timeoutMs Timeout in milliseconds
+ * @param timeoutMessage Optional message for the timeout error
+ * @returns A promise that resolves with the result of the original promise or rejects with a timeout error
+ */
+export declare function withTimeout<T>(promise: Promise<T>, timeoutMs: number, timeoutMessage?: string): Promise<T>;

package/dist/common/src/util/random.d.ts

@@ -0,0 +1 @@
+export declare function sampleSizeWithSeed<T>(array: T[], size: number, seed: string): T[];

package/dist/common/src/util/skills.d.ts

@@ -0,0 +1,5 @@
+import type { SkillsMap } from '../types/skill';
+/**
+ * Formats available skills as XML for inclusion in tool descriptions.
+ */
+export declare function formatAvailableSkillsXml(skills: SkillsMap): string;

package/dist/common/src/util/stop-sequence.d.ts

@@ -0,0 +1,14 @@
+export declare class StopSequenceHandler {
+    private buffer;
+    private finished;
+    private stopSequences;
+    constructor(stopSequences?: string[]);
+    process(text: string): {
+        text: string;
+        endOfStream: boolean;
+    } | {
+        text: null;
+        endOfStream: true;
+    };
+    flush(): string;
+}

package/dist/common/src/util/string.d.ts

@@ -0,0 +1,82 @@
+export declare const truncateString: (str: string, maxLength: number) => string;
+export declare const truncateStringWithMessage: ({ str, maxLength, message, remove, }: {
+    str: string;
+    maxLength: number;
+    message?: string;
+    remove?: "END" | "START" | "MIDDLE";
+}) => string;
+/**
+ * Check if a character is a whitespace character according
+ * to the XML spec (space, carriage return, line feed or tab)
+ *
+ * @param character Character to check
+ * @return Whether the character is whitespace or not
+ */
+export declare const isWhitespace: (character: string) => boolean;
+export declare const replaceNonStandardPlaceholderComments: (content: string, replacement: string) => string;
+export declare const randBoolFromStr: (str: string) => boolean;
+export declare const pluralize: (count: number, word: string, { includeCount }?: {
+    includeCount?: boolean;
+}) => string;
+/**
+ * Safely replaces all occurrences of a search string with a replacement string,
+ * escaping special replacement patterns (like $) in the replacement string.
+ */
+export declare const capitalize: (str: string) => string;
+/**
+ * Converts a snake_case string to Title Case
+ * Example: "add_subgoal" -> "Add Subgoal"
+ */
+export declare const snakeToTitleCase: (str: string) => string;
+/**
+ * Ensures a URL has the appropriate protocol (http:// or https://)
+ * Uses http:// for localhost and local IPs, https:// for all other domains
+ */
+export declare const ensureUrlProtocol: (url: string) => string;
+export declare const safeReplace: (content: string, searchStr: string, replaceStr: string) => string;
+export declare const hasLazyEdit: (content: string) => boolean;
+/**
+ * Extracts a JSON field from a string, transforms it, and puts it back.
+ * Handles both array and object JSON values.
+ * @param content The string containing JSON-like content
+ * @param field The field name to find and transform
+ * @param transform Function to transform the parsed JSON value
+ * @param fallback String to use if parsing fails
+ * @returns The content string with the transformed JSON field
+ */
+export declare function transformJsonInString<T = unknown>(content: string, field: string, transform: (json: T) => unknown, fallback: string): string;
+/**
+ * Generates a compact unique identifier by combining timestamp bits with random bits.
+ * Uses 40 bits of timestamp (enough for ~34 years) and 24 random bits for exactly 64 total bits.
+ * Encodes in base64url for compact, URL-safe strings (~11 chars).
+ * @param prefix Optional prefix to add to the ID
+ * @returns A unique string ID
+ * @example
+ * generateCompactId()      // => "1a2b3c4d5e6"
+ * generateCompactId('msg-') // => "msg-1a2b3c4d5e6"
+ */
+export declare const generateCompactId: (prefix?: string) => string;
+/**
+ * Removes null characters from a string
+ */
+export declare const stripNullChars: (str: string) => string;
+export declare function stripColors(str: string): string;
+export declare function stripAnsi(str: string): string;
+export declare function includesMatch(array: (string | RegExp)[], value: string): boolean;
+/**
+ * Finds the longest substring that is **both** a suffix of `source`
+ * **and** a prefix of `next`.
+ * Useful when concatenating strings while avoiding duplicate overlap.
+ *
+ * @example
+ * ```ts
+ * suffixPrefixOverlap('foobar', 'barbaz'); // ➜ 'bar'
+ * suffixPrefixOverlap('abc', 'def');       // ➜ ''
+ * ```
+ *
+ * @param source  The string whose **suffix** is inspected.
+ * @param next    The string whose **prefix** is inspected.
+ * @returns       The longest overlapping edge, or an empty string if none exists.
+ */
+export declare function suffixPrefixOverlap(source: string, next: string): string;
+export declare const escapeString: (str: string) => string;

package/dist/common/src/util/xml.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Generate a closing XML tag for a single tool name
+ * @param toolName Single tool name to generate closing tag for
+ * @returns Closing XML tag string
+ */
+export declare function closeXml(toolName: string): string;
+/**
+ * Generate stop sequences (closing XML tags) for a list of tool names
+ * @param toolNames Array of tool names to generate closing tags for
+ * @returns Array of closing XML tag strings
+ */
+export declare function getStopSequences(toolNames: readonly string[]): string[];

package/dist/common/src/util/zod-schema.d.ts

@@ -0,0 +1,5 @@
+import z from 'zod/v4';
+/**
+ * Convert a Zod4 schema to JSON string representation.
+ */
+export declare function schemaToJsonStr(schema: z.ZodTypeAny | undefined | Record<string, any>, options?: Parameters<typeof z.toJSONSchema>[1]): string;

package/dist/common/src/utils/dev-phases.d.ts

@@ -0,0 +1,23 @@
+import type { ToolName } from '../tools/constants.js';
+import type { DevPhase, TeamConfig } from '../types/team-config.js';
+export declare const PHASE_ORDER: readonly DevPhase[];
+export declare function getPhaseOrder(phase: DevPhase): number;
+export declare function canTransition(currentPhase: DevPhase, targetPhase: DevPhase): boolean;
+export declare function transitionPhase(teamConfig: TeamConfig, targetPhase: DevPhase): TeamConfig;
+export declare function getPhaseDescription(phase: DevPhase): string;
+/**
+ * Team tool names that are subject to phase gating.
+ * Non-team tools (read_files, str_replace, etc.) are not gated by dev phase.
+ */
+export declare const TEAM_TOOL_NAMES: readonly ToolName[];
+export declare function getPhaseTools(phase: DevPhase): ToolName[];
+/**
+ * Checks whether a specific tool is allowed in the given dev phase.
+ * Only team tools are gated by phase. Non-team tools always return true.
+ */
+export declare function isToolAllowedInPhase(toolName: string, phase: DevPhase): boolean;
+/**
+ * Returns the minimum phase required to use a given team tool.
+ * Returns null for non-team tools (they are always allowed).
+ */
+export declare function getMinimumPhaseForTool(toolName: string): DevPhase | null;

package/dist/common/src/utils/file-lock.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Acquire an exclusive lock on a file path using a .lock sidecar file.
+ * Returns a release function that must be called when done.
+ *
+ * The lock file contains a timestamp. If the lock is older than `staleMs`,
+ * it is considered abandoned and will be forcibly acquired.
+ */
+export declare function acquireLock(filePath: string, timeout?: number): Promise<() => void>;
+/**
+ * Execute a function while holding an exclusive file lock.
+ * The lock is automatically released when the function completes or throws.
+ */
+export declare function withLock<T>(filePath: string, fn: () => T | Promise<T>): Promise<T>;

package/dist/common/src/utils/team-analytics.d.ts

@@ -0,0 +1,16 @@
+import type { TrackEventFn } from '../types/contracts/analytics';
+import type { Logger } from '../types/contracts/logger';
+import type { DevPhase } from '../types/team-config';
+type TrackingContext = {
+    trackEvent: TrackEventFn;
+    userId: string;
+    logger: Logger;
+};
+export declare function trackTeamCreated(ctx: TrackingContext, teamName: string, memberCount: number): void;
+export declare function trackTeamDeleted(ctx: TrackingContext, teamName: string): void;
+export declare function trackTeammateIdle(ctx: TrackingContext, teamName: string, agentName: string, role: string): void;
+export declare function trackTaskCompleted(ctx: TrackingContext, teamName: string, taskId: string, taskSubject: string, owner: string): void;
+export declare function trackPhaseTransition(ctx: TrackingContext, teamName: string, fromPhase: DevPhase, toPhase: DevPhase): void;
+export declare function trackMessageSent(ctx: TrackingContext, teamName: string, type: 'dm' | 'broadcast' | 'shutdown'): void;
+export declare function trackAgentSpawned(ctx: TrackingContext, teamName: string, role: string, agentName: string): void;
+export {};

package/dist/common/src/utils/team-discovery.d.ts

@@ -0,0 +1,47 @@
+import type { TeamConfig, DevPhase, TeamRole } from '../types/team-config';
+export interface TeamAndAgent {
+    teamName: string;
+    agentName: string;
+    config: TeamConfig;
+}
+export interface AgentTeamContext {
+    teamName: string;
+    agentName: string;
+    role: TeamRole;
+    isLeader: boolean;
+    phase: DevPhase;
+}
+export interface TeamSummary {
+    name: string;
+    phase: DevPhase;
+    memberCount: number;
+}
+/**
+ * Finds the team that an agent belongs to, returning the team name and config.
+ * Matches against both the raw agentId and a "lead-" prefixed variant.
+ */
+export declare function findCurrentTeam(agentId: string): {
+    teamName: string;
+    config: TeamConfig;
+} | null;
+/**
+ * Finds the team and the matched agent name for a given agent identifier.
+ * This is the richer variant that also returns which member name was matched.
+ */
+export declare function findCurrentTeamAndAgent(agentId: string): TeamAndAgent | null;
+/**
+ * Direct lookup of a team by name.
+ */
+export declare function findTeamByName(name: string): TeamConfig | null;
+/**
+ * Lists all teams with summary information.
+ */
+export declare function listAllTeams(): TeamSummary[];
+/**
+ * Returns full context for an agent's team membership including role and leadership status.
+ */
+export declare function getAgentTeamContext(agentId: string): AgentTeamContext | null;
+/**
+ * Checks whether an agent is a member of a specific team.
+ */
+export declare function isAgentInTeam(agentId: string, teamName: string): boolean;

package/dist/common/src/utils/team-fs.d.ts

@@ -0,0 +1,20 @@
+import type { TeamConfig, TeamMember, TeamTask } from '../types/team-config';
+import type { TeamProtocolMessage } from '../types/team-protocol';
+export declare function validateTeamName(teamName: string): void;
+export declare function validateAgentName(agentName: string): void;
+export declare function validateTaskId(taskId: string): void;
+export declare function getTeamsDir(): string;
+export declare function getTasksDir(teamName: string): string;
+export declare function createTeam(config: TeamConfig): void;
+export declare function loadTeamConfig(teamName: string): TeamConfig | null;
+export declare function saveTeamConfig(teamName: string, config: TeamConfig): Promise<void>;
+export declare function deleteTeam(teamName: string): void;
+export declare function addTeamMember(teamName: string, member: TeamMember): Promise<void>;
+export declare function removeTeamMember(teamName: string, agentId: string): Promise<void>;
+export declare function createTask(teamName: string, task: TeamTask): Promise<void>;
+export declare function updateTask(teamName: string, taskId: string, updates: Partial<TeamTask>): Promise<void>;
+export declare function listTasks(teamName: string): TeamTask[];
+export declare function getTask(teamName: string, taskId: string): TeamTask | null;
+export declare function sendMessage(teamName: string, to: string, message: TeamProtocolMessage): Promise<void>;
+export declare function readInbox(teamName: string, agentName: string): TeamProtocolMessage[];
+export declare function clearInbox(teamName: string, agentName: string): void;

package/dist/common/src/utils/team-hook-emitter.d.ts

@@ -0,0 +1,40 @@
+import type { TrackEventFn } from '../types/contracts/analytics';
+import type { Logger } from '../types/contracts/logger';
+import type { TeamHookEvent } from '../types/team-hook-events';
+import type { DevPhase } from '../types/team-config';
+/**
+ * Subscribe to all team hook events.
+ * Returns an unsubscribe function.
+ */
+export declare function onTeamHookEvent(listener: (event: TeamHookEvent) => void): () => void;
+/**
+ * Dispatch a team hook event to all registered listeners.
+ * Exported for use in contexts (e.g. CLI) where the full emit helpers
+ * cannot be used because a server-side TrackEventFn is not available.
+ */
+export declare function dispatchTeamHookEvent(event: TeamHookEvent): void;
+export declare function emitTeammateIdle(params: {
+    agentName: string;
+    teamName: string;
+    lastTaskId?: string;
+    trackEvent: TrackEventFn;
+    userId: string;
+    logger: Logger;
+}): void;
+export declare function emitTaskCompleted(params: {
+    taskId: string;
+    taskSubject: string;
+    owner: string;
+    teamName: string;
+    trackEvent: TrackEventFn;
+    userId: string;
+    logger: Logger;
+}): void;
+export declare function emitPhaseTransition(params: {
+    teamName: string;
+    fromPhase: DevPhase;
+    toPhase: DevPhase;
+    trackEvent: TrackEventFn;
+    userId: string;
+    logger: Logger;
+}): void;

package/dist/common/src/utils/team-presets.d.ts

@@ -0,0 +1,35 @@
+import type { TeamRole, DevPhase } from '../types/team-config';
+/**
+ * A preset member definition. Contains the role and descriptive name
+ * but not runtime fields (agentId, joinedAt, status, cwd) which are
+ * assigned at spawn time.
+ */
+export interface PresetMember {
+    name: string;
+    role: TeamRole;
+    agentType: string;
+    model: string;
+}
+/**
+ * A preset configuration that can be used to bootstrap a team.
+ * Contains the member list and default settings but no runtime state.
+ */
+export interface PresetConfig {
+    presetName: string;
+    description: string;
+    defaultPhase: DevPhase;
+    members: PresetMember[];
+    settings: {
+        maxMembers: number;
+        autoAssign: boolean;
+    };
+}
+/**
+ * Returns a preset team configuration by name, or null if not found.
+ * Preset names are case-insensitive.
+ */
+export declare function getTeamPreset(name: string): PresetConfig | null;
+/**
+ * Returns the list of all available preset names.
+ */
+export declare function listPresets(): string[];

package/dist/index.cjs

@@ -23630,6 +23630,7 @@ var juniorEngineer = {
   outputMode: "last_message",
   includeMessageHistory: true,
   toolNames: [
+    "spawn_agents",
     "read_files",
     "read_subtree",
     "str_replace",
@@ -47312,5 +47313,5 @@ function loadMCPConfigSync(options) {
   return mergedConfig;
 }
 
-//# debugId=89F30F83D91716DD64756E2164756E21
+//# debugId=54CC926B8F30DA5964756E2164756E21
 //# sourceMappingURL=index.cjs.map