aimux-cli 0.1.16 → 0.1.19

package/dist/multiplexer/runtime-lifecycle-methods.d.ts

@@ -1,31 +1,29 @@
-import type { InstanceSessionRef } from "../instance-registry.js";
 import type { SessionRuntime } from "../session-runtime.js";
 import type { Multiplexer, SavedState, ServiceState, SessionState } from "./index.js";
-import { getRemoteInstancesSafe as getRemoteInstancesSafeImpl } from "./runtime-state.js";
 export type RuntimeLifecycleMethods = {
     writeInstructionFiles(this: Multiplexer): void;
     removeInstructionFiles(this: Multiplexer): void;
     startStatusRefresh(this: Multiplexer): void;
     stopStatusRefresh(this: Multiplexer): void;
-    syncSessionsFromState(this: Multiplexer, state?: SavedState | null): void;
-    loadOfflineSessions(this: Multiplexer, state?: SavedState | null): boolean;
+    syncSessionsFromTopology(this: Multiplexer): void;
+    loadOfflineTopologySessions(this: Multiplexer): boolean;
     loadOfflineServices(this: Multiplexer, state?: SavedState | null): boolean;
     buildLiveServiceStates(this: Multiplexer): ServiceState[];
-    restoreTmuxSessionsFromState(this: Multiplexer, state?: SavedState | null): void;
+    restoreTmuxSessionsFromTopology(this: Multiplexer): void;
     stopSessionToOffline(this: Multiplexer, session: SessionRuntime): void;
     adjustAfterRemove(this: Multiplexer, hasWorktrees: boolean): void;
-    graveyardSession(this: Multiplexer, sessionId: string): void;
+    graveyardSession(this: Multiplexer, sessionId: string, sessionSeed?: any): void;
     isSessionRuntimeLive(this: Multiplexer, runtime: SessionRuntime): boolean;
     evictZombieSession(this: Multiplexer, runtime: SessionRuntime): void;
     resumeOfflineSession(this: Multiplexer, session: SessionState): void;
+    recordSessionBackendSessionId(this: Multiplexer, sessionId: string, backendSessionId: string): {
+        sessionId: string;
+        backendSessionId: string;
+    };
     startHeartbeat(this: Multiplexer): void;
-    handleSessionClaimed(this: Multiplexer, sessionId: string): void;
     stopHeartbeat(this: Multiplexer): void;
     startProjectServiceRefresh(this: Multiplexer): void;
     stopProjectServiceRefresh(this: Multiplexer): void;
-    getRemoteInstancesSafe(this: Multiplexer): ReturnType<typeof getRemoteInstancesSafeImpl>;
-    getRemoteOwnedSessionKeys(this: Multiplexer): Set<string>;
-    getInstanceSessionRefs(this: Multiplexer): InstanceSessionRef[];
     saveState(this: Multiplexer): void;
     teardown(this: Multiplexer): void;
     cleanup(this: Multiplexer): void;

package/dist/multiplexer/runtime-lifecycle-methods.js

@@ -4,10 +4,55 @@ import { join } from "node:path";
 import { closeDebug, debug } from "../debug.js";
 import { loadConfig } from "../config.js";
 import { getStatePath } from "../paths.js";
-import { adjustAfterRemove as adjustAfterRemoveImpl, buildLiveServiceStates as buildLiveServiceStatesImpl, evictZombieSession as evictZombieSessionImpl, getInstanceSessionRefs as getInstanceSessionRefsImpl, getRemoteInstancesSafe as getRemoteInstancesSafeImpl, getRemoteOwnedSessionKeys as getRemoteOwnedSessionKeysImpl, graveyardSession as graveyardSessionImpl, handleSessionClaimed as handleSessionClaimedImpl, isSessionRuntimeLive as isSessionRuntimeLiveImpl, loadOfflineServices as loadOfflineServicesImpl, loadOfflineSessions as loadOfflineSessionsImpl, restoreTmuxSessionsFromState as restoreTmuxSessionsFromStateImpl, resumeOfflineSession as resumeOfflineSessionImpl, startHeartbeat as startHeartbeatImpl, startProjectServiceRefresh as startProjectServiceRefreshImpl, startStatusRefresh as startStatusRefreshImpl, stopHeartbeat as stopHeartbeatImpl, stopProjectServiceRefresh as stopProjectServiceRefreshImpl, stopSessionToOffline as stopSessionToOfflineImpl, stopStatusRefresh as stopStatusRefreshImpl, syncSessionsFromState as syncSessionsFromStateImpl, } from "./runtime-state.js";
+import { buildAimuxAgentInstructions } from "../session-bootstrap.js";
+import { listTopologySessionStates, saveRuntimeTopologySessions } from "../runtime-core/topology-sessions.js";
+import { adjustAfterRemove as adjustAfterRemoveImpl, buildLiveServiceStates as buildLiveServiceStatesImpl, evictZombieSession as evictZombieSessionImpl, graveyardSession as graveyardSessionImpl, isSessionRuntimeLive as isSessionRuntimeLiveImpl, loadOfflineServices as loadOfflineServicesImpl, loadOfflineTopologySessions as loadOfflineTopologySessionsImpl, restoreTmuxSessionsFromTopology as restoreTmuxSessionsFromTopologyImpl, recordSessionBackendSessionId as recordSessionBackendSessionIdImpl, resumeOfflineSession as resumeOfflineSessionImpl, startHeartbeat as startHeartbeatImpl, startProjectServiceRefresh as startProjectServiceRefreshImpl, startStatusRefresh as startStatusRefreshImpl, stopHeartbeat as stopHeartbeatImpl, stopProjectServiceRefresh as stopProjectServiceRefreshImpl, stopSessionToOffline as stopSessionToOfflineImpl, stopStatusRefresh as stopStatusRefreshImpl, syncSessionsFromTopology as syncSessionsFromTopologyImpl, } from "./runtime-state.js";
+const AIMUX_MANAGED_BLOCK_ID = "aimux-agent-instructions";
+const AIMUX_MANAGED_BLOCK_START = `<!-- BEGIN Aimux MANAGED BLOCK: ${AIMUX_MANAGED_BLOCK_ID} -->`;
+const AIMUX_MANAGED_BLOCK_END = `<!-- END Aimux MANAGED BLOCK: ${AIMUX_MANAGED_BLOCK_ID} -->`;
+const LEGACY_DEFAULT_INSTRUCTION_FILES = ["AGENTS.md"];
+function managedInstructionBlock(content) {
+    return `${AIMUX_MANAGED_BLOCK_START}\n${content.trim()}\n${AIMUX_MANAGED_BLOCK_END}`;
+}
+function mergeManagedInstructionBlock(existing, content) {
+    const block = managedInstructionBlock(content);
+    const pattern = new RegExp(`${escapeRegex(AIMUX_MANAGED_BLOCK_START)}[\\s\\S]*?${escapeRegex(AIMUX_MANAGED_BLOCK_END)}`, "m");
+    if (pattern.test(existing)) {
+        return `${existing.replace(pattern, block).trim()}\n`;
+    }
+    const prefix = existing.trimEnd();
+    return `${prefix ? `${prefix}\n\n` : ""}${block}\n`;
+}
+function stripManagedInstructionBlock(existing) {
+    const pattern = new RegExp(`(?:\\n|^)\\s*${escapeRegex(AIMUX_MANAGED_BLOCK_START)}[\\s\\S]*?${escapeRegex(AIMUX_MANAGED_BLOCK_END)}\\s*(?=\\n|$)`, "m");
+    return existing
+        .replace(pattern, "\n")
+        .replace(/\n{3,}/g, "\n\n")
+        .trim();
+}
+function cleanupManagedInstructionFile(filePath) {
+    if (!existsSync(filePath))
+        return;
+    const existing = readFileSync(filePath, "utf-8");
+    if (!existing.includes(AIMUX_MANAGED_BLOCK_START) || !existing.includes(AIMUX_MANAGED_BLOCK_END))
+        return;
+    const cleaned = stripManagedInstructionBlock(existing);
+    if (cleaned) {
+        writeFileSync(filePath, `${cleaned}\n`);
+    }
+    else {
+        unlinkSync(filePath);
+    }
+}
+function escapeRegex(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 function sanitizeOfflineSessionState(session) {
     const { tmuxTarget: _tmuxTarget, ...rest } = session;
-    return { ...rest, lifecycle: "offline" };
+    return {
+        ...rest,
+        lifecycle: "offline",
+    };
 }
 function sessionStateKey(session) {
     return session.backendSessionId ? `backend:${session.backendSessionId}` : `id:${session.id}`;
@@ -23,22 +68,6 @@ function isRecoverableExistingSession(session) {
         return false;
     return Boolean(session.backendSessionId);
 }
-function sessionStateFromInstanceRef(ref) {
-    const tool = ref.tool;
-    if (!ref.id || !tool)
-        return null;
-    return {
-        id: ref.id,
-        tool,
-        toolConfigKey: tool,
-        command: tool,
-        args: [],
-        lifecycle: "offline",
-        createdAt: ref.createdAt,
-        backendSessionId: ref.backendSessionId,
-        worktreePath: ref.worktreePath,
-    };
-}
 function dedupeSessionStates(sessions) {
     const byKey = new Map();
     for (const session of sessions) {
@@ -50,12 +79,17 @@ function dedupeSessionStates(sessions) {
 }
 export function loadStateStatic() {
     const statePath = getStatePath();
-    if (!existsSync(statePath))
+    if (!existsSync(statePath)) {
         return null;
+    }
     try {
         const raw = readFileSync(statePath, "utf-8");
         const state = JSON.parse(raw);
-        return state;
+        return {
+            savedAt: typeof state.savedAt === "string" ? state.savedAt : new Date().toISOString(),
+            cwd: typeof state.cwd === "string" ? state.cwd : process.cwd(),
+            services: Array.isArray(state.services) ? state.services : undefined,
+        };
     }
     catch {
         return null;
@@ -65,16 +99,20 @@ export const runtimeLifecycleMethods = {
     writeInstructionFiles() {
         const mux = this;
         const config = loadConfig();
+        const configuredInstructionFiles = new Set(Object.values(config.tools)
+            .filter((tool) => tool.enabled && tool.instructionsFile)
+            .map((tool) => tool.instructionsFile));
+        for (const instructionFile of LEGACY_DEFAULT_INSTRUCTION_FILES) {
+            if (!configuredInstructionFiles.has(instructionFile)) {
+                try {
+                    cleanupManagedInstructionFile(join(process.cwd(), instructionFile));
+                }
+                catch { }
+            }
+        }
         const preamble = "# aimux Agent Instructions\n\n" +
-            "You are running inside aimux, an agent multiplexer. " +
-            "Other agents may be working on this codebase simultaneously.\n\n" +
-            "## Context Files\n" +
-            "- `.aimux/context/{session-id}/live.md` — each agent's recent conversation\n" +
-            "- `.aimux/context/{session-id}/summary.md` — each agent's compacted history\n" +
-            "- `.aimux/sessions.json` — all running agents (use to find other agents' session IDs)\n" +
-            "- `.aimux/history/` — full raw conversation history (JSONL)\n\n" +
-            "Check sessions.json to discover other agents, then read their context files.\n" +
-            "This file is auto-generated by aimux and will be removed when aimux exits.\n";
+            buildAimuxAgentInstructions() +
+            "\n\nThis managed block is written by aimux. User-authored content outside the block is preserved.\n";
         let fullPreamble = preamble;
         for (const mdPath of [join(homedir(), "AIMUX.md"), join(process.cwd(), "AIMUX.md")]) {
             if (existsSync(mdPath)) {
@@ -92,20 +130,17 @@ export const runtimeLifecycleMethods = {
             if (!tool.instructionsFile || !tool.enabled)
                 continue;
             const filePath = join(process.cwd(), tool.instructionsFile);
-            if (existsSync(filePath) && !mux.writtenInstructionFiles.has(filePath)) {
-                debug(`skipping ${tool.instructionsFile} — already exists`, "context");
-                continue;
-            }
-            writeFileSync(filePath, fullPreamble);
+            const existing = existsSync(filePath) ? readFileSync(filePath, "utf-8") : "";
+            writeFileSync(filePath, mergeManagedInstructionBlock(existing, fullPreamble));
             mux.writtenInstructionFiles.add(filePath);
-            debug(`wrote ${tool.instructionsFile}`, "context");
+            debug(`merged aimux managed block into ${tool.instructionsFile}`, "context");
         }
     },
     removeInstructionFiles() {
         const mux = this;
         for (const filePath of mux.writtenInstructionFiles) {
             try {
-                unlinkSync(filePath);
+                cleanupManagedInstructionFile(filePath);
             }
             catch { }
         }
@@ -117,11 +152,11 @@ export const runtimeLifecycleMethods = {
     stopStatusRefresh() {
         stopStatusRefreshImpl(this);
     },
-    syncSessionsFromState(state = loadStateStatic()) {
-        syncSessionsFromStateImpl(this, state);
+    syncSessionsFromTopology() {
+        syncSessionsFromTopologyImpl(this);
     },
-    loadOfflineSessions(state = loadStateStatic()) {
-        return loadOfflineSessionsImpl(this, state);
+    loadOfflineTopologySessions() {
+        return loadOfflineTopologySessionsImpl(this);
     },
     loadOfflineServices(state = loadStateStatic()) {
         return loadOfflineServicesImpl(this, state);
@@ -129,8 +164,8 @@ export const runtimeLifecycleMethods = {
     buildLiveServiceStates() {
         return buildLiveServiceStatesImpl(this);
     },
-    restoreTmuxSessionsFromState(state = loadStateStatic()) {
-        restoreTmuxSessionsFromStateImpl(this, state);
+    restoreTmuxSessionsFromTopology() {
+        restoreTmuxSessionsFromTopologyImpl(this);
     },
     stopSessionToOffline(session) {
         stopSessionToOfflineImpl(this, session);
@@ -138,8 +173,8 @@ export const runtimeLifecycleMethods = {
     adjustAfterRemove(hasWorktrees) {
         adjustAfterRemoveImpl(this, hasWorktrees);
     },
-    graveyardSession(sessionId) {
-        graveyardSessionImpl(this, sessionId);
+    graveyardSession(sessionId, sessionSeed) {
+        graveyardSessionImpl(this, sessionId, sessionSeed);
     },
     isSessionRuntimeLive(runtime) {
         return isSessionRuntimeLiveImpl(this, runtime);
@@ -150,12 +185,12 @@ export const runtimeLifecycleMethods = {
     resumeOfflineSession(session) {
         resumeOfflineSessionImpl(this, session);
     },
+    recordSessionBackendSessionId(sessionId, backendSessionId) {
+        return recordSessionBackendSessionIdImpl(this, sessionId, backendSessionId);
+    },
     startHeartbeat() {
         startHeartbeatImpl(this);
     },
-    handleSessionClaimed(sessionId) {
-        handleSessionClaimedImpl(this, sessionId);
-    },
     stopHeartbeat() {
         stopHeartbeatImpl(this);
     },
@@ -165,15 +200,6 @@ export const runtimeLifecycleMethods = {
     stopProjectServiceRefresh() {
         stopProjectServiceRefreshImpl(this);
     },
-    getRemoteInstancesSafe() {
-        return getRemoteInstancesSafeImpl(this);
-    },
-    getRemoteOwnedSessionKeys() {
-        return getRemoteOwnedSessionKeysImpl(this);
-    },
-    getInstanceSessionRefs() {
-        return getInstanceSessionRefsImpl(this);
-    },
     saveState() {
         const mux = this;
         const liveSessions = mux.sessions
@@ -188,6 +214,7 @@ export const runtimeLifecycleMethods = {
             lifecycle: "live",
             createdAt: s.startTime ? new Date(s.startTime).toISOString() : undefined,
             backendSessionId: s.backendSessionId,
+            team: s.team,
             worktreePath: mux.sessionWorktreePaths.get(s.id),
             label: this.getSessionLabel(s.id),
             headline: this.deriveHeadline(s.id),
@@ -195,41 +222,35 @@ export const runtimeLifecycleMethods = {
         }));
         const liveKeys = new Set(liveSessions.map(sessionStateKey));
         const offlineSessions = mux.offlineSessions
-            .map(sanitizeOfflineSessionState)
+            .map((session) => sanitizeOfflineSessionState(session))
             .filter((session) => !liveKeys.has(sessionStateKey(session)));
         const mySessions = dedupeSessionStates([...liveSessions, ...offlineSessions]);
-        const remoteRefs = this.getRemoteInstancesSafe().flatMap((instance) => instance.sessions);
-        const remoteSessions = dedupeSessionStates(remoteRefs.flatMap((ref) => {
-            const session = sessionStateFromInstanceRef(ref);
-            return session ? [session] : [];
-        }));
         const removedServiceIds = mux.removedServiceIds ?? new Set();
         const liveServices = this.buildLiveServiceStates().filter((service) => !removedServiceIds.has(service.id));
         const myServices = [...mux.offlineServices, ...liveServices].filter((service, index, services) => services.findIndex((entry) => entry.id === service.id) === index);
         const statePath = getStatePath();
-        let mergedSessions = dedupeSessionStates([...remoteSessions, ...mySessions]);
+        const myBackendIds = new Set(mySessions.map((s) => s.backendSessionId).filter(Boolean));
+        const myIds = new Set(mySessions.map((s) => s.id));
+        const unpreservedExitedIds = mux.unpreservedExitedSessionIds ?? new Set();
+        const topologySessions = listTopologySessionStates({
+            statuses: ["running", "idle", "offline"],
+        });
+        const otherSessions = topologySessions.flatMap((s) => {
+            if (unpreservedExitedIds.has(s.id))
+                return [];
+            if (s.backendSessionId && myBackendIds.has(s.backendSessionId))
+                return [];
+            if (myIds.has(s.id))
+                return [];
+            if (!isRecoverableExistingSession(s))
+                return [];
+            return [s];
+        });
+        const mergedSessions = dedupeSessionStates([...otherSessions, ...mySessions]);
         let mergedServices = myServices;
         if (existsSync(statePath)) {
             try {
                 const existing = JSON.parse(readFileSync(statePath, "utf-8"));
-                const remoteIds = new Set(remoteRefs.map((s) => s.id));
-                const remoteBackendIds = new Set(remoteRefs.map((s) => s.backendSessionId).filter(Boolean));
-                const myBackendIds = new Set(mySessions.map((s) => s.backendSessionId).filter(Boolean));
-                const myIds = new Set(mySessions.map((s) => s.id));
-                const otherSessions = existing.sessions.flatMap((s) => {
-                    if (remoteIds.has(s.id))
-                        return [s];
-                    if (s.backendSessionId && remoteBackendIds.has(s.backendSessionId))
-                        return [s];
-                    if (s.backendSessionId && myBackendIds.has(s.backendSessionId))
-                        return [];
-                    if (myIds.has(s.id))
-                        return [];
-                    if (!isRecoverableExistingSession(s))
-                        return [];
-                    return [sanitizeOfflineSessionState(s)];
-                });
-                mergedSessions = dedupeSessionStates([...remoteSessions, ...otherSessions, ...mySessions]);
                 const myServiceIds = new Set(myServices.map((service) => service.id));
                 const otherServices = (existing.services ?? []).filter((service) => {
                     if (removedServiceIds.has(service.id))
@@ -242,10 +263,11 @@ export const runtimeLifecycleMethods = {
             }
             catch { }
         }
+        saveRuntimeTopologySessions({ sessions: mergedSessions });
+        unpreservedExitedIds.clear();
         const state = {
             savedAt: new Date().toISOString(),
             cwd: process.cwd(),
-            sessions: mergedSessions,
             services: mergedServices,
         };
         writeFileSync(statePath, JSON.stringify(state, null, 2) + "\n");
@@ -257,13 +279,9 @@ export const runtimeLifecycleMethods = {
         this.clearDashboardBusy();
         this.stopHeartbeat();
         this.stopProjectServiceRefresh();
-        mux.taskDispatcher = null;
-        mux.orchestrationDispatcher = null;
-        mux.instanceDirectory.unregisterInstance(mux.instanceId, process.cwd()).catch(() => { });
         this.saveState();
         this.stopStatusRefresh();
         mux.contextWatcher.stop();
-        this.removeSessionsFile();
         this.removeInstructionFiles();
         closeDebug();
         if (mux.onStdinData) {
@@ -306,4 +324,3 @@ export const runtimeLifecycleMethods = {
         process.exit(0);
     },
 };
-//# sourceMappingURL=runtime-lifecycle-methods.js.map

package/dist/multiplexer/runtime-state.d.ts

@@ -6,27 +6,25 @@ type ManagedAgentWindow = {
 export declare function renderCurrentDashboardView(host: RuntimeStateHost): void;
 export declare function startStatusRefresh(host: RuntimeStateHost): void;
 export declare function stopStatusRefresh(host: RuntimeStateHost): void;
-export declare function syncSessionsFromState(host: RuntimeStateHost, state?: any): void;
-export declare function loadOfflineSessions(host: RuntimeStateHost, state?: any, liveAgentWindows?: ManagedAgentWindow[]): boolean;
+export declare function syncSessionsFromTopology(host: RuntimeStateHost): void;
+export declare function loadOfflineTopologySessions(host: RuntimeStateHost, liveAgentWindows?: ManagedAgentWindow[]): boolean;
 export declare function loadOfflineServices(host: RuntimeStateHost, state?: any): boolean;
 export declare function buildLiveServiceStates(host: RuntimeStateHost): any[];
-export declare function restoreTmuxSessionsFromState(host: RuntimeStateHost, state?: any): ManagedAgentWindow[];
+export declare function restoreTmuxSessionsFromTopology(host: RuntimeStateHost): ManagedAgentWindow[];
 export declare function stopSessionToOffline(host: RuntimeStateHost, session: any): void;
 export declare function adjustAfterRemove(host: RuntimeStateHost, hasWorktrees: boolean): void;
-export declare function graveyardSession(host: RuntimeStateHost, sessionId: string): void;
+export declare function graveyardSession(host: RuntimeStateHost, sessionId: string, _sessionSeed?: any): void;
 export declare function isSessionRuntimeLive(host: RuntimeStateHost, runtime: any): boolean;
 export declare function evictZombieSession(host: RuntimeStateHost, runtime: any): void;
 export declare function resumeOfflineSession(host: RuntimeStateHost, session: any): void;
+export declare function recordSessionBackendSessionId(host: RuntimeStateHost, sessionId: string, backendSessionId: string): {
+    sessionId: string;
+    backendSessionId: string;
+};
 export declare function startHeartbeat(host: RuntimeStateHost): void;
-export declare function handleSessionClaimed(host: RuntimeStateHost, sessionId: string): void;
 export declare function stopHeartbeat(host: RuntimeStateHost): void;
 export declare function startProjectServiceRefresh(host: RuntimeStateHost): void;
 export declare function stopProjectServiceRefresh(host: RuntimeStateHost): void;
-export declare function getRemoteInstancesSafe(host: RuntimeStateHost): any;
-export declare function getRemoteOwnedSessionKeys(host: RuntimeStateHost): Set<string>;
-export declare function getInstanceSessionRefs(host: RuntimeStateHost): any[];
-export declare function writeSessionsFile(host: RuntimeStateHost): void;
-export declare function removeSessionsFile(): void;
 export declare function listDesktopWorktrees(_host: RuntimeStateHost): Array<{
     name: string;
     path: string;