@wolfx/oh-my-openagent 3.17.15 → 4.1.1

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

@@ -0,0 +1,7 @@
+export { BroadcastNotPermittedError, DuplicateMessageIdError, PayloadTooLargeError, RecipientBackpressureError, sendMessage, } from "./send";
+export { listUnreadMessages } from "./inbox";
+export { pollAndBuildInjection } from "./poll";
+export type { InjectionResult } from "./poll";
+export { ackMessages } from "./ack";
+export { reserveMessageForDelivery, commitDeliveryReservation, releaseDeliveryReservation, reclaimStaleReservations, } from "./reservation";
+export type { DeliveryReservation } from "./reservation";

package/dist/features/team-mode/team-mailbox/poll.d.ts

@@ -0,0 +1,10 @@
+import type { TeamModeConfig } from "../../../config/schema/team-mode";
+import type { Message } from "../types";
+export interface InjectionResult {
+    injected: boolean;
+    content?: string;
+    messageIds: string[];
+    reason?: string;
+}
+export declare function buildEnvelope(message: Message): string;
+export declare function pollAndBuildInjection(sessionID: string, memberName: string, teamRunId: string, config: TeamModeConfig, turnMarker: string): Promise<InjectionResult>;

package/dist/features/team-mode/team-mailbox/reservation.d.ts

@@ -0,0 +1,11 @@
+import type { TeamModeConfig } from "../../../config/schema/team-mode";
+export interface DeliveryReservation {
+    reservedPath: string;
+    inboxPath: string;
+    processedPath: string;
+    processedDir: string;
+}
+export declare function reserveMessageForDelivery(teamRunId: string, recipientName: string, messageId: string, config: TeamModeConfig): Promise<DeliveryReservation | null>;
+export declare function commitDeliveryReservation(reservation: DeliveryReservation): Promise<void>;
+export declare function releaseDeliveryReservation(reservation: DeliveryReservation): Promise<void>;
+export declare function reclaimStaleReservations(teamRunId: string, recipientName: string, config: TeamModeConfig, staleTtlMs: number): Promise<string[]>;

package/dist/features/team-mode/team-mailbox/send.d.ts

@@ -0,0 +1,27 @@
+import type { TeamModeConfig } from "../../../config/schema/team-mode";
+import type { Message } from "../types";
+type SendContext = {
+    isLead: boolean;
+    activeMembers: string[];
+    reservedRecipients?: ReadonlySet<string>;
+};
+export declare class BroadcastNotPermittedError extends Error {
+    constructor(message?: string);
+}
+export declare class PayloadTooLargeError extends Error {
+    constructor(message?: string);
+}
+export declare class RecipientBackpressureError extends Error {
+    constructor(message?: string);
+}
+export declare class DuplicateMessageIdError extends Error {
+    constructor(message?: string);
+}
+export declare class TeamDeletingError extends Error {
+    constructor(message?: string);
+}
+export declare function sendMessage(message: Message, teamRunId: string, config: TeamModeConfig, context: SendContext): Promise<{
+    messageId: string;
+    deliveredTo: string[];
+}>;
+export {};

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/session-cleanup.d.ts

@@ -0,0 +1,21 @@
+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 { deleteTeam } from "./delete-team";
+export { clearSessionTeamRunCleanupRegistry, getSessionCreatedTeamRunIds, registerTeamRunForSessionCleanup, unregisterTeamRunForSessionCleanup, } from "./session-team-run-registry";
+export type SessionTeamCleanupReport = {
+    cleanedTeamRunIds: string[];
+    removedLayoutTeamRunIds: string[];
+    errors: string[];
+};
+export type SessionTeamCleanupDeps = {
+    deleteTeam: typeof deleteTeam;
+    log: typeof log;
+};
+export declare function cleanupSessionTeamRuns(args: {
+    config: TeamModeConfig;
+    tmuxMgr?: TmuxSessionManager;
+    bgMgr?: BackgroundManager;
+    deps?: SessionTeamCleanupDeps;
+}): Promise<SessionTeamCleanupReport>;

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

@@ -0,0 +1,4 @@
+export declare function registerTeamRunForSessionCleanup(teamRunId: string): void;
+export declare function unregisterTeamRunForSessionCleanup(teamRunId: string): void;
+export declare function getSessionCreatedTeamRunIds(): string[];
+export declare function clearSessionTeamRunCleanupRegistry(): void;

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";