aimux-cli 0.1.16 → 0.1.19

package/dist/notifications.js

@@ -1,48 +1,8 @@
 import { randomUUID } from "node:crypto";
-import { existsSync, readFileSync } from "node:fs";
-import { writeJsonAtomic } from "./atomic-write.js";
-import { getNotificationsPath } from "./paths.js";
-function loadState() {
-    const path = getNotificationsPath();
-    if (!existsSync(path))
-        return { version: 1, notifications: [] };
-    try {
-        const raw = readFileSync(path, "utf8");
-        const parsed = JSON.parse(raw);
-        if (parsed.version !== 1 || !Array.isArray(parsed.notifications)) {
-            return { version: 1, notifications: [] };
-        }
-        return parsed;
-    }
-    catch {
-        return { version: 1, notifications: [] };
-    }
-}
-function saveState(state) {
-    writeJsonAtomic(getNotificationsPath(), state);
-}
-export function addNotification(input) {
-    const now = input.createdAt ?? new Date().toISOString();
-    const state = loadState();
-    const record = {
-        id: randomUUID(),
-        title: input.title.trim() || "aimux",
-        subtitle: input.subtitle?.trim() || undefined,
-        body: input.body.trim() || input.title.trim() || "aimux",
-        sessionId: input.sessionId?.trim() || undefined,
-        targetKey: normalizeTargetKey(input),
-        targetKind: normalizeTargetKind(input),
-        kind: input.kind?.trim() || undefined,
-        unread: input.unread ?? true,
-        cleared: false,
-        createdAt: now,
-        updatedAt: now,
-        dedupeKey: input.dedupeKey?.trim() || undefined,
-    };
-    state.notifications.unshift(record);
-    saveState(state);
-    return record;
-}
+import { deriveRuntimeExchangeIndexes } from "./runtime-core/exchange-derived.js";
+import { createRuntimeExchangeStore, } from "./runtime-core/exchange-store.js";
+const PROJECT_NOTIFICATION_PARTICIPANT = "project";
+const NOTIFICATION_TAG = "notification";
 function normalizeTargetKey(input) {
     const targetKey = input.targetKey?.trim();
     if (targetKey)
@@ -53,39 +13,127 @@ function normalizeTargetKey(input) {
 function normalizeTargetKind(input) {
     if (input.targetKind)
         return input.targetKind;
-    return input.sessionId?.trim() ? "session" : undefined;
+    return input.sessionId?.trim() ? "session" : "generic";
 }
-function recordTargetKey(record) {
-    return record.targetKey ?? (record.sessionId ? `session:${record.sessionId}` : undefined);
+function metadataString(message, key) {
+    const value = message?.metadata?.[key];
+    return typeof value === "string" && value.trim() ? value : undefined;
 }
-export function upsertNotification(input) {
-    const targetKey = normalizeTargetKey(input);
+function metadataBoolean(message, key) {
+    return message?.metadata?.[key] === true;
+}
+function notificationThreadId(targetKey) {
     if (!targetKey)
-        return addNotification(input);
+        return `notification-${randomUUID()}`;
+    return `notification-${Buffer.from(targetKey).toString("base64url")}`;
+}
+function threadLatestMessage(exchange, threadId) {
+    return exchange.messages
+        .filter((message) => message.threadId === threadId)
+        .sort((a, b) => b.ts.localeCompare(a.ts))[0];
+}
+function entryForThread(exchange, thread) {
+    return exchange.inbox.find((entry) => entry.subjectKind === "thread" && entry.subjectId === thread.id);
+}
+function notificationRecord(exchange, thread, message) {
+    const entry = entryForThread(exchange, thread);
+    const sessionId = metadataString(message, "notificationSessionId");
+    const targetKey = metadataString(message, "notificationTargetKey");
+    const targetKind = metadataString(message, "notificationTargetKind");
+    return {
+        id: metadataString(message, "notificationRecordId") ?? thread.id,
+        title: thread.title,
+        subtitle: metadataString(message, "notificationSubtitle"),
+        body: message.body,
+        sessionId,
+        targetKey,
+        targetKind,
+        kind: metadataString(message, "notificationKind"),
+        unread: Boolean(entry && entry.state !== "done"),
+        cleared: metadataBoolean(message, "notificationCleared"),
+        createdAt: thread.createdAt,
+        updatedAt: thread.updatedAt,
+        dedupeKey: metadataString(message, "notificationDedupeKey"),
+    };
+}
+function notificationRecords(exchange = createRuntimeExchangeStore().read()) {
+    return exchange.threads
+        .filter((thread) => thread.tags?.includes(NOTIFICATION_TAG))
+        .map((thread) => {
+        const message = threadLatestMessage(exchange, thread.id);
+        return message ? notificationRecord(exchange, thread, message) : undefined;
+    })
+        .filter((record) => Boolean(record))
+        .sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+}
+function writeNotification(input) {
     const now = input.createdAt ?? new Date().toISOString();
-    const state = loadState();
-    const record = {
-        id: randomUUID(),
+    const sessionId = input.sessionId?.trim() || undefined;
+    const targetKey = normalizeTargetKey(input);
+    const targetKind = normalizeTargetKind(input);
+    const threadId = input.replaceTarget ? notificationThreadId(targetKey) : notificationThreadId();
+    const participantId = sessionId ?? PROJECT_NOTIFICATION_PARTICIPANT;
+    const thread = {
+        id: threadId,
         title: input.title.trim() || "aimux",
-        subtitle: input.subtitle?.trim() || undefined,
-        body: input.body.trim() || input.title.trim() || "aimux",
-        sessionId: input.sessionId?.trim() || undefined,
-        targetKey,
-        targetKind: normalizeTargetKind(input),
-        kind: input.kind?.trim() || undefined,
-        unread: input.unread ?? true,
-        cleared: false,
+        kind: "conversation",
+        status: "open",
         createdAt: now,
         updatedAt: now,
-        dedupeKey: input.dedupeKey?.trim() || undefined,
+        createdBy: "aimux",
+        participants: ["aimux", participantId],
+        lastMessageId: `message-${threadId}`,
+        unreadBy: input.unread === false ? [] : [participantId],
+        tags: [NOTIFICATION_TAG],
     };
-    state.notifications = [record, ...state.notifications.filter((existing) => recordTargetKey(existing) !== targetKey)];
-    saveState(state);
+    const message = {
+        id: `message-${threadId}`,
+        threadId,
+        ts: now,
+        from: "aimux",
+        to: [participantId],
+        kind: "note",
+        body: input.body.trim() || input.title.trim() || "aimux",
+        metadata: {
+            notificationRecordId: randomUUID(),
+            notificationSubtitle: input.subtitle?.trim() || null,
+            notificationSessionId: sessionId ?? null,
+            notificationTargetKey: targetKey ?? null,
+            notificationTargetKind: targetKind ?? null,
+            notificationKind: input.kind?.trim() || null,
+            notificationDedupeKey: input.dedupeKey?.trim() || null,
+            notificationCleared: false,
+        },
+    };
+    let record;
+    createRuntimeExchangeStore().update((exchange) => {
+        const next = deriveRuntimeExchangeIndexes({
+            ...exchange,
+            generatedAt: now,
+            threads: [...exchange.threads.filter((existing) => existing.id !== threadId), thread],
+            messages: [...exchange.messages.filter((existing) => existing.threadId !== threadId), message],
+        });
+        const inbox = input.unread === false
+            ? next.inbox.map((entry) => entry.subjectKind === "thread" && entry.subjectId === threadId
+                ? { ...entry, state: "done" }
+                : entry)
+            : next.inbox;
+        const updated = { ...next, inbox };
+        record = notificationRecord(updated, thread, message);
+        return updated;
+    });
+    if (!record)
+        throw new Error("failed to write notification");
     return record;
 }
+export function addNotification(input) {
+    return writeNotification(input);
+}
+export function upsertNotification(input) {
+    return writeNotification({ ...input, replaceTarget: Boolean(normalizeTargetKey(input)) });
+}
 export function listNotifications(opts) {
-    const state = loadState();
-    return state.notifications.filter((record) => {
+    return notificationRecords().filter((record) => {
         if (!opts?.includeCleared && record.cleared)
             return false;
         if (opts?.unreadOnly && !record.unread)
@@ -96,49 +144,63 @@ export function listNotifications(opts) {
     });
 }
 export function markNotificationsRead(opts) {
-    const state = loadState();
-    let changed = 0;
-    const now = new Date().toISOString();
-    state.notifications = state.notifications.map((record) => {
+    const store = createRuntimeExchangeStore();
+    const records = notificationRecords(store.read()).filter((record) => {
         if (record.cleared || !record.unread)
-            return record;
-        const matchesId = opts?.id ? record.id === opts.id : true;
-        const matchesSession = opts?.sessionId ? record.sessionId === opts.sessionId : true;
-        if (!matchesId || !matchesSession)
-            return record;
-        changed += 1;
-        return {
-            ...record,
-            unread: false,
-            updatedAt: now,
-        };
+            return false;
+        if (opts?.id && record.id !== opts.id)
+            return false;
+        if (opts?.sessionId && record.sessionId !== opts.sessionId)
+            return false;
+        return true;
     });
-    if (changed > 0)
-        saveState(state);
-    return changed;
+    if (records.length === 0)
+        return 0;
+    const threadIds = new Set(records
+        .map((record) => {
+        const exchange = store.read();
+        return exchange.threads.find((thread) => {
+            const message = threadLatestMessage(exchange, thread.id);
+            return message && notificationRecord(exchange, thread, message).id === record.id;
+        })?.id;
+    })
+        .filter((id) => Boolean(id)));
+    store.update((exchange) => ({
+        ...exchange,
+        inbox: exchange.inbox.map((entry) => entry.subjectKind === "thread" && threadIds.has(entry.subjectId) ? { ...entry, state: "done" } : entry),
+    }));
+    return records.length;
 }
 export function clearNotifications(opts) {
-    const state = loadState();
-    let changed = 0;
-    const now = new Date().toISOString();
-    state.notifications = state.notifications.map((record) => {
+    const store = createRuntimeExchangeStore();
+    const records = notificationRecords(store.read()).filter((record) => {
         if (record.cleared)
-            return record;
-        const matchesId = opts?.id ? record.id === opts.id : true;
-        const matchesSession = opts?.sessionId ? record.sessionId === opts.sessionId : true;
-        if (!matchesId || !matchesSession)
-            return record;
-        changed += 1;
+            return false;
+        if (opts?.id && record.id !== opts.id)
+            return false;
+        if (opts?.sessionId && record.sessionId !== opts.sessionId)
+            return false;
+        return true;
+    });
+    if (records.length === 0)
+        return 0;
+    const recordIds = new Set(records.map((record) => record.id));
+    store.update((exchange) => {
+        const threadIds = new Set(exchange.threads
+            .map((thread) => {
+            const message = threadLatestMessage(exchange, thread.id);
+            return message && recordIds.has(notificationRecord(exchange, thread, message).id) ? thread.id : undefined;
+        })
+            .filter((id) => Boolean(id)));
         return {
-            ...record,
-            unread: false,
-            cleared: true,
-            updatedAt: now,
+            ...exchange,
+            messages: exchange.messages.map((message) => message.threadId && threadIds.has(message.threadId)
+                ? { ...message, metadata: { ...(message.metadata ?? {}), notificationCleared: true } }
+                : message),
+            inbox: exchange.inbox.map((entry) => entry.subjectKind === "thread" && threadIds.has(entry.subjectId) ? { ...entry, state: "done" } : entry),
         };
     });
-    if (changed > 0)
-        saveState(state);
-    return changed;
+    return records.length;
 }
 export function unreadNotificationCount(opts) {
     return listNotifications({ unreadOnly: true, sessionId: opts?.sessionId }).length;
@@ -163,4 +225,3 @@ export function summarizeUnreadNotificationsBySession() {
     }
     return summaries;
 }
-//# sourceMappingURL=notifications.js.map

package/dist/notify.d.ts

@@ -8,3 +8,7 @@ export declare function notifyError(sessionId: string, message?: string): void;
 /** Notify that an agent completed (exited cleanly) */
 export declare function notifyComplete(sessionId: string): void;
 export declare function notifyAlert(event: AlertEvent): void;
+export declare function notifyRemoteClientConnected(input: {
+    title?: unknown;
+    body?: unknown;
+}): void;

package/dist/notify.js

@@ -38,6 +38,15 @@ function send(title, message) {
     }
     debug(`notification: ${message}`, "notify");
 }
+function sendSecurity(title, message) {
+    if (process.platform === "darwin") {
+        sendMacNotification(title, message);
+    }
+    else {
+        notifier.notify({ title, message, sound: true });
+    }
+    debug(`security notification: ${message}`, "notify");
+}
 /** Notify that an agent is waiting for input */
 export function notifyPrompt(sessionId) {
     if (!getNotifyConfig().onPrompt)
@@ -77,4 +86,8 @@ export function notifyAlert(event) {
         return;
     send(event.title || "aimux", event.message || event.sessionId || event.kind);
 }
-//# sourceMappingURL=notify.js.map
+export function notifyRemoteClientConnected(input) {
+    const title = typeof input.title === "string" && input.title.trim().length > 0 ? input.title : "aimux remote access";
+    const body = typeof input.body === "string" && input.body.trim().length > 0 ? input.body : "Remote client connected";
+    sendSecurity(title, body);
+}

package/dist/orchestration-actions.js

@@ -307,4 +307,3 @@ export async function reopenTask(input) {
     await writeTask(reopened);
     return { task: reopened };
 }
-//# sourceMappingURL=orchestration-actions.js.map

package/dist/orchestration-routing.js

@@ -71,4 +71,3 @@ export function resolveOrchestrationRecipients(input) {
         .sort((a, b) => scoreCandidate(b, input) - scoreCandidate(a, input) || a.id.localeCompare(b.id))
         .map((candidate) => candidate.id);
 }
-//# sourceMappingURL=orchestration-routing.js.map

package/dist/orchestration.js

@@ -107,4 +107,3 @@ export function sendDirectMessage(input) {
         threadCreated: !existing,
     };
 }
-//# sourceMappingURL=orchestration.js.map

package/dist/osc-notifications.js

@@ -177,4 +177,3 @@ export class OscNotificationParser {
         return { cleaned, notifications };
     }
 }
-//# sourceMappingURL=osc-notifications.js.map

package/dist/paths.d.ts

@@ -3,9 +3,10 @@
  *
  * Two locations:
  *   - In-repo:  {repoRoot}/.aimux/  → agent-facing shared artifacts
- *                (config, team, plans, context, history, tasks, status, threads, sessions.json)
+ *                (config, team, plans, context, history, tasks, status, threads)
  *   - Global:   ~/.aimux/projects/<project-id>/  → runtime-private state
  *                (recordings, metadata, instance ownership, statusline internals, offline state)
+ *                Override with AIMUX_HOME for isolated dev/runtime lanes.
  *
  * Must call `await initPaths(cwd)` once at startup before using sync path functions.
  */
@@ -21,23 +22,49 @@ export declare function getProjectId(): string;
 export declare function getProjectIdFor(cwd: string): string;
 export declare function getProjectStateDirFor(cwd: string): string;
 export declare function getProjectStateDirById(projectId: string): string;
+export interface ReadOnlyProjectPaths {
+    repoRoot: string;
+    projectId: string;
+    projectStateDir: string;
+    localAimuxDir: string;
+    statePath: string;
+    runtimeTopologyPath: string;
+    runtimeExchangePath: string;
+    metadataPath: string;
+    notificationContextPath: string;
+    dashboardOperationFailuresPath: string;
+}
+/**
+ * Resolve aimux project paths without initializing or registering the project.
+ * Use this for diagnostics that must not create directories, migrate files, or
+ * update project registry state as a side effect.
+ */
+export declare function getReadOnlyProjectPathsFor(cwd: string): ReadOnlyProjectPaths;
 export declare function getGlobalAimuxDir(): string;
 export declare function getDaemonDir(): string;
+export declare function getAuthPath(): string;
 export declare function getDaemonInfoPath(): string;
 export declare function getDaemonStatePath(): string;
+export declare function getDaemonLogsDir(): string;
+export declare function getDaemonLogPath(): string;
+export declare function getDaemonStdioLogPath(): string;
 export declare function getProjectStateDir(): string;
+export declare function getProjectLogsDir(): string;
+export declare function getProjectLogPath(): string;
+export declare function getProjectServiceStdioLogPath(): string;
+export declare function getProjectLogsDirFor(cwd: string): string;
+export declare function getProjectLogPathFor(cwd: string): string;
+export declare function getProjectServiceStdioLogPathFor(cwd: string): string;
 export declare function getStatePath(): string;
-export declare function getGraveyardPath(): string;
-export declare function getWorktreeGraveyardPath(): string;
 export declare function getContextDir(): string;
 export declare function getContextPathForDate(date: Date): string;
 export declare function getHistoryDir(): string;
 export declare function getRecordingsDir(): string;
 export declare function getTasksDir(): string;
 export declare function getStatusDir(): string;
-export declare function getInstancesPath(): string;
 export declare function getMetadataPath(): string;
-export declare function getNotificationsPath(): string;
+export declare function getRuntimeTopologyPath(): string;
+export declare function getRuntimeExchangePath(): string;
 export declare function getNotificationContextPath(): string;
 export declare function getMetadataEndpointPath(): string;
 export declare function getDashboardUiStatePath(): string;
@@ -49,8 +76,6 @@ export declare function getProjectTeamPath(): string;
 export declare function getPlansDir(): string;
 export declare function getThreadsDir(): string;
 export declare function getAttachmentsDir(): string;
-export declare function getSessionMessagesDir(): string;
-export declare function getSessionInputOperationsDir(): string;
 /** Escape hatch for cross-worktree operations. Prefer the no-arg variants above. */
 export declare function getAimuxDirFor(cwd: string): string;
 export declare function getGlobalConfigPath(): string;

package/dist/paths.js

@@ -3,15 +3,16 @@
  *
  * Two locations:
  *   - In-repo:  {repoRoot}/.aimux/  → agent-facing shared artifacts
- *                (config, team, plans, context, history, tasks, status, threads, sessions.json)
+ *                (config, team, plans, context, history, tasks, status, threads)
  *   - Global:   ~/.aimux/projects/<project-id>/  → runtime-private state
  *                (recordings, metadata, instance ownership, statusline internals, offline state)
+ *                Override with AIMUX_HOME for isolated dev/runtime lanes.
  *
  * Must call `await initPaths(cwd)` once at startup before using sync path functions.
  */
 import { createHash } from "node:crypto";
 import { execSync } from "node:child_process";
-import { existsSync, readFileSync, writeFileSync, mkdirSync, cpSync, readdirSync } from "node:fs";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
 import { join, basename, resolve, dirname, sep } from "node:path";
 import { homedir } from "node:os";
 // ── Cached state (populated by initPaths) ──────────────────────────
@@ -31,8 +32,17 @@ function resolveRepoRoot(cwd) {
         return resolvedCwd.slice(0, markerIndex);
     }
     try {
+        // Strip inherited GIT_* env so the command honors `cwd` even when invoked
+        // from a context (e.g. git hook) where the parent set GIT_DIR/GIT_WORK_TREE.
+        const env = { ...process.env };
+        delete env.GIT_DIR;
+        delete env.GIT_WORK_TREE;
+        delete env.GIT_INDEX_FILE;
+        delete env.GIT_OBJECT_DIRECTORY;
+        delete env.GIT_COMMON_DIR;
         const gitCommonDir = execSync("git rev-parse --git-common-dir", {
             cwd,
+            env,
             encoding: "utf-8",
             stdio: ["pipe", "pipe", "pipe"],
         }).trim();
@@ -66,7 +76,6 @@ export async function initPaths(cwd) {
     }
     writeFileSync(join(projectDir, "project-root.txt"), `${_repoRoot}\n`);
     ensureLocalSharedDirs();
-    migrateAgentFacingStateToLocal();
     registerProject();
 }
 export function getRepoRoot() {
@@ -86,32 +95,88 @@ export function getProjectStateDirFor(cwd) {
 export function getProjectStateDirById(projectId) {
     return join(getGlobalAimuxDir(), "projects", projectId);
 }
+/**
+ * Resolve aimux project paths without initializing or registering the project.
+ * Use this for diagnostics that must not create directories, migrate files, or
+ * update project registry state as a side effect.
+ */
+export function getReadOnlyProjectPathsFor(cwd) {
+    const repoRoot = resolveRepoRoot(cwd);
+    const projectId = computeProjectId(repoRoot);
+    const projectStateDir = join(getGlobalAimuxDir(), "projects", projectId);
+    const localAimuxDir = join(repoRoot, ".aimux");
+    return {
+        repoRoot,
+        projectId,
+        projectStateDir,
+        localAimuxDir,
+        statePath: join(projectStateDir, "state.json"),
+        runtimeTopologyPath: join(projectStateDir, "runtime-topology.yaml"),
+        runtimeExchangePath: join(projectStateDir, "runtime-exchange.yaml"),
+        metadataPath: join(projectStateDir, "metadata.json"),
+        notificationContextPath: join(projectStateDir, "notification-context.json"),
+        dashboardOperationFailuresPath: join(projectStateDir, "dashboard-operation-failures.json"),
+    };
+}
 // ── Global paths (~/.aimux/...) ────────────────────────────────────
-const HOME = homedir();
+function resolveAimuxHome() {
+    const override = process.env.AIMUX_HOME?.trim();
+    if (!override)
+        return join(homedir(), ".aimux");
+    if (override === "~")
+        return homedir();
+    if (override.startsWith("~/"))
+        return resolve(homedir(), override.slice(2));
+    return resolve(override);
+}
 export function getGlobalAimuxDir() {
-    return join(HOME, ".aimux");
+    return resolveAimuxHome();
 }
 export function getDaemonDir() {
     return join(getGlobalAimuxDir(), "daemon");
 }
+export function getAuthPath() {
+    return join(getGlobalAimuxDir(), "auth.json");
+}
 export function getDaemonInfoPath() {
     return join(getDaemonDir(), "daemon.json");
 }
 export function getDaemonStatePath() {
     return join(getDaemonDir(), "state.json");
 }
+export function getDaemonLogsDir() {
+    return join(getDaemonDir(), "logs");
+}
+export function getDaemonLogPath() {
+    return join(getDaemonLogsDir(), "daemon.jsonl");
+}
+export function getDaemonStdioLogPath() {
+    return join(getDaemonLogsDir(), "daemon-stdio.log");
+}
 export function getProjectStateDir() {
     assertInitialized();
     return join(getGlobalAimuxDir(), "projects", _projectId);
 }
-export function getStatePath() {
-    return join(getProjectStateDir(), "state.json");
+export function getProjectLogsDir() {
+    return join(getProjectStateDir(), "logs");
+}
+export function getProjectLogPath() {
+    return join(getProjectLogsDir(), "aimux.jsonl");
+}
+export function getProjectServiceStdioLogPath() {
+    return join(getProjectLogsDir(), "project-service-stdio.log");
+}
+export function getProjectLogsDirFor(cwd) {
+    return join(getProjectStateDirFor(cwd), "logs");
 }
-export function getGraveyardPath() {
-    return join(getProjectStateDir(), "graveyard.json");
+export function getProjectLogPathFor(cwd) {
+    return join(getProjectLogsDirFor(cwd), "aimux.jsonl");
 }
-export function getWorktreeGraveyardPath() {
-    return join(getProjectStateDir(), "worktree-graveyard.json");
+export function getProjectServiceStdioLogPathFor(cwd) {
+    return join(getProjectLogsDirFor(cwd), "project-service-stdio.log");
+}
+export function getStatePath() {
+    return join(getProjectStateDir(), "state.json");
 }
 export function getContextDir() {
     return join(getLocalAimuxDir(), "context");
@@ -134,14 +199,14 @@ export function getTasksDir() {
 export function getStatusDir() {
     return join(getLocalAimuxDir(), "status");
 }
-export function getInstancesPath() {
-    return join(getProjectStateDir(), "instances.json");
-}
 export function getMetadataPath() {
     return join(getProjectStateDir(), "metadata.json");
 }
-export function getNotificationsPath() {
-    return join(getProjectStateDir(), "notifications.json");
+export function getRuntimeTopologyPath() {
+    return join(getProjectStateDir(), "runtime-topology.yaml");
+}
+export function getRuntimeExchangePath() {
+    return join(getProjectStateDir(), "runtime-exchange.yaml");
 }
 export function getNotificationContextPath() {
     return join(getProjectStateDir(), "notification-context.json");
@@ -178,12 +243,6 @@ export function getThreadsDir() {
 export function getAttachmentsDir() {
     return join(getLocalAimuxDir(), "attachments");
 }
-export function getSessionMessagesDir() {
-    return join(getLocalAimuxDir(), "session-messages");
-}
-export function getSessionInputOperationsDir() {
-    return join(getLocalAimuxDir(), "session-input-ops");
-}
 /** Escape hatch for cross-worktree operations. Prefer the no-arg variants above. */
 export function getAimuxDirFor(cwd) {
     return join(resolveRepoRoot(cwd), ".aimux");
@@ -191,45 +250,10 @@ export function getAimuxDirFor(cwd) {
 function ensureLocalSharedDirs() {
     const localDir = getLocalAimuxDir();
     mkdirSync(localDir, { recursive: true });
-    for (const subdir of [
-        "plans",
-        "context",
-        "history",
-        "tasks",
-        "status",
-        "threads",
-        "attachments",
-        "session-messages",
-        "session-input-ops",
-    ]) {
+    for (const subdir of ["plans", "context", "history", "status", "attachments"]) {
         mkdirSync(join(localDir, subdir), { recursive: true });
     }
 }
-function migrateDirIfNeeded(globalSubdir, localDir) {
-    const source = join(getProjectStateDir(), globalSubdir);
-    if (!existsSync(source) || !existsSync(localDir))
-        return;
-    const hasLocalEntries = (() => {
-        try {
-            return readdirSync(localDir).length > 0;
-        }
-        catch {
-            return false;
-        }
-    })();
-    if (hasLocalEntries)
-        return;
-    try {
-        cpSync(source, localDir, { recursive: true, force: false });
-    }
-    catch { }
-}
-function migrateAgentFacingStateToLocal() {
-    migrateDirIfNeeded("context", getContextDir());
-    migrateDirIfNeeded("history", getHistoryDir());
-    migrateDirIfNeeded("tasks", getTasksDir());
-    migrateDirIfNeeded("status", getStatusDir());
-}
 // ── Global non-project paths ───────────────────────────────────────
 export function getGlobalConfigPath() {
     return join(getGlobalAimuxDir(), "config.json");
@@ -283,4 +307,3 @@ export function removeProject(id) {
     registry.projects = registry.projects.filter((p) => p.id !== id);
     saveRegistry(registry);
 }
-//# sourceMappingURL=paths.js.map

package/dist/pending-actions.d.ts

@@ -0,0 +1,5 @@
+export type PendingDashboardActionKind = PendingSessionActionKind | PendingServiceActionKind | PendingWorktreeActionKind;
+export type PendingSessionActionKind = "creating" | "forking" | "migrating" | "starting" | "stopping" | "graveyarding" | "renaming";
+export type PendingServiceActionKind = "creating" | "starting" | "stopping" | "removing";
+export type PendingWorktreeActionKind = "creating" | "removing" | "graveyarding";
+export declare function isBlockingPendingDashboardActionKind(kind: string | null | undefined): kind is PendingDashboardActionKind;