@creativeintelligence/abbie 0.1.0

package/dist/lib/web/tmux-bridge.d.ts

@@ -0,0 +1,7 @@
+/**
+ * tmux bridge for agents web.
+ *
+ * This file re-exports from the core tmux bridge module for backwards compatibility.
+ * New code should import from '../tmux/bridge.js' or '../tmux/index.js' directly.
+ */
+export * from "../tmux/bridge.js";

package/dist/lib/web/tmux-bridge.js

@@ -0,0 +1,7 @@
+/**
+ * tmux bridge for agents web.
+ *
+ * This file re-exports from the core tmux bridge module for backwards compatibility.
+ * New code should import from '../tmux/bridge.js' or '../tmux/index.js' directly.
+ */
+export * from "../tmux/bridge.js";

package/dist/lib/windows/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./inventory.js";
+export * from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/windows/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lib/windows/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,YAAY,CAAC"}

package/dist/lib/windows/index.js

@@ -0,0 +1,2 @@
+export * from "./inventory.js";
+export * from "./types.js";

package/dist/lib/windows/inventory.d.ts

@@ -0,0 +1,21 @@
+import type { WindowState } from "./types.js";
+export interface InventoryOptions {
+    session?: string;
+    includeNvim?: boolean;
+    includeAgent?: boolean;
+    includeBuffers?: boolean;
+}
+/**
+ * Get complete inventory of all workspace windows.
+ * Correlates tmux panes → nvim instances → agent processes.
+ */
+export declare function inventory(options?: InventoryOptions): Promise<WindowState[]>;
+/**
+ * Get a single window's state by pane ID or session:window.pane reference.
+ */
+export declare function getWindowState(ref: string, options?: Omit<InventoryOptions, "session">): Promise<WindowState | null>;
+/**
+ * Get the currently focused window's state.
+ */
+export declare function getFocusedWindow(options?: Omit<InventoryOptions, "session">): Promise<WindowState | null>;
+//# sourceMappingURL=inventory.d.ts.map

package/dist/lib/windows/inventory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inventory.d.ts","sourceRoot":"","sources":["../../../src/lib/windows/inventory.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAqC,WAAW,EAAE,MAAM,YAAY,CAAC;AAEjF,MAAM,WAAW,gBAAgB;IAC/B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AA+OD;;;GAGG;AACH,wBAAsB,SAAS,CAAC,OAAO,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC,CA2ClF;AAED;;GAEG;AACH,wBAAsB,cAAc,CAClC,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE,IAAI,CAAC,gBAAgB,EAAE,SAAS,CAAC,GAC1C,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,CAoB7B;AAED;;GAEG;AACH,wBAAsB,gBAAgB,CACpC,OAAO,CAAC,EAAE,IAAI,CAAC,gBAAgB,EAAE,SAAS,CAAC,GAC1C,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,CAoB7B"}

package/dist/lib/windows/inventory.js

@@ -0,0 +1,263 @@
+import * as nvim from "../nvim/index.js";
+import * as process from "../process/snapshot.js";
+import * as tmux from "../tmux/bridge.js";
+function normalizeTty(tty) {
+    if (!tty)
+        return null;
+    const trimmed = tty.trim();
+    if (!trimmed)
+        return null;
+    if (trimmed.startsWith("/dev/"))
+        return trimmed.slice("/dev/".length);
+    return trimmed;
+}
+function guessPanePidFromTty(paneTty, snapshot) {
+    const normalizedPaneTty = normalizeTty(paneTty);
+    if (!normalizedPaneTty)
+        return null;
+    const matching = [];
+    for (const [, info] of snapshot) {
+        if (normalizeTty(info.tty) === normalizedPaneTty) {
+            matching.push(info);
+        }
+    }
+    if (matching.length === 0)
+        return null;
+    const pidSet = new Set(matching.map((p) => p.pid));
+    const roots = matching.filter((p) => !pidSet.has(p.ppid));
+    const candidates = roots.length > 0 ? roots : matching;
+    const shells = new Set(["zsh", "bash", "fish", "sh", "nu", "pwsh", "tcsh", "csh", "ksh", "dash"]);
+    candidates.sort((a, b) => {
+        const aShell = shells.has(a.cmd.toLowerCase()) ? 0 : 1;
+        const bShell = shells.has(b.cmd.toLowerCase()) ? 0 : 1;
+        if (aShell !== bShell)
+            return aShell - bShell;
+        return a.pid - b.pid;
+    });
+    return candidates[0]?.pid ?? null;
+}
+function extractSessionId(args) {
+    const match = args.match(/(?:^|\s)--session-id(?:=|\s+)([^\s]+)/);
+    return match?.[1];
+}
+function extractIssue(args) {
+    const match = args.match(/\b[A-Z][A-Z0-9]{1,9}-\d+\b/);
+    return match?.[0];
+}
+function depthFromRoot(rootPid, pid, snapshot, maxDepth = 50) {
+    if (pid === rootPid)
+        return 0;
+    let depth = 0;
+    let current = pid;
+    const visited = new Set();
+    while (depth < maxDepth) {
+        if (current === rootPid)
+            return depth;
+        if (visited.has(current))
+            break;
+        visited.add(current);
+        const info = snapshot.get(current);
+        if (!info)
+            break;
+        current = info.ppid;
+        depth++;
+    }
+    return depth;
+}
+function toBufferInfo(buf) {
+    const record = typeof buf === "object" && buf !== null ? buf : {};
+    const name = typeof record.name === "string" ? record.name : "";
+    const filetype = typeof record.filetype === "string" ? record.filetype : "";
+    const lineCount = typeof record.lineCount === "number"
+        ? record.lineCount
+        : typeof record.linecount === "number"
+            ? record.linecount
+            : 0;
+    const cursor = typeof record.cursor === "object" &&
+        record.cursor !== null &&
+        typeof record.cursor.line === "number" &&
+        typeof record.cursor.col === "number"
+        ? {
+            line: record.cursor.line,
+            col: record.cursor.col,
+        }
+        : undefined;
+    return {
+        name,
+        path: name,
+        modified: Boolean(record.modified),
+        filetype,
+        lineCount,
+        cursor,
+    };
+}
+function detectAgentForPane(panePid, snapshot, tree) {
+    if (panePid <= 0)
+        return null;
+    const candidatePids = process.findDescendants(panePid, tree, snapshot, (p) => {
+        return process.detectAgentType(p) !== null;
+    });
+    // Include root pid if pane is running the agent directly.
+    const paneInfo = snapshot.get(panePid);
+    if (paneInfo && process.detectAgentType(paneInfo)) {
+        candidatePids.push(panePid);
+    }
+    if (candidatePids.length === 0)
+        return null;
+    let best = null;
+    for (const pid of candidatePids) {
+        const info = snapshot.get(pid);
+        if (!info)
+            continue;
+        const type = process.detectAgentType(info);
+        if (!type)
+            continue;
+        const depth = depthFromRoot(panePid, pid, snapshot);
+        if (!best || depth > best.depth || (depth === best.depth && pid < best.pid)) {
+            best = { pid, depth, type, info };
+        }
+    }
+    if (!best)
+        return null;
+    return {
+        type: best.type,
+        pid: best.pid,
+        sessionId: extractSessionId(best.info.args),
+        issue: extractIssue(best.info.args),
+    };
+}
+async function buildWindowState(params) {
+    const { sessionName, windowIndex, windowName, pane, snapshot, tree, options } = params;
+    const paneId = (await tmux.getPaneId(windowIndex, pane.index, sessionName)) ?? "";
+    const paneTty = (await tmux.getPaneTty(windowIndex, pane.index, sessionName)) ?? "";
+    const panePid = guessPanePidFromTty(paneTty, snapshot) ?? -1;
+    const window = {
+        session: sessionName,
+        window: windowIndex,
+        windowName,
+        pane: pane.index,
+        paneId,
+        panePid,
+        paneTty,
+        title: pane.currentCommand,
+        cwd: pane.currentPath,
+        active: pane.active,
+        size: { cols: pane.width, rows: pane.height },
+    };
+    const agent = options.includeAgent ? detectAgentForPane(panePid, snapshot, tree) : null;
+    if (!options.includeNvim) {
+        return { window, nvim: null, agent, buffers: [] };
+    }
+    const nvimState = {
+        available: false,
+        pid: null,
+        serverAddr: null,
+        discoveryMethod: null,
+        currentBuffer: null,
+    };
+    let buffers = [];
+    if (panePid > 0) {
+        let nvimPid = nvim.findNvimPidForWindow(panePid, snapshot, tree);
+        // If the pane is running nvim directly (no shell), treat it as the nvim pid.
+        if (!nvimPid) {
+            const rootInfo = snapshot.get(panePid);
+            if (rootInfo && process.isNvimProcess(rootInfo)) {
+                nvimPid = panePid;
+            }
+        }
+        if (nvimPid) {
+            nvimState.available = true;
+            nvimState.pid = nvimPid;
+            const discovery = await nvim.discoverNvimServerAddress(nvimPid, snapshot);
+            nvimState.serverAddr = discovery?.addr ?? null;
+            nvimState.discoveryMethod = discovery?.method ?? null;
+            if (options.includeBuffers && nvimState.serverAddr) {
+                const [listed, current] = await Promise.all([
+                    nvim.listBuffers(nvimState.serverAddr),
+                    nvim.getCurrentBufferInfo(nvimState.serverAddr),
+                ]);
+                buffers = (listed ?? []).map(toBufferInfo);
+                nvimState.currentBuffer = current ? toBufferInfo(current) : null;
+            }
+        }
+    }
+    return { window, nvim: nvimState, agent, buffers };
+}
+/**
+ * Get complete inventory of all workspace windows.
+ * Correlates tmux panes → nvim instances → agent processes.
+ */
+export async function inventory(options) {
+    const { session, includeNvim = true, includeAgent = true, includeBuffers = false, } = options || {};
+    const tmuxRunning = await tmux.isRunning();
+    if (!tmuxRunning)
+        return [];
+    const sessions = await tmux.listSessions();
+    const targetSessions = session ? sessions.filter((s) => s.name === session) : sessions;
+    if (session && targetSessions.length === 0)
+        return [];
+    const snapshot = await process.getProcessSnapshot();
+    const tree = process.buildProcessTree(snapshot);
+    const states = [];
+    for (const s of targetSessions) {
+        const windows = await tmux.listWindows(s.name);
+        for (const w of windows) {
+            const panes = await tmux.listPanes(w.index, s.name);
+            for (const pane of panes) {
+                states.push(await buildWindowState({
+                    sessionName: s.name,
+                    windowIndex: w.index,
+                    windowName: w.name,
+                    pane,
+                    snapshot,
+                    tree,
+                    options: { includeNvim, includeAgent, includeBuffers },
+                }));
+            }
+        }
+    }
+    return states;
+}
+/**
+ * Get a single window's state by pane ID or session:window.pane reference.
+ */
+export async function getWindowState(ref, options) {
+    const trimmed = ref.trim();
+    if (!trimmed)
+        return null;
+    // Pane ID form: "%3"
+    if (trimmed.startsWith("%")) {
+        const states = await inventory({ ...(options || {}) });
+        return states.find((s) => s.window.paneId === trimmed) ?? null;
+    }
+    // session:window.pane form, e.g. "work:1.0"
+    const match = trimmed.match(/^([^:]+):(\d+)\.(\d+)$/);
+    if (!match)
+        return null;
+    const sessionName = match[1];
+    const windowIndex = parseInt(match[2], 10);
+    const paneIndex = parseInt(match[3], 10);
+    const states = await inventory({ ...(options || {}), session: sessionName });
+    return states.find((s) => s.window.window === windowIndex && s.window.pane === paneIndex) ?? null;
+}
+/**
+ * Get the currently focused window's state.
+ */
+export async function getFocusedWindow(options) {
+    const tmuxRunning = await tmux.isRunning();
+    if (!tmuxRunning)
+        return null;
+    const sessions = await tmux.listSessions();
+    const attachedSession = sessions.find((s) => s.attached);
+    if (!attachedSession)
+        return null;
+    const windows = await tmux.listWindows(attachedSession.name);
+    const activeWindow = windows.find((w) => w.active);
+    if (!activeWindow)
+        return null;
+    const panes = await tmux.listPanes(activeWindow.index, attachedSession.name);
+    const activePane = panes.find((p) => p.active);
+    if (!activePane)
+        return null;
+    return getWindowState(`${attachedSession.name}:${activeWindow.index}.${activePane.index}`, options);
+}

package/dist/lib/windows/inventory.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/windows/inventory.test.js

@@ -0,0 +1,292 @@
+import { describe, it, expect, mock } from 'bun:test';
+let tmuxRunning = true;
+let tmuxSessions = [];
+let tmuxWindowsBySession = new Map();
+let tmuxPanesBySessionWindow = new Map();
+let tmuxPaneIdByTarget = new Map();
+let tmuxPaneTtyByTarget = new Map();
+let processSnapshot = new Map();
+let nvimPidByPanePid = new Map();
+let nvimDiscoveryByPid = new Map();
+let nvimBuffers = null;
+let nvimCurrentBuffer = null;
+function keyForPane(session, window, pane) {
+    return `${session}:${window}.${pane}`;
+}
+mock.module('../tmux/bridge.js', () => {
+    return {
+        isRunning: async () => tmuxRunning,
+        listSessions: async () => tmuxSessions,
+        listWindows: async (session) => tmuxWindowsBySession.get(session ?? '') ?? [],
+        listPanes: async (window, session) => {
+            const win = typeof window === 'string' ? parseInt(window, 10) : window;
+            return tmuxPanesBySessionWindow.get(`${session ?? ''}:${win}`) ?? [];
+        },
+        getPaneId: async (window, pane = 0, session) => {
+            const win = typeof window === 'string' ? parseInt(window, 10) : window;
+            return tmuxPaneIdByTarget.get(keyForPane(session ?? '', win, pane)) ?? null;
+        },
+        getPaneTty: async (window, pane = 0, session) => {
+            const win = typeof window === 'string' ? parseInt(window, 10) : window;
+            return tmuxPaneTtyByTarget.get(keyForPane(session ?? '', win, pane)) ?? null;
+        },
+    };
+});
+function buildTree(snapshot) {
+    const tree = new Map();
+    for (const [pid, info] of snapshot) {
+        const children = tree.get(info.ppid) || [];
+        children.push(pid);
+        tree.set(info.ppid, children);
+    }
+    return tree;
+}
+function findDescendants(pid, tree, snapshot, filter) {
+    const results = [];
+    const stack = [pid];
+    const visited = new Set();
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (visited.has(current))
+            continue;
+        visited.add(current);
+        const info = snapshot.get(current);
+        if (info && current !== pid) {
+            if (!filter || filter(info))
+                results.push(current);
+        }
+        const children = tree.get(current) || [];
+        stack.push(...children);
+    }
+    return results;
+}
+function isNvimProcess(info) {
+    const cmd = info.cmd.toLowerCase();
+    return cmd === 'nvim' || cmd === 'vim' || cmd === 'vi';
+}
+function detectAgentType(info) {
+    const cmd = info.cmd.toLowerCase();
+    if (cmd === 'claude')
+        return 'claude';
+    if (cmd === 'codex')
+        return 'codex';
+    if (cmd === 'copilot')
+        return 'copilot';
+    if (cmd === 'gemini')
+        return 'gemini';
+    const wrappers = ['node', 'bun', 'npx', 'pnpm', 'npm'];
+    if (wrappers.includes(cmd)) {
+        const argsLower = info.args.toLowerCase();
+        if (argsLower.includes('claude'))
+            return 'claude';
+        if (argsLower.includes('codex'))
+            return 'codex';
+        if (argsLower.includes('copilot'))
+            return 'copilot';
+        if (argsLower.includes('gemini'))
+            return 'gemini';
+    }
+    return null;
+}
+mock.module('../process/snapshot.js', () => {
+    return {
+        getProcessSnapshot: async () => processSnapshot,
+        buildProcessTree: (snapshot) => buildTree(snapshot),
+        findDescendants: (pid, tree, snapshot, filter) => findDescendants(pid, tree, snapshot, filter),
+        detectAgentType: (info) => detectAgentType(info),
+        isNvimProcess: (info) => isNvimProcess(info),
+    };
+});
+mock.module('../nvim/index.js', () => {
+    return {
+        findNvimPidForWindow: (panePid) => nvimPidByPanePid.get(panePid) ?? null,
+        discoverNvimServerAddress: async (pid) => nvimDiscoveryByPid.get(pid) ?? null,
+        listBuffers: async () => nvimBuffers,
+        getCurrentBufferInfo: async () => nvimCurrentBuffer,
+    };
+});
+const windows = await import('./inventory.js');
+function resetMocks() {
+    tmuxRunning = true;
+    tmuxSessions = [];
+    tmuxWindowsBySession = new Map();
+    tmuxPanesBySessionWindow = new Map();
+    tmuxPaneIdByTarget = new Map();
+    tmuxPaneTtyByTarget = new Map();
+    processSnapshot = new Map();
+    nvimPidByPanePid = new Map();
+    nvimDiscoveryByPid = new Map();
+    nvimBuffers = null;
+    nvimCurrentBuffer = null;
+}
+describe('windows inventory', () => {
+    it('returns empty array when tmux is not running', async () => {
+        resetMocks();
+        tmuxRunning = false;
+        const result = await windows.inventory();
+        expect(result).toEqual([]);
+        const focused = await windows.getFocusedWindow();
+        expect(focused).toBeNull();
+    });
+    it('correlates tmux pane → nvim → agent', async () => {
+        resetMocks();
+        tmuxSessions = [{ name: 'work', windows: 1, attached: true, created: new Date() }];
+        tmuxWindowsBySession.set('work', [
+            { id: '@1', index: 0, name: 'editor', active: true, panes: 1, layout: 'even-horizontal' },
+        ]);
+        tmuxPanesBySessionWindow.set('work:0', [
+            {
+                index: 0,
+                active: true,
+                width: 100,
+                height: 30,
+                currentCommand: 'zsh',
+                currentPath: '/Users/luke/Developer',
+            },
+        ]);
+        tmuxPaneIdByTarget.set('work:0.0', '%3');
+        tmuxPaneTtyByTarget.set('work:0.0', '/dev/ttys001');
+        // Process snapshot for the pane tty:
+        // tmux(100) → zsh(200) → nvim(300)
+        //                    └→ codex(400)
+        processSnapshot.set(100, { pid: 100, ppid: 1, tty: '??', cmd: 'tmux', args: 'tmux new -s work' });
+        processSnapshot.set(200, { pid: 200, ppid: 100, tty: 'ttys001', cmd: 'zsh', args: '-zsh' });
+        processSnapshot.set(300, {
+            pid: 300,
+            ppid: 200,
+            tty: 'ttys001',
+            cmd: 'nvim',
+            args: 'nvim --listen /tmp/nvim.sock',
+        });
+        processSnapshot.set(400, {
+            pid: 400,
+            ppid: 200,
+            tty: 'ttys001',
+            cmd: 'codex',
+            args: 'codex exec - --session-id hostagent-123 ARBOR-42',
+        });
+        nvimPidByPanePid.set(200, 300);
+        nvimDiscoveryByPid.set(300, { addr: '/tmp/nvim.sock', method: 'argv' });
+        nvimBuffers = [
+            {
+                bufnr: 1,
+                name: '/Users/luke/Developer/utils/agents/src/index.ts',
+                filetype: 'typescript',
+                modified: false,
+                loaded: true,
+                listed: true,
+                linecount: 123,
+            },
+            {
+                bufnr: 2,
+                name: '/Users/luke/Developer/utils/agents/README.md',
+                filetype: 'markdown',
+                modified: true,
+                loaded: true,
+                listed: true,
+                linecount: 10,
+            },
+        ];
+        nvimCurrentBuffer = {
+            bufnr: 1,
+            name: '/Users/luke/Developer/utils/agents/src/index.ts',
+            filetype: 'typescript',
+            modified: false,
+            loaded: true,
+            listed: true,
+            cursor: { line: 10, col: 5 },
+            linecount: 123,
+        };
+        const result = await windows.inventory({ includeBuffers: true });
+        expect(result).toHaveLength(1);
+        const state = result[0];
+        expect(state.window.session).toBe('work');
+        expect(state.window.window).toBe(0);
+        expect(state.window.pane).toBe(0);
+        expect(state.window.paneId).toBe('%3');
+        expect(state.window.paneTty).toBe('/dev/ttys001');
+        expect(state.window.panePid).toBe(200);
+        expect(state.window.title).toBe('zsh');
+        expect(state.window.cwd).toBe('/Users/luke/Developer');
+        expect(state.window.active).toBe(true);
+        expect(state.window.size).toEqual({ cols: 100, rows: 30 });
+        expect(state.nvim).not.toBeNull();
+        expect(state.nvim?.available).toBe(true);
+        expect(state.nvim?.pid).toBe(300);
+        expect(state.nvim?.serverAddr).toBe('/tmp/nvim.sock');
+        expect(state.nvim?.discoveryMethod).toBe('argv');
+        expect(state.nvim?.currentBuffer?.path).toBe('/Users/luke/Developer/utils/agents/src/index.ts');
+        expect(state.nvim?.currentBuffer?.cursor).toEqual({ line: 10, col: 5 });
+        expect(state.agent).not.toBeNull();
+        expect(state.agent?.type).toBe('codex');
+        expect(state.agent?.pid).toBe(400);
+        expect(state.agent?.sessionId).toBe('hostagent-123');
+        expect(state.agent?.issue).toBe('ARBOR-42');
+        expect(state.buffers).toHaveLength(2);
+        expect(state.buffers[0]?.lineCount).toBe(123);
+    });
+    it('handles no nvim and no agent gracefully', async () => {
+        resetMocks();
+        tmuxSessions = [{ name: 'work', windows: 1, attached: true, created: new Date() }];
+        tmuxWindowsBySession.set('work', [
+            { id: '@1', index: 0, name: 'editor', active: true, panes: 1, layout: 'even-horizontal' },
+        ]);
+        tmuxPanesBySessionWindow.set('work:0', [
+            {
+                index: 0,
+                active: true,
+                width: 100,
+                height: 30,
+                currentCommand: 'zsh',
+                currentPath: '/Users/luke/Developer',
+            },
+        ]);
+        tmuxPaneIdByTarget.set('work:0.0', '%3');
+        tmuxPaneTtyByTarget.set('work:0.0', '/dev/ttys001');
+        processSnapshot.set(100, { pid: 100, ppid: 1, tty: '??', cmd: 'tmux', args: 'tmux new -s work' });
+        processSnapshot.set(200, { pid: 200, ppid: 100, tty: 'ttys001', cmd: 'zsh', args: '-zsh' });
+        // nvim/agent absent
+        nvimPidByPanePid.set(200, null);
+        const result = await windows.inventory();
+        expect(result).toHaveLength(1);
+        const state = result[0];
+        expect(state.agent).toBeNull();
+        expect(state.nvim?.available).toBe(false);
+        expect(state.nvim?.pid).toBeNull();
+        expect(state.buffers).toEqual([]);
+    });
+    it('supports getWindowState by pane ID and by session:window.pane', async () => {
+        resetMocks();
+        tmuxSessions = [{ name: 'work', windows: 1, attached: true, created: new Date() }];
+        tmuxWindowsBySession.set('work', [
+            { id: '@1', index: 0, name: 'editor', active: true, panes: 1, layout: 'even-horizontal' },
+        ]);
+        tmuxPanesBySessionWindow.set('work:0', [
+            {
+                index: 0,
+                active: true,
+                width: 100,
+                height: 30,
+                currentCommand: 'zsh',
+                currentPath: '/Users/luke/Developer',
+            },
+        ]);
+        tmuxPaneIdByTarget.set('work:0.0', '%3');
+        tmuxPaneTtyByTarget.set('work:0.0', '/dev/ttys001');
+        processSnapshot.set(100, { pid: 100, ppid: 1, tty: '??', cmd: 'tmux', args: 'tmux new -s work' });
+        processSnapshot.set(200, { pid: 200, ppid: 100, tty: 'ttys001', cmd: 'zsh', args: '-zsh' });
+        const byPaneId = await windows.getWindowState('%3');
+        expect(byPaneId?.window.session).toBe('work');
+        const byRef = await windows.getWindowState('work:0.0');
+        expect(byRef?.window.paneId).toBe('%3');
+    });
+    it('returns empty when filtering to unknown session', async () => {
+        resetMocks();
+        tmuxSessions = [{ name: 'other', windows: 1, attached: true, created: new Date() }];
+        tmuxWindowsBySession.set('other', [
+            { id: '@1', index: 0, name: 'misc', active: true, panes: 1, layout: 'even-horizontal' },
+        ]);
+        const result = await windows.inventory({ session: 'work' });
+        expect(result).toEqual([]);
+    });
+});

package/dist/lib/windows/types.d.ts

@@ -0,0 +1,46 @@
+export interface WindowInfo {
+    session: string;
+    window: number;
+    windowName: string;
+    pane: number;
+    paneId: string;
+    panePid: number;
+    paneTty: string;
+    title: string;
+    cwd: string;
+    active: boolean;
+    size: {
+        cols: number;
+        rows: number;
+    };
+}
+export interface BufferInfo {
+    name: string;
+    path: string;
+    modified: boolean;
+    filetype: string;
+    lineCount: number;
+    cursor?: {
+        line: number;
+        col: number;
+    };
+}
+export interface AgentInfo {
+    type: "claude" | "codex" | "copilot" | "gemini";
+    pid: number;
+    sessionId?: string;
+    issue?: string;
+}
+export interface WindowState {
+    window: WindowInfo;
+    nvim: {
+        available: boolean;
+        pid: number | null;
+        serverAddr: string | null;
+        discoveryMethod: "argv" | "lsof" | null;
+        currentBuffer: BufferInfo | null;
+    } | null;
+    agent: AgentInfo | null;
+    buffers: BufferInfo[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/lib/windows/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/lib/windows/types.ts"],"names":[],"mappings":"AACA,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,OAAO,CAAC;IAChB,IAAI,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;CACtC;AAGD,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,OAAO,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC;CACxC;AAGD,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,QAAQ,GAAG,OAAO,GAAG,SAAS,GAAG,QAAQ,CAAC;IAChD,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAGD,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,UAAU,CAAC;IACnB,IAAI,EAAE;QACJ,SAAS,EAAE,OAAO,CAAC;QACnB,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;QACnB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;QAC1B,eAAe,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;QACxC,aAAa,EAAE,UAAU,GAAG,IAAI,CAAC;KAClC,GAAG,IAAI,CAAC;IACT,KAAK,EAAE,SAAS,GAAG,IAAI,CAAC;IACxB,OAAO,EAAE,UAAU,EAAE,CAAC;CACvB"}

package/dist/lib/windows/types.js

@@ -0,0 +1 @@
+export {};