aimux-cli 0.1.16 → 0.1.19

package/dist/team.js

@@ -1,5 +1,45 @@
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
 import { getLocalAimuxDir, getProjectTeamPath, getGlobalTeamPath, getGlobalAimuxDir } from "./paths.js";
+export function isTeammateSession(session) {
+    return Boolean(session?.team?.parentSessionId);
+}
+export function compareTeammateSessions(left, right) {
+    const leftOrder = typeof left.team?.order === "number" ? left.team.order : Number.POSITIVE_INFINITY;
+    const rightOrder = typeof right.team?.order === "number" ? right.team.order : Number.POSITIVE_INFINITY;
+    if (leftOrder !== rightOrder)
+        return leftOrder - rightOrder;
+    const leftCreated = left.createdAt ? Date.parse(left.createdAt) : Number.POSITIVE_INFINITY;
+    const rightCreated = right.createdAt ? Date.parse(right.createdAt) : Number.POSITIVE_INFINITY;
+    const normalizedLeftCreated = Number.isFinite(leftCreated) ? leftCreated : Number.POSITIVE_INFINITY;
+    const normalizedRightCreated = Number.isFinite(rightCreated) ? rightCreated : Number.POSITIVE_INFINITY;
+    if (normalizedLeftCreated !== normalizedRightCreated)
+        return normalizedLeftCreated - normalizedRightCreated;
+    return left.id.localeCompare(right.id);
+}
+export function selectDirectTeammates(sessions, parentSessionId) {
+    const byId = new Map();
+    for (const session of sessions) {
+        if (session.team?.parentSessionId !== parentSessionId)
+            continue;
+        if (!byId.has(session.id)) {
+            byId.set(session.id, session);
+        }
+    }
+    return [...byId.values()].sort(compareTeammateSessions);
+}
+export function selectOrphanTeammates(sessions, knownParentIds) {
+    const parents = new Set(knownParentIds);
+    const byId = new Map();
+    for (const session of sessions) {
+        const parentSessionId = session.team?.parentSessionId;
+        if (!parentSessionId || parents.has(parentSessionId))
+            continue;
+        if (!byId.has(session.id)) {
+            byId.set(session.id, session);
+        }
+    }
+    return [...byId.values()].sort(compareTeammateSessions);
+}
 const DEFAULT_TEAM_CONFIG = {
     roles: {
         coder: {
@@ -88,4 +128,3 @@ export function buildRolePreamble(role, config) {
     }
     return lines.join("\n");
 }
-//# sourceMappingURL=team.js.map

package/dist/terminal-host.js

@@ -49,4 +49,3 @@ export class TerminalHost {
         catch { }
     }
 }
-//# sourceMappingURL=terminal-host.js.map

package/dist/threads.d.ts

@@ -1,38 +1,9 @@
-export type ThreadKind = "conversation" | "task" | "review" | "handoff" | "user";
-export type ThreadStatus = "open" | "waiting" | "blocked" | "done" | "abandoned";
-export type MessageKind = "request" | "reply" | "status" | "decision" | "handoff" | "note";
-export interface OrchestrationThread {
-    id: string;
-    title: string;
-    kind: ThreadKind;
-    createdAt: string;
-    updatedAt: string;
-    createdBy: string;
-    participants: string[];
-    status: ThreadStatus;
-    owner?: string;
-    waitingOn?: string[];
-    worktreePath?: string;
-    taskId?: string;
-    relatedPlanIds?: string[];
-    lastMessageId?: string;
-    unreadBy?: string[];
-    tags?: string[];
-}
-export interface OrchestrationMessage {
-    id: string;
-    threadId: string;
-    ts: string;
-    from: string;
-    to?: string[];
-    kind: MessageKind;
-    body: string;
-    taskId?: string;
-    planId?: string;
-    metadata?: Record<string, string | number | boolean | null>;
-    deliveredTo?: string[];
-    deliveredAt?: string;
-}
+import { type RuntimeExchangeMessage, type RuntimeExchangeThread } from "./runtime-core/exchange-store.js";
+export type ThreadKind = RuntimeExchangeThread["kind"];
+export type ThreadStatus = RuntimeExchangeThread["status"];
+export type MessageKind = RuntimeExchangeMessage["kind"];
+export type OrchestrationThread = RuntimeExchangeThread;
+export type OrchestrationMessage = RuntimeExchangeMessage;
 export interface ThreadSummary {
     thread: OrchestrationThread;
     latestMessage?: OrchestrationMessage;

package/dist/threads.js

@@ -1,33 +1,32 @@
-import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { getThreadsDir } from "./paths.js";
-function threadsDir() {
-    const dir = getThreadsDir();
-    if (!existsSync(dir))
-        mkdirSync(dir, { recursive: true });
-    return dir;
-}
-function threadPath(threadId) {
-    return join(threadsDir(), `${threadId}.json`);
-}
-function messagesPath(threadId) {
-    return join(threadsDir(), `${threadId}.jsonl`);
-}
+import { deriveRuntimeExchangeIndexes } from "./runtime-core/exchange-derived.js";
+import { createRuntimeExchangeStore, } from "./runtime-core/exchange-store.js";
 function nowIso() {
     return new Date().toISOString();
 }
 function randomId(prefix) {
     return `${prefix}-${Math.random().toString(36).slice(2, 10)}`;
 }
+function unique(values) {
+    return [...new Set(values.map((value) => value?.trim()).filter(Boolean))];
+}
+function threadUpdatedForMessage(thread, message, updatedAt) {
+    return {
+        ...thread,
+        updatedAt,
+        lastMessageId: message.id,
+        unreadBy: unique((thread.participants ?? []).filter((id) => id !== message.from)),
+    };
+}
 export function createThread(input) {
+    const now = nowIso();
     const thread = {
         id: input.id ?? randomId("thread"),
         title: input.title,
         kind: input.kind,
-        createdAt: nowIso(),
-        updatedAt: nowIso(),
+        createdAt: now,
+        updatedAt: now,
         createdBy: input.createdBy,
-        participants: [...new Set(input.participants)],
+        participants: unique(input.participants),
         status: input.status ?? "open",
         owner: input.owner,
         waitingOn: input.waitingOn,
@@ -38,56 +37,50 @@ export function createThread(input) {
         unreadBy: input.unreadBy,
         tags: input.tags,
     };
-    writeFileSync(threadPath(thread.id), JSON.stringify(thread, null, 2) + "\n");
+    createRuntimeExchangeStore().update((exchange) => deriveRuntimeExchangeIndexes({
+        ...exchange,
+        generatedAt: now,
+        threads: [...exchange.threads.filter((existing) => existing.id !== thread.id), thread],
+    }));
     return thread;
 }
 export function readThread(threadId) {
-    if (!existsSync(threadPath(threadId)))
-        return undefined;
-    try {
-        return JSON.parse(readFileSync(threadPath(threadId), "utf-8"));
-    }
-    catch {
-        return undefined;
-    }
+    return createRuntimeExchangeStore()
+        .read()
+        .threads.find((thread) => thread.id === threadId);
 }
 export function updateThread(threadId, updater) {
-    const current = readThread(threadId);
-    if (!current)
-        return undefined;
-    const next = {
-        ...updater(current),
-        id: current.id,
-        createdAt: current.createdAt,
-        updatedAt: nowIso(),
-    };
-    writeFileSync(threadPath(threadId), JSON.stringify(next, null, 2) + "\n");
-    return next;
+    const now = nowIso();
+    let updated;
+    createRuntimeExchangeStore().update((exchange) => {
+        const threads = exchange.threads.map((current) => {
+            if (current.id !== threadId)
+                return current;
+            updated = {
+                ...updater(current),
+                id: current.id,
+                createdAt: current.createdAt,
+                updatedAt: now,
+            };
+            return updated;
+        });
+        return deriveRuntimeExchangeIndexes({
+            ...exchange,
+            generatedAt: updated ? now : exchange.generatedAt,
+            threads,
+        });
+    });
+    return updated;
 }
 export function listThreads() {
-    try {
-        return readdirSync(threadsDir())
-            .filter((name) => name.endsWith(".json"))
-            .map((name) => {
-            try {
-                return JSON.parse(readFileSync(join(threadsDir(), name), "utf-8"));
-            }
-            catch {
-                return undefined;
-            }
-        })
-            .filter((value) => Boolean(value))
-            .sort((a, b) => (a.updatedAt < b.updatedAt ? 1 : a.updatedAt > b.updatedAt ? -1 : 0));
-    }
-    catch {
-        return [];
-    }
+    return [...createRuntimeExchangeStore().read().threads].sort((a, b) => a.updatedAt < b.updatedAt ? 1 : a.updatedAt > b.updatedAt ? -1 : 0);
 }
 export function appendMessage(threadId, input) {
+    const now = nowIso();
     const message = {
         id: input.id ?? randomId("msg"),
         threadId,
-        ts: input.ts ?? nowIso(),
+        ts: input.ts ?? now,
         from: input.from,
         to: input.to,
         kind: input.kind,
@@ -95,61 +88,59 @@ export function appendMessage(threadId, input) {
         taskId: input.taskId,
         planId: input.planId,
         metadata: input.metadata,
+        deliveredTo: input.deliveredTo,
+        deliveredAt: input.deliveredAt,
     };
-    appendFileSync(messagesPath(threadId), JSON.stringify(message) + "\n");
-    updateThread(threadId, (current) => ({
-        ...current,
-        lastMessageId: message.id,
-        unreadBy: [...new Set((current.participants ?? []).filter((id) => id !== message.from))],
-    }));
+    let threadFound = false;
+    createRuntimeExchangeStore().update((exchange) => {
+        const threads = exchange.threads.map((thread) => {
+            if (thread.id !== threadId)
+                return thread;
+            threadFound = true;
+            return threadUpdatedForMessage(thread, message, now);
+        });
+        if (!threadFound)
+            throw new Error(`thread not found: ${threadId}`);
+        return deriveRuntimeExchangeIndexes({
+            ...exchange,
+            generatedAt: now,
+            threads,
+            messages: [...exchange.messages.filter((existing) => existing.id !== message.id), message],
+        });
+    });
     return message;
 }
 export function readMessages(threadId) {
-    if (!existsSync(messagesPath(threadId)))
-        return [];
-    try {
-        return readFileSync(messagesPath(threadId), "utf-8")
-            .split("\n")
-            .map((line) => line.trim())
-            .filter(Boolean)
-            .map((line) => {
-            try {
-                return JSON.parse(line);
-            }
-            catch {
-                return undefined;
-            }
-        })
-            .filter((value) => Boolean(value));
-    }
-    catch {
-        return [];
-    }
+    return createRuntimeExchangeStore()
+        .read()
+        .messages.filter((message) => message.threadId === threadId)
+        .sort((a, b) => (a.ts < b.ts ? -1 : a.ts > b.ts ? 1 : 0));
 }
 export function updateMessage(threadId, messageId, updater) {
-    const messages = readMessages(threadId);
-    if (messages.length === 0)
-        return undefined;
     let updated;
-    const nextMessages = messages.map((message) => {
-        if (message.id !== messageId)
-            return message;
-        updated = {
-            ...updater(message),
-            id: message.id,
-            threadId: message.threadId,
-            ts: message.ts,
+    createRuntimeExchangeStore().update((exchange) => {
+        const messages = exchange.messages.map((message) => {
+            if (message.threadId !== threadId || message.id !== messageId)
+                return message;
+            updated = {
+                ...updater(message),
+                id: message.id,
+                threadId: message.threadId,
+                ts: message.ts,
+            };
+            return updated;
+        });
+        return {
+            ...exchange,
+            generatedAt: updated ? nowIso() : exchange.generatedAt,
+            messages,
         };
-        return updated;
     });
-    if (!updated)
-        return undefined;
-    writeFileSync(messagesPath(threadId), nextMessages.map((message) => JSON.stringify(message)).join("\n") + "\n");
     return updated;
 }
 export function markMessageDelivered(threadId, messageId, recipient) {
     return updateMessage(threadId, messageId, (current) => {
-        const deliveredTo = [...new Set([...(current.deliveredTo ?? []), recipient])];
+        const deliveredTo = unique([...(current.deliveredTo ?? []), recipient]);
         return {
             ...current,
             deliveredTo,
@@ -197,4 +188,3 @@ export function listThreadSummaries(participantId) {
         };
     });
 }
-//# sourceMappingURL=threads.js.map

package/dist/tmux/doctor.js

@@ -249,4 +249,3 @@ export function renderTmuxRepairResult(result) {
         `  dashboard target: ${result.dashboardSessionName}:${result.dashboardWindowId}`,
     ].join("\n");
 }
-//# sourceMappingURL=doctor.js.map

package/dist/tmux/inbox-popup.js

@@ -2,6 +2,7 @@ import { readFileSync } from "node:fs";
 import { TerminalHost } from "../terminal-host.js";
 import { parseKeys } from "../key-parser.js";
 import { requestJson } from "../http-client.js";
+import { TmuxRuntimeManager } from "./runtime-manager.js";
 function wrapText(text, width) {
     if (width <= 8)
         return [text.slice(0, Math.max(0, width))];
@@ -66,20 +67,39 @@ function loadEndpoint(projectStateDir) {
         throw new Error("no live project service metadata endpoint");
     return raw;
 }
-async function loadInboxEntries(endpoint) {
-    const [{ status: notificationsStatus, json: notificationsBody }, { status: desktopStatus, json: desktopBody }] = await Promise.all([
-        requestJson(`${endpoint}/notifications`, { timeoutMs: 2000 }),
-        requestJson(`${endpoint}/desktop-state`, { timeoutMs: 2000 }),
+function resolveFocusedParticipant(options) {
+    const currentWindowId = options.currentWindowId?.trim();
+    if (!currentWindowId || (options.currentWindow?.trim() && /^dashboard/.test(options.currentWindow.trim()))) {
+        return undefined;
+    }
+    try {
+        const tmux = new TmuxRuntimeManager();
+        const match = tmux
+            .listProjectManagedWindows(options.projectRoot)
+            .find((entry) => entry.target.windowId === currentWindowId);
+        return match?.metadata.sessionId?.trim() || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function loadInboxEntries(endpoint, participantId) {
+    const query = participantId ? `?participant=${encodeURIComponent(participantId)}` : "";
+    const [{ status: inboxStatus, json: inboxBody }, { status: desktopStatus, json: desktopBody }] = await Promise.all([
+        requestJson(`${endpoint}/inbox${query}`, { timeoutMs: 2000 }),
+        requestJson(`${endpoint}/desktop-state`, {
+            timeoutMs: 2000,
+        }),
     ]);
-    if (notificationsStatus < 200 || notificationsStatus >= 300) {
+    if (inboxStatus < 200 || inboxStatus >= 300) {
         throw new Error("failed to load inbox");
     }
     if (desktopStatus < 200 || desktopStatus >= 300) {
         throw new Error("failed to load desktop state");
     }
-    const sessions = new Map((desktopBody.sessions ?? []).map((entry) => [entry.id, entry]));
+    const sessions = new Map([...(desktopBody.sessions ?? []), ...(desktopBody.teammates ?? [])].map((entry) => [entry.id, entry]));
     const services = new Map((desktopBody.services ?? []).map((entry) => [entry.id, entry]));
-    return (notificationsBody.notifications ?? []).map((entry) => {
+    return (inboxBody.inbox ?? []).map((entry) => {
         const session = entry.sessionId ? sessions.get(entry.sessionId) : undefined;
         if (session) {
             return {
@@ -98,7 +118,8 @@ async function loadInboxEntries(endpoint) {
         }
         return {
             ...entry,
-            targetState: entry.sessionId ? "missing" : "none",
+            sessionId: undefined,
+            targetState: "none",
         };
     });
 }
@@ -163,7 +184,8 @@ function renderPopup(entries, index, message) {
 }
 export async function runTmuxInboxPopup(options) {
     const endpoint = loadEndpoint(options.projectStateDir);
-    let entries = await loadInboxEntries(endpoint);
+    const participantId = resolveFocusedParticipant(options);
+    let entries = await loadInboxEntries(endpoint, participantId);
     let index = entries.length > 0 ? 0 : -1;
     let message = null;
     const terminal = new TerminalHost();
@@ -177,7 +199,7 @@ export async function runTmuxInboxPopup(options) {
         return code;
     };
     const refresh = async (nextMessage = null) => {
-        entries = await loadInboxEntries(endpoint);
+        entries = await loadInboxEntries(endpoint, participantId);
         if (index >= entries.length)
             index = Math.max(0, entries.length - 1);
         if (entries.length === 0)
@@ -213,24 +235,24 @@ export async function runTmuxInboxPopup(options) {
             if (key === "r") {
                 if (!selected)
                     return;
-                await postJson(endpoint, "/notifications/read", { id: selected.id });
+                await postJson(endpoint, "/inbox/read", { id: selected.id });
                 await refresh(null);
                 return;
             }
             if (key === "R") {
-                await postJson(endpoint, "/notifications/read", {});
+                await postJson(endpoint, "/inbox/read", { participant: participantId });
                 await refresh(null);
                 return;
             }
             if (key === "c") {
                 if (!selected)
                     return;
-                await postJson(endpoint, "/notifications/clear", { id: selected.id });
+                await postJson(endpoint, "/inbox/clear", { id: selected.id });
                 await refresh(null);
                 return;
             }
             if (key === "C") {
-                await postJson(endpoint, "/notifications/clear", {});
+                await postJson(endpoint, "/inbox/clear", { participant: participantId });
                 await refresh(null);
                 return;
             }
@@ -251,7 +273,7 @@ export async function runTmuxInboxPopup(options) {
                         clientTty: options.clientTty,
                     });
                     if (selected.unread) {
-                        await postJson(endpoint, "/notifications/read", { id: selected.id });
+                        await postJson(endpoint, "/inbox/read", { id: selected.id });
                     }
                     process.stdin.off("data", onData);
                     resolve(exit(0));
@@ -264,4 +286,3 @@ export async function runTmuxInboxPopup(options) {
         process.stdin.on("data", onData);
     });
 }
-//# sourceMappingURL=inbox-popup.js.map

package/dist/tmux/runtime-manager.d.ts

@@ -1,3 +1,4 @@
+import type { SessionTeamMetadata } from "../team.js";
 export interface TmuxExecOptions {
     cwd?: string;
 }
@@ -50,8 +51,10 @@ export interface TmuxWindowMetadata {
     toolConfigKey: string;
     createdAt?: string;
     backendSessionId?: string;
+    team?: SessionTeamMetadata;
     worktreePath?: string;
     label?: string;
+    launchCommandLine?: string;
     role?: string;
     activity?: string;
     attention?: string;

package/dist/tmux/runtime-manager.js

@@ -5,7 +5,7 @@ import { mkdtempSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { fileURLToPath } from "node:url";
 import { loadConfig } from "../config.js";
-import { debug } from "../debug.js";
+import { debug, log } from "../debug.js";
 import { getProjectStateDirFor } from "../paths.js";
 export function isDashboardWindowName(name) {
     return name === "dashboard" || name.startsWith("dashboard-");
@@ -560,8 +560,6 @@ export class TmuxRuntimeManager {
         for (const entry of this.listManagedWindows(sessionName)) {
             if (matcher.sessionId && entry.metadata.sessionId === matcher.sessionId)
                 return entry;
-            if (matcher.backendSessionId && entry.metadata.backendSessionId === matcher.backendSessionId)
-                return entry;
         }
         return null;
     }
@@ -652,6 +650,15 @@ export class TmuxRuntimeManager {
                 ...target,
                 sessionName,
             };
+        log.info("opening tmux target", "tmux", {
+            targetSession: target.sessionName,
+            targetWindowId: target.windowId,
+            targetWindowName: target.windowName,
+            effectiveSession: effectiveTarget.sessionName,
+            effectiveWindowIndex: effectiveTarget.windowIndex,
+            insideTmux,
+            alreadyResolved: options.alreadyResolved === true,
+        });
         if (isDashboardWindowName(effectiveTarget.windowName)) {
             this.cancelCopyMode(effectiveTarget);
         }
@@ -739,6 +746,7 @@ export class TmuxRuntimeManager {
         this.exec(["unbind-key", "-T", "prefix", "p"]);
         this.exec(["unbind-key", "-T", "prefix", "d"]);
         this.exec(["unbind-key", "-T", "prefix", "u"]);
+        this.exec(["unbind-key", "-T", "prefix", "e"]);
         this.exec(["unbind-key", "-T", "prefix", "K"]);
         for (const digit of ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"]) {
             this.exec(["unbind-key", "-T", "prefix", digit]);
@@ -795,6 +803,15 @@ export class TmuxRuntimeManager {
             "-b",
             `${controlScript} attention --project-root ${shellQuote(projectRoot)} --project-state-dir ${shellQuote(projectStateDir)} --current-client-session '#{client_session}' --client-tty '#{client_tty}' --current-window '#{window_name}' --current-window-id '#{window_id}' --current-path '#{pane_current_path}' --pane-id '#{pane_id}' >/dev/null 2>&1`,
         ]);
+        this.exec([
+            "bind-key",
+            "-T",
+            "prefix",
+            "e",
+            "run-shell",
+            "-b",
+            `${controlScript} team --project-root ${shellQuote(projectRoot)} --project-state-dir ${shellQuote(projectStateDir)} --current-client-session '#{client_session}' --client-tty '#{client_tty}' --current-window '#{window_name}' --current-window-id '#{window_id}' --current-path '#{pane_current_path}' --pane-id '#{pane_id}' >/dev/null 2>&1`,
+        ]);
         this.exec([
             "bind-key",
             "-T",
@@ -845,7 +862,7 @@ export class TmuxRuntimeManager {
             "-t",
             sessionName,
             "status-format[0]",
-            `#[bg=colour238,fg=colour255,bold] #(${top}) #[default]`,
+            `#[bg=colour238,fg=colour255,bold] #(${top})#[default]#{?pane_in_mode, #[fg=colour214,bold]scroll#[default],}`,
         ]);
         this.exec([
             "set-option",
@@ -953,4 +970,3 @@ export class TmuxRuntimeManager {
 function shellQuote(value) {
     return `'${value.replace(/'/g, `'"'"'`)}'`;
 }
-//# sourceMappingURL=runtime-manager.js.map

package/dist/tmux/session-transport.js

@@ -119,4 +119,3 @@ export class TmuxSessionTransport {
             listener(code);
     }
 }
-//# sourceMappingURL=session-transport.js.map

package/dist/tmux/statusline-cache.js

@@ -25,4 +25,3 @@ export function invalidateTmuxStatuslineArtifacts(projectRoot) {
         catch { }
     }
 }
-//# sourceMappingURL=statusline-cache.js.map