evil-omo 3.17.11 → 4.0.0

package/dist/features/team-mode/team-registry/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./paths";
+export * from "./loader";
+export * from "./validator";

package/dist/features/team-mode/team-registry/loader.d.ts

@@ -0,0 +1,12 @@
+import type { TeamModeConfig } from "../../../config/schema/team-mode";
+import type { NormalizeTeamSpecInputOptions } from "./team-spec-input-normalizer";
+import type { TeamSpec } from "../types";
+export { TeamSpecValidationError } from "./validator";
+export { normalizeTeamSpecInput } from "./team-spec-input-normalizer";
+export declare function loadTeamSpec(teamName: string, config: TeamModeConfig, projectRoot: string, options?: NormalizeTeamSpecInputOptions): Promise<TeamSpec>;
+export declare function loadAllTeamSpecs(config: TeamModeConfig, projectRoot: string): Promise<Array<{
+    name: string;
+    scope: "project" | "user";
+    spec?: TeamSpec;
+    error?: Error;
+}>>;

package/dist/features/team-mode/team-registry/paths.d.ts

@@ -0,0 +1,13 @@
+import type { TeamModeConfig } from "../../../config/schema/team-mode";
+export declare function resolveBaseDir(config: TeamModeConfig): string;
+export declare function getTeamSpecPath(baseDir: string, teamName: string, scope: "user" | "project", projectRoot?: string): string;
+export declare function getRuntimeStateDir(baseDir: string, teamRunId: string): string;
+export declare function getInboxDir(baseDir: string, teamRunId: string, memberName: string): string;
+export declare function getTasksDir(baseDir: string, teamRunId: string): string;
+export declare function getWorktreeDir(baseDir: string, teamRunId: string, memberName: string): string;
+export declare function discoverTeamSpecs(config: TeamModeConfig, projectRoot: string): Promise<Array<{
+    name: string;
+    scope: "project" | "user";
+    path: string;
+}>>;
+export declare function ensureBaseDirs(baseDir: string): Promise<void>;

package/dist/features/team-mode/team-registry/team-spec-input-normalizer.d.ts

@@ -0,0 +1,6 @@
+import type { CallerTeamLead } from "../resolve-caller-team-lead";
+export type NormalizeTeamSpecInputOptions = {
+    callerTeamLead?: CallerTeamLead;
+    defaultCategoryName?: string;
+};
+export declare function normalizeTeamSpecInput(raw: unknown, options?: NormalizeTeamSpecInputOptions): unknown;

package/dist/features/team-mode/team-registry/validator.d.ts

@@ -0,0 +1,10 @@
+import type { Member, TeamSpec } from "../types";
+export declare class TeamSpecValidationError extends Error {
+    readonly code: string;
+    readonly field?: string | undefined;
+    readonly memberName?: string | undefined;
+    constructor(message: string, code: string, field?: string | undefined, memberName?: string | undefined);
+}
+export declare function validateSpec(spec: TeamSpec): void;
+export declare function validateMemberEligibility(member: Member): void;
+export declare function validateDualSupport(member: Member): void;

package/dist/features/team-mode/team-runtime/activate-team-layout.d.ts

@@ -0,0 +1,4 @@
+import type { TeamModeConfig } from "../../../config/schema/team-mode";
+import type { TmuxSessionManager } from "../../tmux-subagent/manager";
+import type { RuntimeState } from "../types";
+export declare function activateTeamLayout(runtimeState: RuntimeState, config: TeamModeConfig, projectRoot: string, tmuxMgr?: TmuxSessionManager): Promise<boolean>;

package/dist/features/team-mode/team-runtime/cleanup-team-run-resources.d.ts

@@ -0,0 +1,17 @@
+import type { TeamModeConfig } from "../../../config/schema/team-mode";
+import type { BackgroundManager } from "../../background-agent/manager";
+import type { TmuxSessionManager } from "../../tmux-subagent/manager";
+import type { TeamRunCreateError } from "./create";
+type SpawnedMemberResource = {
+    taskId?: string;
+    worktreePath?: string;
+};
+export declare function cleanupTeamRunResources(args: {
+    teamRunId: string;
+    config: TeamModeConfig;
+    resources: SpawnedMemberResource[];
+    bgMgr: BackgroundManager;
+    tmuxMgr?: TmuxSessionManager;
+    createdLayout: boolean;
+}): Promise<TeamRunCreateError["cleanupReport"]>;
+export {};

package/dist/features/team-mode/team-runtime/create.d.ts

@@ -0,0 +1,25 @@
+import type { TeamModeConfig } from "../../../config/schema/team-mode";
+import type { ExecutorContext } from "../../../tools/delegate-task/executor-types";
+import type { BackgroundManager } from "../../background-agent/manager";
+import type { TmuxSessionManager } from "../../tmux-subagent/manager";
+import type { RuntimeState, TeamSpec } from "../types";
+type CreateTeamRunOptions = {
+    callerAgentTypeId?: string;
+    parentMessageID?: string;
+};
+export declare class TeamRunCreateError extends Error {
+    readonly cleanupReport: {
+        cancelledTaskIds: string[];
+        removedLayout: boolean;
+        removedWorktrees: string[];
+        errors: string[];
+    };
+    constructor(message: string, cleanupReport: {
+        cancelledTaskIds: string[];
+        removedLayout: boolean;
+        removedWorktrees: string[];
+        errors: string[];
+    }, cause: Error);
+}
+export declare function createTeamRun(spec: TeamSpec, leadSessionId: string, ctx: ExecutorContext, config: TeamModeConfig, bgMgr: BackgroundManager, tmuxMgr?: TmuxSessionManager, options?: CreateTeamRunOptions): Promise<RuntimeState>;
+export {};

package/dist/features/team-mode/team-runtime/delete-team.d.ts

@@ -0,0 +1,16 @@
+import type { TeamModeConfig } from "../../../config/schema/team-mode";
+import { log } from "../../../shared/logger";
+import type { BackgroundManager } from "../../background-agent/manager";
+import type { TmuxSessionManager } from "../../tmux-subagent/manager";
+import { canVisualize, removeTeamLayout } from "../team-layout-tmux/layout";
+export type DeleteTeamDeps = {
+    canVisualize: typeof canVisualize;
+    removeTeamLayout: typeof removeTeamLayout;
+    log: typeof log;
+};
+export declare function deleteTeam(teamRunId: string, config: TeamModeConfig, tmuxMgr?: TmuxSessionManager, bgMgr?: BackgroundManager, options?: {
+    force?: boolean;
+}, deps?: DeleteTeamDeps): Promise<{
+    removedWorktrees: string[];
+    removedLayout: boolean;
+}>;

package/dist/features/team-mode/team-runtime/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./resolve-member";
+export * from "./shutdown";

package/dist/features/team-mode/team-runtime/resolve-member-dependencies.d.ts

@@ -0,0 +1,3 @@
+export { resolveCategoryExecution } from "../../../tools/delegate-task/category-resolver";
+export { resolveSubagentExecution } from "../../../tools/delegate-task/subagent-resolver";
+export { buildSystemContent } from "../../../tools/delegate-task/prompt-builder";

package/dist/features/team-mode/team-runtime/resolve-member.d.ts

@@ -0,0 +1,17 @@
+import type { FallbackEntry } from "../../../shared/model-requirements";
+import type { DelegatedModelConfig } from "../../../shared/model-resolution-types";
+import type { ExecutorContext } from "../../../tools/delegate-task/executor-types";
+import type { Member } from "../types";
+export declare class TeamMemberResolutionError extends Error {
+    readonly memberName: string;
+    readonly cause: Error;
+    constructor(memberName: string, cause: Error);
+}
+export interface ResolvedMember {
+    memberName: string;
+    agentToUse: string;
+    model: DelegatedModelConfig | undefined;
+    fallbackChain: FallbackEntry[] | undefined;
+    systemContent: string;
+}
+export declare function resolveMember(member: Member, ctx: ExecutorContext, categoryExamples: string, parentAgent?: string): Promise<ResolvedMember>;

package/dist/features/team-mode/team-runtime/shutdown-helpers.d.ts

@@ -0,0 +1,11 @@
+import type { Message, RuntimeState } from "../types";
+export declare const DELETABLE_MEMBER_STATUSES: Set<"pending" | "completed" | "running" | "idle" | "shutdown_approved" | "errored">;
+export declare function createShutdownMessage(from: string, to: string, kind: Message["kind"], body: string): Message;
+export declare function getRuntimeMember(runtimeState: RuntimeState, memberName: string): RuntimeState["members"][number];
+export declare function getLeadMemberName(runtimeState: RuntimeState): string;
+export declare function createSendContext(runtimeState: RuntimeState, senderName: string): {
+    isLead: boolean;
+    activeMembers: string[];
+};
+export declare function findLatestShutdownRequestIndex(runtimeState: RuntimeState, memberName: string, requesterName?: string): number;
+export declare function removeWorktrees(memberPaths: Array<string | undefined>): Promise<string[]>;

package/dist/features/team-mode/team-runtime/shutdown-test-fixtures.d.ts

@@ -0,0 +1,46 @@
+import type { TeamModeConfig } from "../../../config/schema/team-mode";
+import { sendMessage } from "../team-mailbox/send";
+import { type RuntimeState, type TeamSpec } from "../types";
+export declare function createConfig(baseDir: string): TeamModeConfig;
+export declare function createSpec(worktreeRoot: string): TeamSpec;
+export declare function createFixture(options?: {
+    status?: RuntimeState["status"];
+}): Promise<{
+    baseDir: string;
+    config: TeamModeConfig;
+    teamRunId: string;
+    worktreePaths: string[];
+}>;
+export declare function updateMemberStatuses(teamRunId: string, config: TeamModeConfig, statuses: Record<string, RuntimeState["members"][number]["status"]>): Promise<void>;
+export declare function readInboxMessages(teamRunId: string, memberName: string, config: TeamModeConfig): Promise<{
+    version: 1;
+    messageId: string;
+    from: string;
+    to: string;
+    kind: "message" | "shutdown_request" | "shutdown_approved" | "shutdown_rejected" | "announcement";
+    body: string;
+    timestamp: number;
+    summary?: string | undefined;
+    references?: {
+        path: string;
+        description?: string | undefined;
+    }[] | undefined;
+    correlationId?: string | undefined;
+    color?: string | undefined;
+}[]>;
+export declare function createTestMessage(overrides?: Partial<Parameters<typeof sendMessage>[0]>): {
+    version: 1;
+    messageId: string;
+    from: string;
+    to: string;
+    kind: "message" | "shutdown_request" | "shutdown_approved" | "shutdown_rejected" | "announcement";
+    body: string;
+    timestamp: number;
+    summary?: string | undefined;
+    references?: {
+        path: string;
+        description?: string | undefined;
+    }[] | undefined;
+    correlationId?: string | undefined;
+    color?: string | undefined;
+};

package/dist/features/team-mode/team-runtime/shutdown.d.ts

@@ -0,0 +1,5 @@
+import type { TeamModeConfig } from "../../../config/schema/team-mode";
+export { deleteTeam } from "./delete-team";
+export declare function requestShutdownOfMember(teamRunId: string, targetMemberName: string, requesterName: string, config: TeamModeConfig): Promise<void>;
+export declare function approveShutdown(teamRunId: string, memberName: string, approverName: string, config: TeamModeConfig): Promise<void>;
+export declare function rejectShutdown(teamRunId: string, memberName: string, reason: string, config: TeamModeConfig): Promise<void>;

package/dist/features/team-mode/team-runtime/status.d.ts

@@ -0,0 +1,36 @@
+import type { BackgroundManager } from "../../background-agent/manager";
+import type { TeamModeConfig } from "../../../config/schema/team-mode";
+import type { RuntimeState } from "../types";
+export interface TeamStatus {
+    teamName: string;
+    teamRunId: string;
+    status: RuntimeState["status"];
+    leadSessionId?: string;
+    createdAt: number;
+    members: Array<{
+        name: string;
+        sessionId?: string;
+        status: RuntimeState["members"][number]["status"];
+        color?: string;
+        worktreePath?: string;
+        unreadMessages: number;
+        paneId?: string;
+    }>;
+    tasks: {
+        pending: number;
+        claimed: number;
+        in_progress: number;
+        completed: number;
+        deleted: number;
+        total: number;
+    };
+    shutdownRequests: RuntimeState["shutdownRequests"];
+    concurrency: {
+        runningOnSameModel: number;
+        queuedOnSameModel: number;
+        teamRunIdSpecific?: number;
+    };
+    bounds: RuntimeState["bounds"];
+    staleLocks: string[];
+}
+export declare function aggregateStatus(teamRunId: string, config: TeamModeConfig, bgMgr?: BackgroundManager): Promise<TeamStatus>;

package/dist/features/team-mode/team-session-registry.d.ts

@@ -0,0 +1,11 @@
+export type TeamSessionRole = "lead" | "member";
+export type TeamSessionEntry = {
+    teamRunId: string;
+    memberName: string;
+    role: TeamSessionRole;
+};
+export declare function registerTeamSession(sessionId: string, entry: TeamSessionEntry): void;
+export declare function lookupTeamSession(sessionId: string): TeamSessionEntry | undefined;
+export declare function unregisterTeamSession(sessionId: string): void;
+export declare function unregisterTeamSessionsByTeam(teamRunId: string): void;
+export declare function clearTeamSessionRegistry(): void;

package/dist/features/team-mode/team-state-store/index.d.ts

@@ -0,0 +1 @@
+export { InvalidTransitionError, RuntimeStateError, createRuntimeState, listActiveTeams, loadRuntimeState, saveRuntimeState, transitionRuntimeState, } from "./store";

package/dist/features/team-mode/team-state-store/locks.d.ts

@@ -0,0 +1,12 @@
+import { rename } from "node:fs/promises";
+type LockOptions = {
+    staleAfterMs?: number;
+    ownerTag?: string;
+};
+export declare function withLock<T>(lockPath: string, fn: () => Promise<T>, opts?: LockOptions): Promise<T>;
+export declare function detectStaleLock(lockPath: string, staleAfterMs: number): Promise<boolean>;
+export declare function reapStaleLock(lockPath: string): Promise<void>;
+export declare function atomicWrite(filePath: string, content: string | Buffer, deps?: {
+    rename: typeof rename;
+}): Promise<void>;
+export {};

package/dist/features/team-mode/team-state-store/resume.d.ts

@@ -0,0 +1,10 @@
+import type { TeamModeConfig } from "../../../config/schema/team-mode";
+import type { ExecutorContext } from "../../../tools/delegate-task/executor-types";
+export interface ResumeReport {
+    resumed: number;
+    marked_failed: number;
+    marked_orphaned: number;
+    cleaned: number;
+    errors: Error[];
+}
+export declare function resumeAllTeams(ctx: ExecutorContext, config: TeamModeConfig): Promise<ResumeReport>;

package/dist/features/team-mode/team-state-store/store.d.ts

@@ -0,0 +1,21 @@
+import type { TeamModeConfig } from "../../../config/schema/team-mode";
+import { type RuntimeState, type TeamSpec } from "../types";
+export declare const STALE_DELETING_TTL_MS = 60000;
+export declare class RuntimeStateError extends Error {
+    readonly code: string;
+    constructor(message: string, code: string);
+}
+export declare class InvalidTransitionError extends Error {
+    constructor(from: string, to: string);
+}
+export declare function createRuntimeState(spec: TeamSpec, leadSessionId: string | undefined, specSource: "project" | "user", config: TeamModeConfig): Promise<RuntimeState>;
+export declare function loadRuntimeState(teamRunId: string, config: TeamModeConfig): Promise<RuntimeState>;
+export declare function saveRuntimeState(runtimeState: RuntimeState, config: TeamModeConfig): Promise<void>;
+export declare function transitionRuntimeState(teamRunId: string, transition: (runtimeState: RuntimeState) => RuntimeState, config: TeamModeConfig): Promise<RuntimeState>;
+export declare function listActiveTeams(config: TeamModeConfig): Promise<Array<{
+    teamRunId: string;
+    teamName: string;
+    status: string;
+    memberCount: number;
+    scope: "project" | "user";
+}>>;

package/dist/features/team-mode/team-tasklist/claim.d.ts

@@ -0,0 +1,10 @@
+import type { TeamModeConfig } from "../../../config/schema/team-mode";
+import type { Task } from "../types";
+export declare class AlreadyClaimedError extends Error {
+    constructor(message?: string);
+}
+export declare class BlockedByError extends Error {
+    readonly blockers: string[];
+    constructor(blockers: string[]);
+}
+export declare function claimTask(teamRunId: string, taskId: string, memberName: string, config: TeamModeConfig): Promise<Task>;

package/dist/features/team-mode/team-tasklist/dependencies.d.ts

@@ -0,0 +1,2 @@
+import type { Task } from "../types";
+export declare function canClaim(task: Task, allTasks: Task[]): boolean;

package/dist/features/team-mode/team-tasklist/get.d.ts

@@ -0,0 +1,3 @@
+import type { TeamModeConfig } from "../../../config/schema/team-mode";
+import type { Task } from "../types";
+export declare function getTask(teamRunId: string, taskId: string, config: TeamModeConfig): Promise<Task>;

package/dist/features/team-mode/team-tasklist/index.d.ts

@@ -0,0 +1,6 @@
+export { claimTask, AlreadyClaimedError, BlockedByError } from "./claim";
+export { canClaim } from "./dependencies";
+export { getTask } from "./get";
+export { listTasks } from "./list";
+export { createTask } from "./store";
+export { updateTaskStatus, CrossOwnerUpdateError, InvalidTaskTransitionError } from "./update";

package/dist/features/team-mode/team-tasklist/list.d.ts

@@ -0,0 +1,8 @@
+import type { TeamModeConfig } from "../../../config/schema/team-mode";
+import type { Task } from "../types";
+type TaskListFilter = {
+    status?: Task["status"];
+    owner?: string;
+};
+export declare function listTasks(teamRunId: string, config: TeamModeConfig, filter?: TaskListFilter): Promise<Task[]>;
+export {};

package/dist/features/team-mode/team-tasklist/store.d.ts

@@ -0,0 +1,3 @@
+import type { TeamModeConfig } from "../../../config/schema/team-mode";
+import type { Task } from "../types";
+export declare function createTask(teamRunId: string, taskInput: Omit<Task, "id" | "createdAt" | "updatedAt" | "version">, config: TeamModeConfig): Promise<Task>;

package/dist/features/team-mode/team-tasklist/test-support.d.ts

@@ -0,0 +1,9 @@
+import type { TeamModeConfig } from "../../../config/schema/team-mode";
+import type { Task } from "../types";
+export declare function createTasklistFixture(): Promise<{
+    config: TeamModeConfig;
+    rootDirectory: string;
+    teamRunId: string;
+    cleanup: () => Promise<void>;
+}>;
+export declare function createTaskInput(overrides?: Partial<Omit<Task, "id" | "createdAt" | "updatedAt" | "version">>): Omit<Task, "id" | "createdAt" | "updatedAt" | "version">;

package/dist/features/team-mode/team-tasklist/update.d.ts

@@ -0,0 +1,9 @@
+import type { TeamModeConfig } from "../../../config/schema/team-mode";
+import type { Task } from "../types";
+export declare class InvalidTaskTransitionError extends Error {
+    constructor(currentStatus: Task["status"], nextStatus: Task["status"]);
+}
+export declare class CrossOwnerUpdateError extends Error {
+    constructor(message?: string);
+}
+export declare function updateTaskStatus(teamRunId: string, taskId: string, newStatus: Task["status"], memberName: string, config: TeamModeConfig): Promise<Task>;

package/dist/features/team-mode/tools/index.d.ts

@@ -0,0 +1 @@
+export { createTeamApproveShutdownTool, createTeamCreateTool, createTeamDeleteTool, createTeamRejectShutdownTool, createTeamShutdownRequestTool } from "./lifecycle";

package/dist/features/team-mode/tools/lifecycle-test-fixture.d.ts

@@ -0,0 +1,188 @@
+import type { ToolContext } from "@opencode-ai/plugin/tool";
+import type { OpencodeClient } from "../../../tools/delegate-task/types";
+import type { BackgroundManager } from "../../background-agent/manager";
+import type { RuntimeState, TeamSpec } from "../types";
+export declare function parseToolResult<TValue>(value: string): TValue;
+export declare function createToolContext(sessionID: string): ToolContext;
+export declare function getLatestShutdownRequest(runtimeState: RuntimeState, memberName: string): RuntimeState["shutdownRequests"][number] | undefined;
+export declare function createSpec(): TeamSpec;
+export declare function requireRuntime(teamRunId: string): RuntimeState;
+export declare const createTeamRunMock: import("bun:test").Mock<(spec: TeamSpec, leadSessionId: string) => Promise<{
+    version: 1;
+    teamRunId: string;
+    teamName: string;
+    specSource: "user" | "project";
+    createdAt: number;
+    status: "deleted" | "failed" | "active" | "creating" | "shutdown_requested" | "deleting" | "orphaned";
+    members: {
+        name: string;
+        agentType: "leader" | "general-purpose";
+        status: "pending" | "completed" | "running" | "idle" | "shutdown_approved" | "errored";
+        pendingInjectedMessageIds: string[];
+        sessionId?: string | undefined;
+        tmuxPaneId?: string | undefined;
+        tmuxGridPaneId?: string | undefined;
+        subagent_type?: string | undefined;
+        category?: string | undefined;
+        model?: {
+            providerID: string;
+            modelID: string;
+            variant?: string | undefined;
+            reasoningEffort?: string | undefined;
+            temperature?: number | undefined;
+            top_p?: number | undefined;
+            maxTokens?: number | undefined;
+            thinking?: {
+                type: "enabled" | "disabled";
+                budgetTokens?: number | undefined;
+            } | undefined;
+        } | undefined;
+        color?: string | undefined;
+        worktreePath?: string | undefined;
+        lastInjectedTurnMarker?: string | undefined;
+    }[];
+    shutdownRequests: {
+        memberId: string;
+        requesterName: string;
+        requestedAt: number;
+        approvedAt?: number | undefined;
+        rejectedReason?: string | undefined;
+        rejectedAt?: number | undefined;
+    }[];
+    bounds: {
+        maxMembers: number;
+        maxParallelMembers: number;
+        maxMessagesPerRun: number;
+        maxWallClockMinutes: number;
+        maxMemberTurns: number;
+    };
+    leadSessionId?: string | undefined;
+    tmuxLayout?: {
+        ownedSession: boolean;
+        targetSessionId: string;
+        focusWindowId?: string | undefined;
+        gridWindowId?: string | undefined;
+    } | undefined;
+}>>;
+export declare const deleteTeamMock: import("bun:test").Mock<(teamRunId: string, _config?: unknown, _tmuxMgr?: unknown, _bgMgr?: unknown, options?: {
+    force?: boolean;
+}) => Promise<{
+    removedWorktrees: never[];
+    removedLayout: boolean;
+}>>;
+export declare const requestShutdownOfMemberMock: import("bun:test").Mock<(teamRunId: string, targetMemberName: string, requesterName: string) => Promise<void>>;
+export declare const approveShutdownMock: import("bun:test").Mock<(teamRunId: string, memberName: string) => Promise<void>>;
+export declare const rejectShutdownMock: import("bun:test").Mock<(teamRunId: string, memberName: string, reason: string) => Promise<void>>;
+export declare const loadTeamSpecMock: import("bun:test").Mock<() => Promise<{
+    version: 1;
+    name: string;
+    createdAt: number;
+    members: ({
+        name: string;
+        backendType: "tmux" | "in-process";
+        isActive: boolean;
+        kind: "category";
+        category: string;
+        prompt: string;
+        cwd?: string | undefined;
+        worktreePath?: string | undefined;
+        subscriptions?: string[] | undefined;
+        color?: string | undefined;
+    } | {
+        name: string;
+        backendType: "tmux" | "in-process";
+        isActive: boolean;
+        kind: "subagent_type";
+        subagent_type: string;
+        cwd?: string | undefined;
+        worktreePath?: string | undefined;
+        subscriptions?: string[] | undefined;
+        color?: string | undefined;
+        prompt?: string | undefined;
+    })[];
+    description?: string | undefined;
+    leadAgentId?: string | undefined;
+    teamAllowedPaths?: string[] | undefined;
+    sessionPermission?: string | undefined;
+}>>;
+export declare const listActiveTeamsMock: import("bun:test").Mock<() => Promise<{
+    teamRunId: string;
+    teamName: string;
+    status: "deleted" | "failed" | "active" | "creating" | "shutdown_requested" | "deleting" | "orphaned";
+    memberCount: number;
+    scope: "user" | "project";
+}[]>>;
+export declare const loadRuntimeStateMock: import("bun:test").Mock<(teamRunId: string) => Promise<{
+    version: 1;
+    teamRunId: string;
+    teamName: string;
+    specSource: "user" | "project";
+    createdAt: number;
+    status: "deleted" | "failed" | "active" | "creating" | "shutdown_requested" | "deleting" | "orphaned";
+    members: {
+        name: string;
+        agentType: "leader" | "general-purpose";
+        status: "pending" | "completed" | "running" | "idle" | "shutdown_approved" | "errored";
+        pendingInjectedMessageIds: string[];
+        sessionId?: string | undefined;
+        tmuxPaneId?: string | undefined;
+        tmuxGridPaneId?: string | undefined;
+        subagent_type?: string | undefined;
+        category?: string | undefined;
+        model?: {
+            providerID: string;
+            modelID: string;
+            variant?: string | undefined;
+            reasoningEffort?: string | undefined;
+            temperature?: number | undefined;
+            top_p?: number | undefined;
+            maxTokens?: number | undefined;
+            thinking?: {
+                type: "enabled" | "disabled";
+                budgetTokens?: number | undefined;
+            } | undefined;
+        } | undefined;
+        color?: string | undefined;
+        worktreePath?: string | undefined;
+        lastInjectedTurnMarker?: string | undefined;
+    }[];
+    shutdownRequests: {
+        memberId: string;
+        requesterName: string;
+        requestedAt: number;
+        approvedAt?: number | undefined;
+        rejectedReason?: string | undefined;
+        rejectedAt?: number | undefined;
+    }[];
+    bounds: {
+        maxMembers: number;
+        maxParallelMembers: number;
+        maxMessagesPerRun: number;
+        maxWallClockMinutes: number;
+        maxMemberTurns: number;
+    };
+    leadSessionId?: string | undefined;
+    tmuxLayout?: {
+        ownedSession: boolean;
+        targetSessionId: string;
+        focusWindowId?: string | undefined;
+        gridWindowId?: string | undefined;
+    } | undefined;
+}>>;
+export declare const config: {
+    enabled: boolean;
+    tmux_visualization: boolean;
+    max_parallel_members: number;
+    max_members: number;
+    max_messages_per_run: number;
+    max_wall_clock_minutes: number;
+    max_member_turns: number;
+    message_payload_max_bytes: number;
+    recipient_unread_max_bytes: number;
+    mailbox_poll_interval_ms: number;
+    base_dir?: string | undefined;
+};
+export declare const mockClient: OpencodeClient;
+export declare const backgroundManager: BackgroundManager;
+export declare function resetLifecycleTestState(): void;
+export declare function hasRuntime(teamRunId: string): boolean;

package/dist/features/team-mode/tools/lifecycle.d.ts

@@ -0,0 +1,37 @@
+import { type ToolDefinition } from "@opencode-ai/plugin/tool";
+import type { TeamModeConfig } from "../../../config/schema/team-mode";
+import type { CategoriesConfig, AgentOverrides } from "../../../config/schema";
+import type { OpencodeClient } from "../../../tools/delegate-task/types";
+import type { BackgroundManager } from "../../background-agent/manager";
+import type { TmuxSessionManager } from "../../tmux-subagent/manager";
+import { loadTeamSpec } from "../team-registry/loader";
+import { createTeamRun } from "../team-runtime/create";
+import { approveShutdown, deleteTeam, rejectShutdown, requestShutdownOfMember } from "../team-runtime/shutdown";
+import { listActiveTeams, loadRuntimeState } from "../team-state-store/store";
+type TeamRuntimeStoreDeps = {
+    listActiveTeams: typeof listActiveTeams;
+    loadRuntimeState: typeof loadRuntimeState;
+};
+type TeamShutdownToolDeps = TeamRuntimeStoreDeps & {
+    deleteTeam: typeof deleteTeam;
+    requestShutdownOfMember: typeof requestShutdownOfMember;
+    approveShutdown: typeof approveShutdown;
+    rejectShutdown: typeof rejectShutdown;
+};
+export type TeamCreateExecutorConfig = {
+    userCategories?: CategoriesConfig;
+    sisyphusJuniorModel?: string;
+    agentOverrides?: AgentOverrides;
+};
+type TeamCreateToolDeps = {
+    createTeamRun: typeof createTeamRun;
+    loadTeamSpec: typeof loadTeamSpec;
+    listActiveTeams: typeof listActiveTeams;
+    loadRuntimeState: typeof loadRuntimeState;
+};
+export declare function createTeamCreateTool(config: TeamModeConfig, client: OpencodeClient, bgMgr: BackgroundManager, tmuxMgr?: TmuxSessionManager, executorConfig?: TeamCreateExecutorConfig, deps?: TeamCreateToolDeps): ToolDefinition;
+export declare function createTeamDeleteTool(config: TeamModeConfig, client: OpencodeClient, backgroundManager: BackgroundManager, tmuxMgr?: TmuxSessionManager, deps?: TeamShutdownToolDeps): ToolDefinition;
+export declare function createTeamShutdownRequestTool(config: TeamModeConfig, client: OpencodeClient, deps?: TeamShutdownToolDeps): ToolDefinition;
+export declare function createTeamApproveShutdownTool(config: TeamModeConfig, client: OpencodeClient, deps?: TeamShutdownToolDeps): ToolDefinition;
+export declare function createTeamRejectShutdownTool(config: TeamModeConfig, client: OpencodeClient, deps?: TeamShutdownToolDeps): ToolDefinition;
+export {};

package/dist/features/team-mode/tools/messaging.d.ts

@@ -0,0 +1,31 @@
+import { type ToolDefinition } from "@opencode-ai/plugin/tool";
+import type { TeamModeConfig } from "../../../config/schema/team-mode";
+import { loadRuntimeState } from "../team-state-store/store";
+export type LiveDeliveryClient = {
+    session: {
+        promptAsync(input: {
+            path: {
+                id: string;
+            };
+            body: {
+                parts: Array<{
+                    type: "text";
+                    text: string;
+                }>;
+                agent?: string;
+                model?: {
+                    providerID: string;
+                    modelID: string;
+                };
+                variant?: string;
+            };
+            query?: {
+                directory: string;
+            };
+        }): Promise<unknown>;
+    };
+};
+export type TeamSendMessageToolDeps = {
+    loadRuntimeState: typeof loadRuntimeState;
+};
+export declare function createTeamSendMessageTool(config: TeamModeConfig, client: LiveDeliveryClient, deps?: TeamSendMessageToolDeps): ToolDefinition;