terminal-agent-workboard 0.0.1

package/.agent-workboard.example.json

@@ -0,0 +1,24 @@
+{
+  "tmuxPrefix": "awb",
+  "defaultAgent": "codex",
+  "agents": {
+    "codex": {
+      "label": "Codex",
+      "command": "codex",
+      "resumeCommand": "codex resume {sessionId}"
+    },
+    "claude": {
+      "label": "Claude Code",
+      "command": "claude",
+      "resumeCommand": "claude --resume {sessionId}"
+    },
+    "opencode": {
+      "label": "OpenCode",
+      "command": "opencode"
+    },
+    "gemini": {
+      "label": "Gemini CLI",
+      "command": "gemini"
+    }
+  }
+}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Lellansin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,139 @@
+# terminal-agent-workboard
+
+`workboard` is a tmux-backed Node.js + TypeScript prototype for managing multiple code-agent conversations from one terminal workboard.
+
+It can run sessions for tools such as Claude Code, Codex, OpenCode, and Gemini CLI, then group them by inferred state:
+
+- Working
+- Needs input
+- Rate limited (agent hit a quota / rate limit modal — switch model or wait for reset)
+- Completed
+- Return pending
+- WIP
+- Human handoff
+- Session switching
+- Agent routing
+
+## Requirements
+
+- Node.js 20+
+- tmux
+- Any agent CLI you want to route to, such as `codex`, `claude`, `opencode`, or `gemini`
+
+## Tech Stack
+
+- Node.js + TypeScript
+- React + Ink for terminal rendering
+- tmux for agent process/session management
+
+## Status detection
+
+`workboard` polls each tmux pane and infers a status by matching common agent UI patterns. Notably:
+
+- `Needs input` — Codex/Claude prompt sitting idle after an assistant reply, or an initialization prompt (e.g. Codex "Update available · press enter to continue") blocks startup.
+- `Rate limited` — codex shows "Approaching rate limits" model-switch modal, or the agent output contains usage-limit / quota-exhausted phrasing. Open the session with `Ctrl+O` to choose a model or wait for the quota window to reset.
+
+## History Discovery
+
+The default UI shows a bordered `Current Session` panel with the selected session's latest message. Long messages are truncated in the panel; use `Ctrl+O` or `/open` to inspect the full tmux session. History is hidden by default and can be opened with `/history`.
+
+The history browser reads JSONL history files only:
+
+- `~/.codex/session_index.jsonl`
+- `~/.claude/projects/**/*.jsonl`
+
+Markdown files such as Claude plan documents are intentionally ignored.
+
+On startup, `workboard` initializes `~/.workboard/state.json`. This global state stores mappings between JSONL history ids and tmux sessions, so `/resume <history-id>` can return to the existing tmux session instead of creating a duplicate.
+
+Inside `/history`:
+
+- `↑` / `↓` or `j` / `k`: select a history entry
+- `Enter`: resume the selected history session
+- `Esc`: close history and return to the prompt
+
+## Setup
+
+```sh
+npm install
+npm run build
+npm link
+```
+
+Optional config:
+
+```sh
+cp .agent-workboard.example.json .agent-workboard.json
+```
+
+Edit `.agent-workboard.json` if your agent commands differ.
+
+## Run
+
+```sh
+npm run dev
+```
+
+After `npm link`, use the bin directly:
+
+```sh
+workboard
+```
+
+Useful flags:
+
+```sh
+npm run dev -- --demo
+npm run dev -- new codex "review this repository"
+npm run dev -- list
+workboard --demo
+workboard new codex "review this repository"
+workboard list
+```
+
+## Controls
+
+- `↑` / `↓` or `j` / `k`: select a session
+- `Enter`: send the bottom input to the selected session
+- `/`: open the slash-command menu
+- `Shift+Enter`: insert a newline in the prompt
+- `←` / `→`: move the prompt cursor
+- `Home` / `End`: move to line start/end
+- `Alt+←` / `Alt+→` or `Ctrl+←` / `Ctrl+→`: move by word
+- `Backspace` / `Delete`: delete before/after the cursor
+- `Ctrl+W`: delete the previous word
+- `Ctrl+K`: delete to the end of the line
+- `Ctrl+N`: mark bottom input as a new-session task
+- `Ctrl+O`: attach to the selected tmux session
+- `Ctrl+X`: stop the selected session
+- `Ctrl+C`: clear the prompt; press again on an empty prompt to quit
+
+Commands typed into the input:
+
+```text
+/new codex implement login flow
+/new claude inspect failing tests
+/history
+/resume 019dab7d
+/review
+/send payment-migration continue
+/select pr-review
+/open
+/kill
+/refresh
+```
+
+Without a slash command, pressing `Enter` sends the input to the selected conversation. If nothing is selected, it creates a new session with the default agent.
+If the selected conversation no longer has a running tmux session, plain input creates a new session instead of sending to the dead session.
+
+History restore uses a stable tmux session name. `workboard` first checks whether that tmux session already exists; if not, it creates one with the configured `resumeCommand`.
+
+Resume command templates can use:
+
+```json
+{
+  "resumeCommand": "codex resume {sessionId}"
+}
+```
+
+Available placeholders: `{sessionId}`, `{sourcePath}`, `{cwd}`, `{title}`.

package/dist/SlashCommandMenu.js

@@ -0,0 +1,14 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+export function SlashCommandMenu({ items, activeIndex, width, maxVisible = 7 }) {
+    if (items.length === 0)
+        return null;
+    const visibleStart = Math.min(Math.max(0, activeIndex - Math.floor((maxVisible - 1) / 2)), Math.max(0, items.length - maxVisible));
+    const visible = items.slice(visibleStart, visibleStart + maxVisible);
+    const labelWidth = Math.min(Math.max(14, ...visible.map((item) => item.label.length + 2)), Math.max(14, Math.floor(width / 2)));
+    return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [visible.map((item, index) => {
+                const actualIndex = visibleStart + index;
+                const active = actualIndex === activeIndex;
+                return (_jsxs(Box, { gap: 2, children: [_jsx(Box, { width: labelWidth, children: _jsxs(Text, { color: active ? "cyan" : undefined, bold: active, wrap: "truncate-end", children: [active ? "› " : "  ", item.label] }) }), _jsx(Text, { color: active ? "cyan" : "gray", wrap: "truncate-end", children: item.description })] }, item.name));
+            }), _jsxs(Text, { color: "gray", children: ["(", activeIndex + 1, "/", items.length, ") \u2191\u2193 select \u00B7 Enter apply \u00B7 Esc close"] })] }));
+}

package/dist/config.js

@@ -0,0 +1,34 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+const defaultConfig = {
+    tmuxPrefix: "awb",
+    defaultAgent: "codex",
+    agents: {
+        codex: { label: "Codex", command: "codex", resumeCommand: "codex resume {sessionId}" },
+        claude: { label: "Claude Code", command: "claude", resumeCommand: "claude --resume {sessionId}" },
+        opencode: { label: "OpenCode", command: "opencode" },
+        gemini: { label: "Gemini CLI", command: "gemini" }
+    }
+};
+export function loadConfig(cwd) {
+    const path = join(cwd, ".agent-workboard.json");
+    if (!existsSync(path)) {
+        return defaultConfig;
+    }
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    return {
+        ...defaultConfig,
+        ...parsed,
+        agents: {
+            ...defaultConfig.agents,
+            ...(parsed.agents ?? {})
+        }
+    };
+}
+export function ensureConfigExample(cwd) {
+    const path = join(cwd, ".agent-workboard.example.json");
+    if (existsSync(path))
+        return;
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, `${JSON.stringify(defaultConfig, null, 2)}\n`);
+}

package/dist/ctrlCBehavior.js

@@ -0,0 +1,21 @@
+export function decideCtrlC(inputText, pendingExitAt, now, timeoutMs = 2000) {
+    if (inputText.length > 0) {
+        return {
+            action: "clearPrompt",
+            message: "prompt cleared; press ctrl+c again to quit",
+            pendingExitAt: null
+        };
+    }
+    if (pendingExitAt !== null && now - pendingExitAt <= timeoutMs) {
+        return {
+            action: "exit",
+            message: "exiting",
+            pendingExitAt: null
+        };
+    }
+    return {
+        action: "promptExit",
+        message: "press ctrl+c again to quit",
+        pendingExitAt: now
+    };
+}

package/dist/globalState.js

@@ -0,0 +1,44 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+export class GlobalStateStore {
+    dir;
+    path;
+    constructor(dir = defaultWorkboardHome()) {
+        this.dir = dir;
+        this.path = join(dir, "state.json");
+    }
+    init() {
+        mkdirSync(this.dir, { recursive: true });
+        if (!existsSync(this.path)) {
+            this.writeMappings([]);
+        }
+    }
+    readMappings() {
+        if (!existsSync(this.path))
+            return [];
+        const parsed = JSON.parse(readFileSync(this.path, "utf8"));
+        return parsed.mappings ?? [];
+    }
+    findByHistoryId(historyId) {
+        return this.readMappings().find((mapping) => mapping.historyId === historyId);
+    }
+    upsertMapping(mapping) {
+        const mappings = this.readMappings();
+        const index = mappings.findIndex((candidate) => candidate.historyId === mapping.historyId);
+        if (index >= 0) {
+            mappings[index] = mapping;
+        }
+        else {
+            mappings.push(mapping);
+        }
+        this.writeMappings(mappings);
+    }
+    writeMappings(mappings) {
+        mkdirSync(dirname(this.path), { recursive: true });
+        writeFileSync(this.path, `${JSON.stringify({ mappings }, null, 2)}\n`);
+    }
+}
+export function defaultWorkboardHome() {
+    return process.env.WORKBOARD_HOME || join(homedir(), ".workboard");
+}

package/dist/history.js

@@ -0,0 +1,148 @@
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, join } from "node:path";
+import { ageLabel } from "./status.js";
+export function discoverHistory(limit = 12) {
+    return [...discoverCodexHistory(limit), ...discoverClaudeHistory(limit)]
+        .sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime())
+        .slice(0, limit);
+}
+function discoverCodexHistory(limit) {
+    const path = join(homedir(), ".codex", "session_index.jsonl");
+    if (!existsSync(path))
+        return [];
+    return readJsonl(path)
+        .map((item) => {
+        const id = asString(item.id) ?? basename(path);
+        const updatedAt = asString(item.updated_at) ?? new Date(statSync(path).mtimeMs).toISOString();
+        const title = asString(item.thread_name) ?? id;
+        return toEntry({ id, agent: "codex", title, updatedAt, sourcePath: path });
+    })
+        .filter((entry) => Boolean(entry))
+        .sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime())
+        .slice(0, limit);
+}
+function discoverClaudeHistory(limit) {
+    const root = join(homedir(), ".claude", "projects");
+    if (!existsSync(root))
+        return [];
+    return findJsonlFiles(root, 5)
+        .filter((path) => !path.includes("/subagents/"))
+        .map((path) => parseClaudeJsonl(path))
+        .filter((entry) => Boolean(entry))
+        .sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime())
+        .slice(0, limit);
+}
+function parseClaudeJsonl(path) {
+    const fallbackId = basename(path, ".jsonl");
+    const fallbackTime = new Date(statSync(path).mtimeMs).toISOString();
+    let cwd;
+    let updatedAt = fallbackTime;
+    let sessionId = fallbackId;
+    let title = "";
+    for (const item of readJsonl(path, 120)) {
+        const timestamp = asString(item.timestamp);
+        if (timestamp)
+            updatedAt = timestamp;
+        cwd = asString(item.cwd) ?? cwd;
+        sessionId = asString(item.sessionId) ?? sessionId;
+        if (item.type === "user") {
+            const message = asObject(item.message);
+            const content = extractText(message?.content);
+            if (content && !isEnvironmentContext(content)) {
+                title = content;
+                break;
+            }
+        }
+    }
+    if (!title) {
+        title = fallbackId;
+    }
+    return toEntry({
+        id: sessionId,
+        agent: "claude",
+        title,
+        cwd: cwd ?? decodeClaudeProjectPath(dirname(path)),
+        updatedAt,
+        sourcePath: path
+    });
+}
+function findJsonlFiles(root, maxDepth) {
+    const files = [];
+    const visit = (dir, depth) => {
+        if (depth > maxDepth)
+            return;
+        for (const entry of safeReadDir(dir)) {
+            const path = join(dir, entry.name);
+            if (entry.isDirectory()) {
+                visit(path, depth + 1);
+            }
+            else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+                files.push(path);
+            }
+        }
+    };
+    visit(root, 0);
+    return files
+        .map((path) => ({ path, mtimeMs: statSync(path).mtimeMs }))
+        .sort((a, b) => b.mtimeMs - a.mtimeMs)
+        .slice(0, 200)
+        .map((item) => item.path);
+}
+function readJsonl(path, maxLines = Number.POSITIVE_INFINITY) {
+    return readFileSync(path, "utf8")
+        .split(/\r?\n/)
+        .slice(0, maxLines)
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .map((line) => {
+        try {
+            return JSON.parse(line);
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter((item) => Boolean(item));
+}
+function safeReadDir(path) {
+    try {
+        return readdirSync(path, { withFileTypes: true, encoding: "utf8" });
+    }
+    catch {
+        return [];
+    }
+}
+function toEntry(input) {
+    const title = input.title.trim().replace(/\s+/g, " ").slice(0, 120);
+    if (!title)
+        return null;
+    return {
+        ...input,
+        title,
+        ageLabel: ageLabel(input.updatedAt)
+    };
+}
+function extractText(value) {
+    if (typeof value === "string")
+        return value;
+    if (Array.isArray(value)) {
+        return value.map((item) => extractText(asObject(item)?.text)).filter(Boolean).join(" ");
+    }
+    return "";
+}
+function decodeClaudeProjectPath(path) {
+    const encoded = basename(path);
+    if (!encoded.startsWith("-"))
+        return undefined;
+    return encoded.replace(/-/g, "/");
+}
+function isEnvironmentContext(text) {
+    return text.trim().startsWith("<environment_context>");
+}
+function asObject(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+}
+function asString(value) {
+    return typeof value === "string" && value.trim() ? value : undefined;
+}

package/dist/index.js

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+import { loadConfig } from "./config.js";
+import { SessionStore } from "./store.js";
+import { Tmux } from "./tmux.js";
+import { Workboard } from "./workboard.js";
+import { GlobalStateStore } from "./globalState.js";
+import React from "react";
+import { render } from "ink";
+import { WorkboardApp } from "./ui.js";
+const cwd = process.cwd();
+const config = loadConfig(cwd);
+const store = new SessionStore(cwd);
+const globalState = new GlobalStateStore();
+const tmux = new Tmux();
+const workboard = new Workboard(cwd, config, store, tmux, globalState);
+async function main() {
+    globalState.init();
+    if (!tmux.available()) {
+        throw new Error("tmux is required but was not found on PATH.");
+    }
+    const [command, ...args] = process.argv.slice(2);
+    if (command === "new") {
+        const [agent, ...taskParts] = args;
+        const task = taskParts.join(" ");
+        if (!task)
+            throw new Error("Usage: workboard new <agent> <task>");
+        const session = workboard.create(agent, task);
+        console.log(`created ${session.id} (${session.tmuxSession})`);
+        return;
+    }
+    if (command === "send") {
+        const [id, ...inputParts] = args;
+        if (!id || inputParts.length === 0)
+            throw new Error("Usage: workboard send <session> <input>");
+        workboard.send(id, inputParts.join(" "));
+        console.log(`sent to ${id}`);
+        return;
+    }
+    if (command === "list") {
+        for (const session of workboard.list()) {
+            console.log(`${session.status.padEnd(17)} ${session.id.padEnd(32)} ${session.agent.padEnd(10)} ${session.summary}`);
+        }
+        return;
+    }
+    if (command === "open") {
+        const [id] = args;
+        if (!id)
+            throw new Error("Usage: workboard open <session>");
+        workboard.attach(id);
+    }
+    if (command === "--demo") {
+        seedDemo(store, config.tmuxPrefix);
+    }
+    if (!process.stdin.isTTY) {
+        throw new Error("workboard requires an interactive terminal (TTY).");
+    }
+    render(React.createElement(WorkboardApp, { workboard, config }), { exitOnCtrlC: false });
+}
+function seedDemo(store, prefix) {
+    const now = new Date();
+    store.write([
+        demo("dark-mode", "codex", "system theme vs explicit toggle - your call", "Needs input", 4, prefix, now),
+        demo("release-notes", "claude", "draft ready - which feature leads?", "Needs input", 11, prefix, now),
+        demo("load-test", "gemini", "-> to return", "Return pending", 3, prefix, now),
+        demo("pr-review", "codex", "-> to return", "Working", 0, prefix, now),
+        demo("perf-audit", "opencode", "events_org_ts index live - p95 38ms", "Working", 7, prefix, now),
+        demo("payment-migration", "claude", "porting billing to the new processor - 12/14", "WIP", 2, prefix, now),
+        demo("onboarding-copy", "gemini", "rewriting empty-state copy across 6 screens", "Working", 1, prefix, now),
+        demo("test-coverage", "codex", "billing/ from 61% -> 92% - PR #408 merged", "Completed", 9, prefix, now)
+    ]);
+}
+function demo(id, agent, title, statusOverride, ageMinutes, prefix, now) {
+    const updatedAt = new Date(now.getTime() - ageMinutes * 60_000).toISOString();
+    return {
+        id,
+        title,
+        agent,
+        tmuxSession: `${prefix}-${id}`,
+        createdAt: updatedAt,
+        updatedAt,
+        statusOverride
+    };
+}
+main().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+});

package/dist/promptBuffer.js

@@ -0,0 +1,102 @@
+export const EMPTY_BUFFER = { text: "", cursor: 0 };
+export function insertText(state, value) {
+    if (!value)
+        return state;
+    const text = state.text.slice(0, state.cursor) + value + state.text.slice(state.cursor);
+    return { text, cursor: state.cursor + value.length };
+}
+export function backspace(state) {
+    if (state.cursor === 0)
+        return state;
+    return {
+        text: state.text.slice(0, state.cursor - 1) + state.text.slice(state.cursor),
+        cursor: state.cursor - 1
+    };
+}
+export function deleteForward(state) {
+    if (state.cursor >= state.text.length)
+        return state;
+    return {
+        text: state.text.slice(0, state.cursor) + state.text.slice(state.cursor + 1),
+        cursor: state.cursor
+    };
+}
+export function deleteWordBefore(state) {
+    const end = state.cursor;
+    let start = end;
+    while (start > 0 && /\s/.test(state.text[start - 1] ?? ""))
+        start--;
+    while (start > 0 && !/\s/.test(state.text[start - 1] ?? ""))
+        start--;
+    return {
+        text: state.text.slice(0, start) + state.text.slice(end),
+        cursor: start
+    };
+}
+export function moveLeft(state) {
+    return state.cursor === 0 ? state : { ...state, cursor: state.cursor - 1 };
+}
+export function moveRight(state) {
+    return state.cursor >= state.text.length ? state : { ...state, cursor: state.cursor + 1 };
+}
+export function moveWordLeft(state) {
+    let cursor = state.cursor;
+    while (cursor > 0 && /\s/.test(state.text[cursor - 1] ?? ""))
+        cursor--;
+    while (cursor > 0 && !/\s/.test(state.text[cursor - 1] ?? ""))
+        cursor--;
+    return { ...state, cursor };
+}
+export function moveWordRight(state) {
+    let cursor = state.cursor;
+    while (cursor < state.text.length && /\s/.test(state.text[cursor] ?? ""))
+        cursor++;
+    while (cursor < state.text.length && !/\s/.test(state.text[cursor] ?? ""))
+        cursor++;
+    return { ...state, cursor };
+}
+export function moveLineStart(state) {
+    return { ...state, cursor: locate(state).lineStart };
+}
+export function moveLineEnd(state) {
+    return { ...state, cursor: locate(state).lineEnd };
+}
+export function moveUp(state) {
+    const { column, lineStart } = locate(state);
+    if (lineStart === 0)
+        return { ...state, cursor: 0 };
+    const previousLineEnd = lineStart - 1;
+    const previousLineStart = state.text.lastIndexOf("\n", previousLineEnd - 1) + 1;
+    return { ...state, cursor: previousLineStart + Math.min(column, previousLineEnd - previousLineStart) };
+}
+export function moveDown(state) {
+    const { column, lineEnd } = locate(state);
+    if (lineEnd >= state.text.length)
+        return { ...state, cursor: state.text.length };
+    const nextLineStart = lineEnd + 1;
+    const nextLineNewline = state.text.indexOf("\n", nextLineStart);
+    const nextLineEnd = nextLineNewline === -1 ? state.text.length : nextLineNewline;
+    return { ...state, cursor: nextLineStart + Math.min(column, nextLineEnd - nextLineStart) };
+}
+export function killLine(state) {
+    const { lineEnd } = locate(state);
+    return { text: state.text.slice(0, state.cursor) + state.text.slice(lineEnd), cursor: state.cursor };
+}
+export function getCurrentSlashToken(state) {
+    const beforeCursor = state.text.slice(0, state.cursor);
+    const line = beforeCursor.slice(beforeCursor.lastIndexOf("\n") + 1);
+    if (!line.startsWith("/") || /\s/.test(line))
+        return null;
+    return line;
+}
+function locate(state) {
+    const before = state.text.slice(0, state.cursor);
+    const lineStart = before.lastIndexOf("\n") + 1;
+    const after = state.text.slice(state.cursor);
+    const nextNewline = after.indexOf("\n");
+    return {
+        column: state.cursor - lineStart,
+        lineStart,
+        lineEnd: nextNewline === -1 ? state.text.length : state.cursor + nextNewline
+    };
+}

package/dist/slashCommands.js

@@ -0,0 +1,29 @@
+export function buildSlashCommands(agents) {
+    return [
+        { kind: "new", name: "new", label: "/new", description: `Create a session: /new [${agents.join("|")}] <task>`, insertText: "/new " },
+        { kind: "history", name: "history", label: "/history", description: "Browse discovered JSONL history sessions" },
+        { kind: "resume", name: "resume", label: "/resume", description: "Restore a JSONL history session: /resume <id-prefix>", insertText: "/resume " },
+        { kind: "review", name: "review", label: "/review", description: "Preview selected tmux session pane", insertText: "/review" },
+        { kind: "send", name: "send", label: "/send", description: "Send input to a session: /send <id> <text>", insertText: "/send " },
+        { kind: "select", name: "select", label: "/select", description: "Select a session by id/title", insertText: "/select " },
+        { kind: "open", name: "open", label: "/open", description: "Attach to selected tmux session" },
+        { kind: "kill", name: "kill", label: "/kill", description: "Stop selected tmux session" },
+        { kind: "status", name: "status", label: "/status", description: "Override status: /status <id> <status>", insertText: "/status " },
+        { kind: "refresh", name: "refresh", label: "/refresh", description: "Reload tmux/session state" },
+        { kind: "help", name: "help", label: "/help", description: "Show available slash commands" },
+        { kind: "quit", name: "quit", label: "/quit", description: "Exit workboard" }
+    ];
+}
+export function filterSlashCommands(items, token) {
+    if (!token.startsWith("/"))
+        return [];
+    const query = token.slice(1).toLowerCase();
+    if (!query)
+        return items;
+    return items.filter((item) => item.label.slice(1).toLowerCase().includes(query) || item.description.toLowerCase().includes(query));
+}
+export function isExactSlashCommand(input, item) {
+    if (!item)
+        return false;
+    return input.trim() === item.label;
+}