aimux-cli 0.1.16 → 0.1.19

package/dist/statusline-model.js

@@ -1,5 +1,6 @@
 import { basename } from "node:path";
 import { sessionSemanticCompactHint } from "./session-semantics.js";
+import { compareTeammateSessions, isTeammateSession } from "./team.js";
 function isAutogeneratedSessionLabel(session) {
     const label = session.label?.trim().toLowerCase();
     const tool = session.tool?.trim().toLowerCase();
@@ -8,6 +9,11 @@ function isAutogeneratedSessionLabel(session) {
     return label === tool || label.startsWith(`${tool}-`);
 }
 export function compactSessionTitle(session) {
+    if (session.kind === "service") {
+        const command = session.launchCommandLine?.trim();
+        if (command)
+            return command;
+    }
     const base = session.kind === "service"
         ? session.label?.trim() || session.tool || "service"
         : !isAutogeneratedSessionLabel(session) && session.label?.trim()
@@ -42,12 +48,27 @@ function isWithinPath(path, root) {
 }
 function resolveScopedWorktreePath(data, projectRoot, currentPath) {
     const normalizedCurrentPath = normalizePath(currentPath, projectRoot);
-    const candidates = (data.sessions ?? [])
+    const candidates = [...(data.sessions ?? []), ...(data.teammates ?? [])]
         .map((session) => normalizePath(session.worktreePath, projectRoot))
         .filter((worktreePath) => isWithinPath(normalizedCurrentPath, worktreePath))
         .sort((left, right) => right.length - left.length);
     return candidates[0] ?? normalizedCurrentPath;
 }
+function allStatuslineSessions(data) {
+    return [...(data.sessions ?? []), ...(data.teammates ?? [])];
+}
+export function findStatuslineSession(data, sessionId) {
+    if (!sessionId)
+        return undefined;
+    return allStatuslineSessions(data).find((session) => session.id === sessionId);
+}
+function sessionsMatchingScopedWindow(sessions, scopedWorktreePath, currentWindow, projectRoot) {
+    return sessions.filter((session) => {
+        if (normalizePath(session.worktreePath, projectRoot) !== scopedWorktreePath)
+            return false;
+        return session.windowName === currentWindow || session.label === currentWindow || session.tool === currentWindow;
+    });
+}
 export function sessionIdentity(session) {
     return compactSessionTitle(session);
 }
@@ -87,7 +108,7 @@ export function currentPathContext(currentPath) {
     };
 }
 export function resolveCurrentSessionId(data, currentSession, currentWindow, currentWindowId, currentPath, projectRoot) {
-    const sessions = data.sessions ?? [];
+    const sessions = allStatuslineSessions(data);
     if (currentWindowId) {
         const byWindow = sessions.find((session) => session.tmuxWindowId === currentWindowId);
         if (byWindow?.id)
@@ -95,18 +116,17 @@ export function resolveCurrentSessionId(data, currentSession, currentWindow, cur
     }
     if (currentWindow && projectRoot) {
         const scopedWorktreePath = resolveScopedWorktreePath(data, projectRoot, currentPath);
-        const byScopedWindow = sessions.find((session) => {
-            if (normalizePath(session.worktreePath, projectRoot) !== scopedWorktreePath)
-                return false;
-            return session.windowName === currentWindow || session.label === currentWindow || session.tool === currentWindow;
-        });
-        if (byScopedWindow?.id)
-            return byScopedWindow.id;
+        const visibleMatch = sessionsMatchingScopedWindow(data.sessions ?? [], scopedWorktreePath, currentWindow, projectRoot)[0];
+        if (visibleMatch?.id)
+            return visibleMatch.id;
+        const teammateMatch = sessionsMatchingScopedWindow(data.teammates ?? [], scopedWorktreePath, currentWindow, projectRoot)[0];
+        if (teammateMatch?.id)
+            return teammateMatch.id;
     }
     return data.sessions?.find((session) => session.active)?.id;
 }
 export function resolveExactCurrentSessionId(data, currentSession, currentWindow, currentWindowId, currentPath, projectRoot) {
-    const sessions = data.sessions ?? [];
+    const sessions = allStatuslineSessions(data);
     if (currentWindowId) {
         const byWindow = sessions.find((session) => session.tmuxWindowId === currentWindowId);
         if (byWindow?.id)
@@ -114,33 +134,29 @@ export function resolveExactCurrentSessionId(data, currentSession, currentWindow
     }
     if (currentWindow && projectRoot) {
         const scopedWorktreePath = resolveScopedWorktreePath(data, projectRoot, currentPath);
-        const matches = sessions.filter((session) => {
-            if (normalizePath(session.worktreePath, projectRoot) !== scopedWorktreePath)
-                return false;
-            return session.windowName === currentWindow || session.label === currentWindow || session.tool === currentWindow;
-        });
-        if (matches.length === 1) {
-            return matches[0]?.id;
+        const visibleMatches = sessionsMatchingScopedWindow(data.sessions ?? [], scopedWorktreePath, currentWindow, projectRoot);
+        if (visibleMatches.length === 1) {
+            return visibleMatches[0]?.id;
+        }
+        if (visibleMatches.length > 1) {
+            return undefined;
+        }
+        const teammateMatches = sessionsMatchingScopedWindow(data.teammates ?? [], scopedWorktreePath, currentWindow, projectRoot);
+        if (teammateMatches.length === 1) {
+            return teammateMatches[0]?.id;
         }
     }
     return undefined;
 }
 export function resolveScopedSessions(data, projectRoot, currentSession, currentWindow, currentWindowId, currentPath) {
     const scopedWorktreePath = resolveScopedWorktreePath(data, projectRoot, currentPath);
-    return (data.sessions ?? [])
+    const scopedSessions = (data.sessions ?? [])
         .filter((session) => session.status !== "offline" && session.status !== "exited")
-        .filter((session) => normalizePath(session.worktreePath, projectRoot) === scopedWorktreePath)
-        .sort((left, right) => {
-        const leftKind = left.kind === "service" ? 1 : 0;
-        const rightKind = right.kind === "service" ? 1 : 0;
-        if (leftKind !== rightKind)
-            return leftKind - rightKind;
-        const leftIndex = left.tmuxWindowIndex ?? Number.MAX_SAFE_INTEGER;
-        const rightIndex = right.tmuxWindowIndex ?? Number.MAX_SAFE_INTEGER;
-        if (leftIndex !== rightIndex)
-            return leftIndex - rightIndex;
-        return compactSessionTitle(left).localeCompare(compactSessionTitle(right));
-    })
+        .filter((session) => normalizePath(session.worktreePath, projectRoot) === scopedWorktreePath);
+    return [
+        ...scopedSessions.filter((session) => session.kind !== "service"),
+        ...scopedSessions.filter((session) => session.kind === "service"),
+    ]
         .slice(0, 5)
         .map((session) => {
         const resolvedMetadata = data.metadata?.[session.id];
@@ -153,6 +169,66 @@ export function resolveScopedSessions(data, projectRoot, currentSession, current
         };
     });
 }
+export function resolveFocusedTeammate(data, projectRoot, currentSession, currentWindow, currentWindowId, currentPath) {
+    const exactCurrentSessionId = resolveExactCurrentSessionId(data, currentSession, currentWindow, currentWindowId, currentPath, projectRoot);
+    if (!exactCurrentSessionId)
+        return null;
+    const teammate = (data.teammates ?? []).find((session) => session.id === exactCurrentSessionId);
+    if (!teammate || teammate.status === "offline" || teammate.status === "exited")
+        return null;
+    const resolvedMetadata = data.metadata?.[teammate.id];
+    return {
+        ...teammate,
+        derived: resolvedMetadata?.derived,
+        semantic: teammate.semantic,
+        metadata: resolvedMetadata,
+        isCurrent: true,
+    };
+}
+export function resolveFocusedTeammateGroup(data, projectRoot, currentSession, currentWindow, currentWindowId, currentPath) {
+    const focusedTeammate = resolveFocusedTeammate(data, projectRoot, currentSession, currentWindow, currentWindowId, currentPath);
+    const parentSessionId = focusedTeammate?.team?.parentSessionId;
+    if (!focusedTeammate || !parentSessionId)
+        return [];
+    return (data.teammates ?? [])
+        .filter((session) => session.team?.parentSessionId === parentSessionId)
+        .filter((session) => session.status !== "offline" && session.status !== "exited")
+        .sort(compareTeammateSessions)
+        .slice(0, 5)
+        .map((session) => {
+        const resolvedMetadata = data.metadata?.[session.id];
+        return {
+            ...session,
+            derived: resolvedMetadata?.derived,
+            semantic: session.semantic,
+            metadata: resolvedMetadata,
+            isCurrent: session.id === focusedTeammate.id,
+        };
+    });
+}
+export function resolveCurrentTeammates(data, projectRoot, currentSession, currentWindow, currentWindowId, currentPath) {
+    const parentSessionId = resolveExactCurrentSessionId(data, currentSession, currentWindow, currentWindowId, currentPath, projectRoot);
+    if (!parentSessionId)
+        return [];
+    const parentSession = (data.sessions ?? []).find((session) => session.id === parentSessionId);
+    if (!parentSession || isTeammateSession(parentSession))
+        return [];
+    return (data.teammates ?? [])
+        .filter((session) => session.team?.parentSessionId === parentSessionId)
+        .filter((session) => session.status !== "offline" && session.status !== "exited")
+        .sort(compareTeammateSessions)
+        .slice(0, 5)
+        .map((session) => {
+        const resolvedMetadata = data.metadata?.[session.id];
+        return {
+            ...session,
+            derived: resolvedMetadata?.derived,
+            semantic: session.semantic,
+            metadata: resolvedMetadata,
+            isCurrent: false,
+        };
+    });
+}
 export function resolveSessionMetadata(data, projectRoot, currentSession, currentWindow, currentWindowId, currentPath) {
     const activeSessionId = resolveCurrentSessionId(data, currentSession, currentWindow, currentWindowId, currentPath, projectRoot);
     if (!activeSessionId)
@@ -165,4 +241,3 @@ export function resolveExactSessionMetadata(data, projectRoot, currentSession, c
         return undefined;
     return data.metadata?.[activeSessionId];
 }
-//# sourceMappingURL=statusline-model.js.map

package/dist/task-workflow.d.ts

@@ -1,15 +1,12 @@
 import { type Task } from "./tasks.js";
-import type { TaskEvent } from "./task-dispatcher.js";
-interface DispatchSession {
-    id: string;
-    write(data: string): void;
+export interface TaskEvent {
+    type: "assigned" | "completed" | "failed" | "review_created" | "review_approved" | "changes_requested";
+    taskId: string;
+    sessionId: string;
+    description: string;
 }
 export declare class TaskWorkflow {
-    private readonly deliverPrompt;
-    constructor(deliverPrompt?: (session: DispatchSession, prompt: string) => void);
-    injectIntoSession(session: DispatchSession, task: Task): TaskEvent;
-    notifyAssigner(session: DispatchSession, task: Task): void;
     handleCompletion(task: Task): TaskEvent[];
     private handleReviewCompletion;
 }
-export {};
+export declare function requestReview(agentSessionId: string, agentRole: string, diff: string | undefined, summary: string): Promise<Task | null>;

package/dist/task-workflow.js

@@ -1,87 +1,6 @@
 import { normalizeReviewStatus, writeTask } from "./tasks.js";
 import { loadTeamConfig } from "./team.js";
-import { markMessageDelivered, openTaskThread, updateThread } from "./threads.js";
-import { sendThreadMessage } from "./orchestration.js";
 export class TaskWorkflow {
-    deliverPrompt;
-    constructor(deliverPrompt = defaultDeliverPrompt) {
-        this.deliverPrompt = deliverPrompt;
-    }
-    injectIntoSession(session, task) {
-        const thread = openTaskThread(task.id, {
-            title: `${task.type === "review" ? "Review" : "Task"}: ${task.description}`,
-            createdBy: task.assignedBy,
-            participants: [task.assignedBy, session.id],
-            kind: task.type === "review" ? "review" : "task",
-        });
-        task.threadId = thread.id;
-        const initialMessage = sendThreadMessage({
-            threadId: thread.id,
-            from: task.assignedBy,
-            to: [session.id],
-            kind: "request",
-            body: task.description,
-            metadata: { taskId: task.id },
-        });
-        markMessageDelivered(thread.id, initialMessage.message.id, session.id);
-        const prefix = task.type === "review"
-            ? `[AIMUX REVIEW ${task.id} from ${task.assignedBy}]`
-            : `[AIMUX TASK ${task.id} from ${task.assignedBy}]`;
-        let prompt = `${prefix} ${task.description}\n\n`;
-        if (task.type === "review" && task.diff) {
-            prompt += `Diff to review:\n${task.diff.slice(0, 3000)}\n\n`;
-        }
-        prompt +=
-            `Run:\n` +
-                `  aimux task show ${task.id}\n` +
-                `  aimux thread show ${thread.id}\n\n` +
-                `Acknowledge with:\n` +
-                `  aimux task accept ${task.id} --from ${session.id}\n\n` +
-                `When done, complete with:\n` +
-                `  aimux task complete ${task.id} --from ${session.id} --body "<summary>"`;
-        if (task.type === "review") {
-            prompt +=
-                `\n\nFor review verdicts use:\n` +
-                    `  aimux review approve ${task.id} --from ${session.id} --body "<notes>"\n` +
-                    `  aimux review request-changes ${task.id} --from ${session.id} --body "<requested changes>"`;
-        }
-        else {
-            prompt += `\n\nIf blocked, use:\n  aimux task block ${task.id} --from ${session.id} --body "<reason>"`;
-        }
-        this.deliverPrompt(session, prompt);
-        task.status = "assigned";
-        task.assignedTo = session.id;
-        writeTask(task);
-        return {
-            type: "assigned",
-            taskId: task.id,
-            sessionId: session.id,
-            description: task.description,
-        };
-    }
-    notifyAssigner(session, task) {
-        if (task.threadId) {
-            sendThreadMessage({
-                threadId: task.threadId,
-                from: task.assignedTo ?? task.assignedBy,
-                to: [task.assignedBy],
-                kind: task.status === "done" ? "status" : "reply",
-                body: task.status === "done"
-                    ? `Completed: ${task.description}${task.result ? `\n\n${task.result}` : ""}`
-                    : `Failed: ${task.description}${task.error ? `\n\n${task.error}` : ""}`,
-                metadata: { taskId: task.id, status: task.status },
-            });
-            updateThread(task.threadId, (current) => ({
-                ...current,
-                status: task.status === "done" ? "done" : "blocked",
-                owner: task.assignedBy,
-                waitingOn: [],
-            }));
-        }
-        this.deliverPrompt(session, `[AIMUX TASK COMPLETE ${task.id}] Agent ${task.assignedTo} finished: ${task.result ?? task.error ?? "no details"}`);
-        task.notifiedAt = new Date().toISOString();
-        writeTask(task);
-    }
     handleCompletion(task) {
         if (task.type === "review") {
             return this.handleReviewCompletion(task);
@@ -164,8 +83,41 @@ export class TaskWorkflow {
         ];
     }
 }
-function defaultDeliverPrompt(session, prompt) {
-    // Production multiplexer wiring overrides this with writeAgentInput(..., submit: true).
-    session.write(prompt + "\r");
+export async function requestReview(agentSessionId, agentRole, diff, summary) {
+    const config = loadTeamConfig();
+    const roleConfig = config.roles[agentRole];
+    let reviewerRole = roleConfig?.reviewedBy;
+    if (!reviewerRole) {
+        const roles = Object.entries(config.roles).filter(([roleKey]) => roleKey !== agentRole);
+        const fallback = roles.find(([, role]) => role.description.toLowerCase().includes("review")) ??
+            roles.find(([, role]) => role.canEdit);
+        if (!fallback)
+            return null;
+        reviewerRole = fallback[0];
+    }
+    if (reviewerRole === agentRole) {
+        const roles = Object.entries(config.roles).filter(([roleKey]) => roleKey !== agentRole);
+        const fallback = roles.find(([, role]) => role.description.toLowerCase().includes("review")) ??
+            roles.find(([, role]) => role.canEdit);
+        if (!fallback)
+            return null;
+        reviewerRole = fallback[0];
+    }
+    const reviewTask = {
+        id: `review-manual-${Date.now().toString(36)}`,
+        status: "pending",
+        assignedBy: agentSessionId,
+        description: `Review: ${summary.slice(0, 100)}`,
+        prompt: summary,
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        assignee: reviewerRole,
+        assigner: agentRole,
+        type: "review",
+        reviewStatus: "pending",
+        diff,
+        iteration: 1,
+    };
+    await writeTask(reviewTask);
+    return reviewTask;
 }
-//# sourceMappingURL=task-workflow.js.map

package/dist/tasks.d.ts

@@ -1,36 +1,9 @@
-export type TaskStatus = "pending" | "assigned" | "in_progress" | "blocked" | "done" | "failed";
+import { type RuntimeExchangeTask } from "./runtime-core/exchange-store.js";
+export type TaskStatus = RuntimeExchangeTask["status"];
 export type ReviewStatus = "pending" | "approved" | "changes_requested";
 export type ReviewStatusInput = ReviewStatus | "approve" | "request-changes" | "request_changes" | "changes-requested" | "changes requested";
-export interface Task {
-    id: string;
-    status: TaskStatus;
-    assignedBy: string;
-    assignedTo?: string;
-    threadId?: string;
-    tool?: string;
-    description: string;
-    prompt: string;
-    result?: string;
-    error?: string;
-    createdAt: string;
-    updatedAt: string;
-    notifiedAt?: string;
-    /** Role name of the intended assignee (e.g. "coder", "reviewer") */
-    assignee?: string;
-    /** Role name of the task creator */
-    assigner?: string;
-    /** Task type: regular task or code review */
-    type?: "task" | "review";
-    /** Review verdict */
+export interface Task extends Omit<RuntimeExchangeTask, "reviewStatus"> {
     reviewStatus?: ReviewStatusInput;
-    /** Reviewer feedback text */
-    reviewFeedback?: string;
-    /** Git diff associated with the task */
-    diff?: string;
-    /** Revision iteration count (incremented on each review round-trip) */
-    iteration?: number;
-    /** ID of the task this review refers to */
-    reviewOf?: string;
 }
 export declare function normalizeReviewStatus(status: unknown): ReviewStatus | undefined;
 /**
@@ -38,13 +11,13 @@ export declare function normalizeReviewStatus(status: unknown): ReviewStatus | u
  */
 export declare function readTask(id: string): Task | undefined;
 /**
- * Read all tasks from the tasks directory.
+ * Read all tasks from the runtime exchange.
  */
 export declare function readAllTasks(): Task[];
 /**
- * Write a task to disk with file locking.
+ * Write a task to the runtime exchange.
  */
-export declare function writeTask(task: Task): Promise<void>;
+export declare function writeTask(task: Task): void;
 /**
  * Returns true if the session has an active (assigned) task.
  */

package/dist/tasks.js

@@ -1,7 +1,5 @@
-import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, unlinkSync } from "node:fs";
-import { join } from "node:path";
-import * as lockfile from "proper-lockfile";
-import { getTasksDir } from "./paths.js";
+import { deriveRuntimeExchangeIndexes } from "./runtime-core/exchange-derived.js";
+import { createRuntimeExchangeStore } from "./runtime-core/exchange-store.js";
 export function normalizeReviewStatus(status) {
     if (!status)
         return undefined;
@@ -17,122 +15,81 @@ export function normalizeReviewStatus(status) {
         return "changes_requested";
     return undefined;
 }
-const LOCK_RETRIES = { retries: 5, minTimeout: 50 };
-/**
- * Get the tasks directory path, creating it if needed.
- */
-function ensureTasksDir() {
-    const dir = getTasksDir();
-    if (!existsSync(dir)) {
-        mkdirSync(dir, { recursive: true });
-    }
-    return dir;
+function nowIso() {
+    return new Date().toISOString();
+}
+function toExchangeTask(task, updatedAt) {
+    return {
+        ...task,
+        updatedAt,
+        reviewStatus: normalizeReviewStatus(task.reviewStatus),
+    };
+}
+function fromExchangeTask(task) {
+    return { ...task };
 }
 /**
  * Read a single task by ID.
  */
 export function readTask(id) {
-    const filePath = join(ensureTasksDir(), `${id}.json`);
-    if (!existsSync(filePath))
-        return undefined;
-    try {
-        return JSON.parse(readFileSync(filePath, "utf-8"));
-    }
-    catch {
-        return undefined;
-    }
+    const task = createRuntimeExchangeStore()
+        .read()
+        .tasks.find((entry) => entry.id === id);
+    return task ? fromExchangeTask(task) : undefined;
 }
 /**
- * Read all tasks from the tasks directory.
+ * Read all tasks from the runtime exchange.
  */
 export function readAllTasks() {
-    const dir = ensureTasksDir();
-    const tasks = [];
-    let files;
-    try {
-        files = readdirSync(dir).filter((f) => f.endsWith(".json"));
-    }
-    catch {
-        return tasks;
-    }
-    for (const file of files) {
-        try {
-            const data = readFileSync(join(dir, file), "utf-8");
-            tasks.push(JSON.parse(data));
-        }
-        catch {
-            // skip corrupt files
-        }
-    }
-    return tasks;
+    return createRuntimeExchangeStore().read().tasks.map(fromExchangeTask);
 }
 /**
- * Write a task to disk with file locking.
+ * Write a task to the runtime exchange.
  */
-export async function writeTask(task) {
-    const dir = ensureTasksDir();
-    const filePath = join(dir, `${task.id}.json`);
-    // Ensure the file exists for proper-lockfile (it locks existing files)
-    if (!existsSync(filePath)) {
-        writeFileSync(filePath, "{}");
-    }
-    let release;
-    try {
-        release = await lockfile.lock(filePath, { retries: LOCK_RETRIES });
-        task.updatedAt = new Date().toISOString();
-        writeFileSync(filePath, JSON.stringify(task, null, 2) + "\n");
-    }
-    finally {
-        if (release)
-            await release();
-    }
+export function writeTask(task) {
+    const updatedAt = nowIso();
+    createRuntimeExchangeStore().update((exchange) => deriveRuntimeExchangeIndexes({
+        ...exchange,
+        generatedAt: updatedAt,
+        tasks: [...exchange.tasks.filter((existing) => existing.id !== task.id), toExchangeTask(task, updatedAt)],
+    }));
+    task.updatedAt = updatedAt;
+    task.reviewStatus = normalizeReviewStatus(task.reviewStatus);
 }
 /**
  * Returns true if the session has an active (assigned) task.
  */
 export function hasActiveTask(sessionId) {
-    const all = readAllTasks();
-    return all.some((t) => ["assigned", "in_progress", "blocked"].includes(t.status) && t.assignedTo === sessionId);
+    return readAllTasks().some((task) => ["assigned", "in_progress", "blocked"].includes(task.status) && task.assignedTo === sessionId);
 }
 /**
  * Remove done/failed tasks older than maxAgeMs.
  */
 export function cleanupTasks(maxAgeMs) {
-    const dir = ensureTasksDir();
     const now = Date.now();
-    let files;
-    try {
-        files = readdirSync(dir).filter((f) => f.endsWith(".json"));
-    }
-    catch {
-        return;
-    }
-    for (const file of files) {
-        try {
-            const data = readFileSync(join(dir, file), "utf-8");
-            const task = JSON.parse(data);
-            if ((task.status === "done" || task.status === "failed") && now - new Date(task.updatedAt).getTime() > maxAgeMs) {
-                unlinkSync(join(dir, file));
-            }
-        }
-        catch {
-            // skip
-        }
-    }
+    const generatedAt = nowIso();
+    createRuntimeExchangeStore().update((exchange) => deriveRuntimeExchangeIndexes({
+        ...exchange,
+        generatedAt,
+        tasks: exchange.tasks.filter((task) => {
+            if (task.status !== "done" && task.status !== "failed")
+                return true;
+            return now - new Date(task.updatedAt).getTime() <= maxAgeMs;
+        }),
+    }));
 }
 /**
  * List pending review tasks assigned to a given role.
  */
 export function listPendingReviews(role) {
-    return readAllTasks().filter((t) => t.type === "review" &&
-        t.assignee === role &&
-        t.status === "pending" &&
-        normalizeReviewStatus(t.reviewStatus) === "pending");
+    return readAllTasks().filter((task) => task.type === "review" &&
+        task.assignee === role &&
+        task.status === "pending" &&
+        normalizeReviewStatus(task.reviewStatus) === "pending");
 }
 /**
  * List active tasks assigned to a given role (pending or assigned, not done/failed).
  */
 export function listTasksForRole(role) {
-    return readAllTasks().filter((t) => t.assignee === role && t.status !== "done" && t.status !== "failed");
+    return readAllTasks().filter((task) => task.assignee === role && task.status !== "done" && task.status !== "failed");
 }
-//# sourceMappingURL=tasks.js.map

package/dist/team.d.ts

@@ -9,6 +9,35 @@ export interface TeamConfig {
     roles: Record<string, RoleConfig>;
     defaultRole: string;
 }
+export interface SessionTeamMetadata {
+    teamId: string;
+    parentSessionId: string;
+    role?: string;
+    label?: string;
+    order?: number;
+}
+export declare function isTeammateSession(session: {
+    team?: SessionTeamMetadata;
+} | undefined): boolean;
+export declare function compareTeammateSessions(left: {
+    id: string;
+    createdAt?: string;
+    team?: SessionTeamMetadata;
+}, right: {
+    id: string;
+    createdAt?: string;
+    team?: SessionTeamMetadata;
+}): number;
+export declare function selectDirectTeammates<T extends {
+    id: string;
+    createdAt?: string;
+    team?: SessionTeamMetadata;
+}>(sessions: T[], parentSessionId: string): T[];
+export declare function selectOrphanTeammates<T extends {
+    id: string;
+    createdAt?: string;
+    team?: SessionTeamMetadata;
+}>(sessions: T[], knownParentIds: Iterable<string>): T[];
 export declare function getDefaultTeamConfig(): TeamConfig;
 /**
  * Load team config: project .aimux/team.json → global ~/.aimux/team.json → built-in defaults.