@gigaflow/gmux 0.15.0

package/dist/services/resources.js

@@ -0,0 +1,113 @@
+import { execFile } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import { promisify } from "node:util";
+import { parsePsOutput, subtreeRss } from "../core/proc-tree.js";
+const run = promisify(execFile);
+/**
+ * Cap every resource probe on the tick path. A wedged `ps`/`sysctl`/`vm_stat`
+ * would otherwise stall the tick forever; the timeout kills the child and
+ * rejects, which the defensive catches below already handle.
+ */
+const RESOURCE_TIMEOUT_MS = 5000;
+export function defaultResourceDeps() {
+    return {
+        psSnapshot: async () => (await run("ps", ["-axo", "pid,ppid,rss,comm"], { timeout: RESOURCE_TIMEOUT_MS })).stdout,
+        hostMemory: async () => (process.platform === "darwin" ? readMacMemory() : readLinuxMemory()),
+    };
+}
+export class ResourceMonitor {
+    deps;
+    constructor(deps = {}) {
+        this.deps = { ...defaultResourceDeps(), ...deps };
+    }
+    async sample(panePids) {
+        const now = Date.now();
+        const rows = parsePsOutput(await this.deps.psSnapshot());
+        const perPane = new Map();
+        let attributed = 0;
+        for (const [paneId, pid] of panePids) {
+            const rss = subtreeRss(pid, rows);
+            attributed += rss;
+            perPane.set(paneId, { perPaneRss: rss, ts: now });
+        }
+        const mem = await this.deps.hostMemory();
+        const host = {
+            usedRatio: mem.usedRatio,
+            unattributed: Math.max(0, mem.usedBytes - attributed),
+            ts: now,
+        };
+        return { perPane, host };
+    }
+}
+/**
+ * Parse `vm_stat` + `sysctl -n hw.memsize` / `hw.pagesize` for macOS memory pressure.
+ * Used ≈ (active + wired + compressed) pages × page size. Defensive: returns a safe
+ * zero reading rather than throwing if parsing fails.
+ */
+async function readMacMemory() {
+    try {
+        const [{ stdout: memsizeOut }, { stdout: pagesizeOut }, { stdout: vmStatOut }] = await Promise.all([
+            run("sysctl", ["-n", "hw.memsize"], { timeout: RESOURCE_TIMEOUT_MS }),
+            run("sysctl", ["-n", "hw.pagesize"], { timeout: RESOURCE_TIMEOUT_MS }),
+            run("vm_stat", [], { timeout: RESOURCE_TIMEOUT_MS }),
+        ]);
+        const total = Number(memsizeOut.trim());
+        const pageSize = Number(pagesizeOut.trim());
+        if (!Number.isFinite(total) || total <= 0 || !Number.isFinite(pageSize) || pageSize <= 0) {
+            return { usedRatio: 0, usedBytes: 0 };
+        }
+        const pages = parseVmStatPages(vmStatOut);
+        const active = pages.get("Pages active") ?? 0;
+        const wired = pages.get("Pages wired down") ?? 0;
+        const compressed = pages.get("Pages occupied by compressor") ?? 0;
+        const usedBytes = (active + wired + compressed) * pageSize;
+        if (!Number.isFinite(usedBytes) || usedBytes < 0) {
+            return { usedRatio: 0, usedBytes: 0 };
+        }
+        return { usedRatio: usedBytes / total, usedBytes };
+    }
+    catch {
+        return { usedRatio: 0, usedBytes: 0 };
+    }
+}
+/** Parse `vm_stat` output lines like "Pages active:  123456." into a label→count map. */
+function parseVmStatPages(raw) {
+    const pages = new Map();
+    for (const line of raw.split("\n")) {
+        const m = line.match(/^([A-Za-z][A-Za-z ]*?):\s*([\d,]+)\.?\s*$/);
+        if (!m)
+            continue;
+        const label = m[1].trim();
+        const count = Number(m[2].replace(/,/g, ""));
+        if (Number.isFinite(count))
+            pages.set(label, count);
+    }
+    return pages;
+}
+/**
+ * Parse `/proc/meminfo` for Linux memory pressure. Used = MemTotal − MemAvailable (KB→bytes).
+ * Defensive: returns a safe zero reading if the expected fields are missing.
+ */
+async function readLinuxMemory() {
+    try {
+        const raw = await readFile("/proc/meminfo", "utf8");
+        const fields = new Map();
+        for (const line of raw.split("\n")) {
+            const m = line.match(/^(\w+):\s*(\d+)\s*kB/);
+            if (!m)
+                continue;
+            fields.set(m[1], Number(m[2]));
+        }
+        const totalKb = fields.get("MemTotal");
+        const availKb = fields.get("MemAvailable");
+        if (totalKb === undefined || availKb === undefined || totalKb <= 0) {
+            return { usedRatio: 0, usedBytes: 0 };
+        }
+        const usedBytes = Math.max(0, totalKb - availKb) * 1024;
+        return { usedRatio: usedBytes / (totalKb * 1024), usedBytes };
+    }
+    catch {
+        return { usedRatio: 0, usedBytes: 0 };
+    }
+}
+//# sourceMappingURL=resources.js.map

package/dist/services/resources.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resources.js","sourceRoot":"","sources":["../../src/services/resources.ts"],"names":[],"mappings":"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"}

package/dist/services/search.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Full-text search across every transcript.
+ *
+ * Half a gigabyte of JSONL is too much to scan in Node, so we shell out to
+ * ripgrep and map its hits back onto indexed sessions. `--json` gives us exact
+ * byte offsets and match counts without us parsing rg's human output.
+ */
+import type { SearchHit, SessionRecord } from "../core/types.js";
+export interface SearchOptions {
+    /** Restrict to these sessions. Also supplies the file→session mapping. */
+    records: readonly SessionRecord[];
+    query: string;
+    /** Treat the query as a regex rather than a literal. */
+    regex?: boolean;
+    caseSensitive?: boolean;
+    maxSessions?: number;
+}
+export declare function searchSessions(options: SearchOptions): Promise<SearchHit[]>;
+/**
+ * A matching JSONL line is one enormous JSON record. Showing it raw would be
+ * unreadable, so we show a window of text around the match itself.
+ */
+export declare function snippetFrom(line: string, query: string, window?: number): string | null;
+/**
+ * Split paths into groups that each fit comfortably inside argv.
+ * A single path longer than the cap still gets its own batch — dropping it
+ * silently would mean a session that can never be searched.
+ */
+export declare function batchPaths(paths: readonly string[], maxBytes: number): string[][];

package/dist/services/search.js

@@ -0,0 +1,135 @@
+/**
+ * Full-text search across every transcript.
+ *
+ * Half a gigabyte of JSONL is too much to scan in Node, so we shell out to
+ * ripgrep and map its hits back onto indexed sessions. `--json` gives us exact
+ * byte offsets and match counts without us parsing rg's human output.
+ */
+import { spawn } from "node:child_process";
+import { MissingDependencyError } from "../core/errors.js";
+import { truncate } from "../core/text.js";
+const MAX_SNIPPETS_PER_SESSION = 3;
+/**
+ * Cap on the bytes of file paths handed to one ripgrep invocation.
+ *
+ * We pass explicit paths so that `--project` and friends narrow the corpus
+ * exactly. But argv is finite: ARG_MAX is 1 MB on macOS and 128 KB per argument
+ * on Linux, and a heavy user's session paths add up fast (1,163 sessions is
+ * already ~230 KB). Past the limit the spawn fails with E2BIG — so we batch.
+ */
+const MAX_ARGV_BYTES = 60_000;
+export async function searchSessions(options) {
+    const { records, query } = options;
+    if (records.length === 0 || query.trim() === "")
+        return [];
+    const byPath = new Map(records.map((r) => [r.filePath, r]));
+    const flags = [
+        "--json",
+        ...(options.regex ? [] : ["--fixed-strings"]),
+        // Always pass the pattern via -e. As a bare positional, a query that starts
+        // with a dash (`gmux grep "-n"`) would be parsed by ripgrep as an option.
+        "-e",
+        query,
+        options.caseSensitive ? "--case-sensitive" : "--ignore-case",
+        "--",
+    ];
+    const hits = new Map();
+    for (const batch of batchPaths([...byPath.keys()], MAX_ARGV_BYTES)) {
+        const lines = await runRipgrep([...flags, ...batch]);
+        for (const line of lines) {
+            let event;
+            try {
+                event = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (event.type !== "match")
+                continue;
+            // rg reports a non-UTF8 path as `bytes` rather than `text`; skip those.
+            const path = event.data?.path?.text;
+            if (!path)
+                continue;
+            const record = byPath.get(path);
+            if (!record)
+                continue;
+            let hit = hits.get(path);
+            if (!hit) {
+                hit = { session: record, matchCount: 0, snippets: [] };
+                hits.set(path, hit);
+            }
+            hit.matchCount += 1;
+            if (hit.snippets.length < MAX_SNIPPETS_PER_SESSION) {
+                const snippet = snippetFrom(event.data?.lines?.text ?? "", query);
+                if (snippet)
+                    hit.snippets.push(snippet);
+            }
+        }
+    }
+    const sorted = [...hits.values()].sort((a, b) => b.session.updatedAt.localeCompare(a.session.updatedAt));
+    return options.maxSessions ? sorted.slice(0, options.maxSessions) : sorted;
+}
+/**
+ * A matching JSONL line is one enormous JSON record. Showing it raw would be
+ * unreadable, so we show a window of text around the match itself.
+ */
+export function snippetFrom(line, query, window = 90) {
+    const at = line.toLowerCase().indexOf(query.toLowerCase());
+    const centre = at === -1 ? 0 : at;
+    const start = Math.max(0, centre - Math.floor(window / 3));
+    const slice = line.slice(start, start + window);
+    const cleaned = slice
+        .replace(/\\n/g, " ")
+        .replace(/\\"/g, '"')
+        .replace(/\s+/g, " ")
+        .trim();
+    return cleaned === "" ? null : truncate(cleaned, window);
+}
+/**
+ * Split paths into groups that each fit comfortably inside argv.
+ * A single path longer than the cap still gets its own batch — dropping it
+ * silently would mean a session that can never be searched.
+ */
+export function batchPaths(paths, maxBytes) {
+    const batches = [];
+    let current = [];
+    let bytes = 0;
+    for (const path of paths) {
+        const size = Buffer.byteLength(path) + 1;
+        if (current.length > 0 && bytes + size > maxBytes) {
+            batches.push(current);
+            current = [];
+            bytes = 0;
+        }
+        current.push(path);
+        bytes += size;
+    }
+    if (current.length > 0)
+        batches.push(current);
+    return batches;
+}
+function runRipgrep(args) {
+    return new Promise((resolve, reject) => {
+        const child = spawn("rg", args, { stdio: ["ignore", "pipe", "pipe"] });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.on("data", (chunk) => (stdout += String(chunk)));
+        child.stderr.on("data", (chunk) => (stderr += String(chunk)));
+        child.on("error", (error) => {
+            if (error.code === "ENOENT") {
+                reject(new MissingDependencyError("rg", "Install ripgrep: `brew install ripgrep` (macOS) or `apt install ripgrep` (Debian/Ubuntu)."));
+                return;
+            }
+            reject(error);
+        });
+        child.on("close", (code) => {
+            // rg exits 1 when there are simply no matches. That is not an error.
+            if (code === 0 || code === 1) {
+                resolve(stdout.split("\n").filter((l) => l !== ""));
+                return;
+            }
+            reject(new Error(`ripgrep exited with code ${code}: ${stderr.trim()}`));
+        });
+    });
+}
+//# sourceMappingURL=search.js.map

package/dist/services/search.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"search.js","sourceRoot":"","sources":["../../src/services/search.ts"],"names":[],"mappings":"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"}

package/dist/services/semantic-gate.d.ts

@@ -0,0 +1,13 @@
+import type { Observation } from "../core/gmux-types.js";
+export declare class SemanticGate {
+    private last;
+    private readonly distance;
+    private readonly debounceMs;
+    constructor(opts?: {
+        distance?: number;
+        debounceMs?: number;
+    });
+    private fp;
+    shouldSummarize(paneId: string, obs: Observation, now: number): boolean;
+    noteQueued(paneId: string, obs: Observation, now: number): void;
+}

package/dist/services/semantic-gate.js

@@ -0,0 +1,23 @@
+import { hammingDistance, simhash64 } from "../core/fingerprint.js";
+export class SemanticGate {
+    last = new Map();
+    distance;
+    debounceMs;
+    constructor(opts = {}) {
+        this.distance = opts.distance ?? 8;
+        this.debounceMs = opts.debounceMs ?? 4000;
+    }
+    fp(obs) { return simhash64(obs.tailLines.join("\n")); }
+    shouldSummarize(paneId, obs, now) {
+        const prev = this.last.get(paneId);
+        if (!prev)
+            return true;
+        if (now - prev.ts < this.debounceMs)
+            return false;
+        return hammingDistance(this.fp(obs), prev.fingerprint) > this.distance;
+    }
+    noteQueued(paneId, obs, now) {
+        this.last.set(paneId, { fingerprint: this.fp(obs), ts: now });
+    }
+}
+//# sourceMappingURL=semantic-gate.js.map

package/dist/services/semantic-gate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"semantic-gate.js","sourceRoot":"","sources":["../../src/services/semantic-gate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAKpE,MAAM,OAAO,YAAY;IACf,IAAI,GAAG,IAAI,GAAG,EAAgB,CAAC;IACtB,QAAQ,CAAS;IACjB,UAAU,CAAS;IAEpC,YAAY,OAAmD,EAAE;QAC/D,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,QAAQ,IAAI,CAAC,CAAC;QACnC,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,UAAU,IAAI,IAAI,CAAC;IAC5C,CAAC;IAEO,EAAE,CAAC,GAAgB,IAAY,OAAO,SAAS,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;IAEpF,eAAe,CAAC,MAAc,EAAE,GAAgB,EAAE,GAAW;QAC3D,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QACnC,IAAI,CAAC,IAAI;YAAE,OAAO,IAAI,CAAC;QACvB,IAAI,GAAG,GAAG,IAAI,CAAC,EAAE,GAAG,IAAI,CAAC,UAAU;YAAE,OAAO,KAAK,CAAC;QAClD,OAAO,eAAe,CAAC,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,IAAI,CAAC,WAAW,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC;IACzE,CAAC;IAED,UAAU,CAAC,MAAc,EAAE,GAAgB,EAAE,GAAW;QACtD,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,EAAE,WAAW,EAAE,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE,GAAG,EAAE,CAAC,CAAC;IAChE,CAAC;CACF"}

package/dist/services/semantic.d.ts

@@ -0,0 +1,113 @@
+/**
+ * The semantic worker: turns a gated pane observation into a `PaneSemantics`
+ * (one-line label + card) and writes it to the workspace model.
+ *
+ * THE DECOUPLING INVARIANT. An LLM call can hang, time out, or simply be slow
+ * — and gmux's fast path (sensors, gate, state transitions, the socket) must
+ * never notice. `SemanticWorker` is a bounded concurrent pool keyed by pane:
+ * `enqueue` never awaits the provider, coalesces a pane's pending job (newest
+ * observation wins), and lets `concurrency` jobs run side by side. One pane
+ * hanging never keeps another pane's label from landing.
+ */
+import type { Observation, PaneEntry } from "../core/gmux-types.js";
+import type { WorkspaceModel } from "./workspace.js";
+import type { SemanticGate } from "./semantic-gate.js";
+/** What a label provider is asked for, and what it must answer with. */
+export interface LabelProvider {
+    label(input: {
+        paneId: string;
+        project: string | null;
+        tailLines: string[];
+    }): Promise<{
+        label: string;
+        card: string;
+    }>;
+}
+/**
+ * Pull `{ label, card }` out of a model reply.
+ *
+ * Models fence their JSON or preface it more often than they should, so —
+ * matching `parseSummaryFields` — we take the outermost brace pair rather
+ * than trusting the whole reply to parse. A reply we can't make sense of
+ * still becomes *something*: the first line as the label, the raw text as
+ * the card, so a scrappy provider degrades gracefully instead of throwing.
+ */
+export declare function parseLabelFields(raw: string): {
+    label: string;
+    card: string;
+};
+/**
+ * The real `LabelProvider`: a thin wrapper over a provider CLI (the same
+ * argv `gmux`'s session summaries use), with its own compact prompt.
+ *
+ * Deliberately NOT built on `SummaryProvider`/`SummaryInput` — that shape
+ * carries a whole session's prompt history, git branch, files touched, and a
+ * six-field reply, none of which a live pane observation (paneId, project,
+ * a tail of lines) can honestly fill in. Reusing it would mean fabricating
+ * those fields or leaving them empty, which is worse than a dedicated,
+ * shorter prompt asking for exactly the two fields we need. `argv` is
+ * resolved the same way summaries resolve theirs (`resolveSummaryCommand`),
+ * so the two features keep sharing one provider *choice* even though they
+ * don't share a prompt shape.
+ *
+ * `argv: null` means "no provider configured" (`gmux setup` never ran, or the
+ * user chose to make no model calls) — `label()` throws in that case, which
+ * `SemanticWorker`'s try/catch turns into a silent skip rather than a crash.
+ */
+export declare class CliLabelProvider implements LabelProvider {
+    private readonly argv;
+    constructor(argv: string[] | null);
+    label(input: {
+        paneId: string;
+        project: string | null;
+        tailLines: string[];
+    }): Promise<{
+        label: string;
+        card: string;
+    }>;
+}
+/** The `CliLabelProvider` for the user's current config (`gmux setup`). */
+export declare function defaultLabelProvider(): Promise<CliLabelProvider>;
+/**
+ * A bounded worker pool that labels gated observations without ever letting
+ * a slow or hung provider call block another pane, or the caller of
+ * `enqueue`.
+ *
+ * `enqueue` is synchronous from the caller's point of view: it consults the
+ * gate, coalesces this pane's pending job (a newer observation replaces an
+ * older, not-yet-started one), and kicks the pump — it never awaits the
+ * provider itself. Up to `concurrency` jobs run side by side; a pane whose
+ * `provider.label()` never resolves simply never frees its pool slot, while
+ * every other slot keeps turning over.
+ */
+export declare class SemanticWorker {
+    private readonly model;
+    private readonly provider;
+    private readonly gate;
+    private readonly concurrency;
+    private running;
+    private pending;
+    private waiters;
+    private pumpScheduled;
+    constructor(model: WorkspaceModel, provider: LabelProvider, gate: SemanticGate, concurrency?: number);
+    /** Gate, coalesce, and schedule — never awaits the provider. */
+    enqueue(entry: PaneEntry, obs: Observation, now: number): void;
+    /**
+     * Defer the next `pump()` to a microtask instead of dispatching inline.
+     *
+     * A caller commonly fires several synchronous `enqueue` calls back to back
+     * (one scan tick touching many panes). Dispatching inline would let the
+     * very first `enqueue` claim a free pool slot before its siblings even
+     * land in `pending`, making `nextJob()`'s priority pick blind to the rest
+     * of the burst. Coalescing all of them into `pending` before the first
+     * pick — via one microtask hop — is what makes prioritization observable;
+     * it changes nothing about concurrency or the fire-and-forget run below.
+     */
+    private schedulePump;
+    /** Scan `pending` for the highest-`priorityOf` job; null when empty. */
+    private nextJob;
+    private pump;
+    private run;
+    /** Resolves once no job is running and none is pending. */
+    drain(): Promise<void>;
+}

package/dist/services/semantic.js

@@ -0,0 +1,216 @@
+/**
+ * The semantic worker: turns a gated pane observation into a `PaneSemantics`
+ * (one-line label + card) and writes it to the workspace model.
+ *
+ * THE DECOUPLING INVARIANT. An LLM call can hang, time out, or simply be slow
+ * — and gmux's fast path (sensors, gate, state transitions, the socket) must
+ * never notice. `SemanticWorker` is a bounded concurrent pool keyed by pane:
+ * `enqueue` never awaits the provider, coalesces a pane's pending job (newest
+ * observation wins), and lets `concurrency` jobs run side by side. One pane
+ * hanging never keeps another pane's label from landing.
+ */
+import { simhash64 } from "../core/fingerprint.js";
+import { readConfig, resolveSummaryCommand } from "./config.js";
+import { runProviderCommand } from "./provider-process.js";
+const LABEL_TIMEOUT_MS = 120_000;
+/** Cap the prompt so a runaway transcript tail doesn't balloon the call. */
+const MAX_TAIL_LINES = 60;
+function buildLabelPrompt(input) {
+    const project = input.project ?? "an unknown project";
+    const tail = input.tailLines.slice(-MAX_TAIL_LINES).join("\n");
+    return [
+        `You are labeling a live terminal pane working in "${project}".`,
+        "Here is the most recent output from that pane:",
+        "---",
+        tail,
+        "---",
+        "Reply with ONLY a single JSON object, no prose and no code fence:",
+        '{"label": "<=8 words, present tense, what it is doing right now>", "card": "2-4 sentences of context: what it is, what changed recently, what is next"}',
+    ].join("\n");
+}
+/**
+ * Pull `{ label, card }` out of a model reply.
+ *
+ * Models fence their JSON or preface it more often than they should, so —
+ * matching `parseSummaryFields` — we take the outermost brace pair rather
+ * than trusting the whole reply to parse. A reply we can't make sense of
+ * still becomes *something*: the first line as the label, the raw text as
+ * the card, so a scrappy provider degrades gracefully instead of throwing.
+ */
+export function parseLabelFields(raw) {
+    const start = raw.indexOf("{");
+    const end = raw.lastIndexOf("}");
+    if (start !== -1 && end !== -1 && end > start) {
+        try {
+            const parsed = JSON.parse(raw.slice(start, end + 1));
+            const label = typeof parsed["label"] === "string" ? parsed["label"].trim() : "";
+            const card = typeof parsed["card"] === "string" ? parsed["card"].trim() : "";
+            if (label)
+                return { label, card };
+        }
+        catch {
+            // Fall through to the defensive fallback below.
+        }
+    }
+    const firstLine = raw.trim().split("\n")[0]?.trim() ?? "";
+    return { label: firstLine || "(no label)", card: raw.trim() };
+}
+/**
+ * The real `LabelProvider`: a thin wrapper over a provider CLI (the same
+ * argv `gmux`'s session summaries use), with its own compact prompt.
+ *
+ * Deliberately NOT built on `SummaryProvider`/`SummaryInput` — that shape
+ * carries a whole session's prompt history, git branch, files touched, and a
+ * six-field reply, none of which a live pane observation (paneId, project,
+ * a tail of lines) can honestly fill in. Reusing it would mean fabricating
+ * those fields or leaving them empty, which is worse than a dedicated,
+ * shorter prompt asking for exactly the two fields we need. `argv` is
+ * resolved the same way summaries resolve theirs (`resolveSummaryCommand`),
+ * so the two features keep sharing one provider *choice* even though they
+ * don't share a prompt shape.
+ *
+ * `argv: null` means "no provider configured" (`gmux setup` never ran, or the
+ * user chose to make no model calls) — `label()` throws in that case, which
+ * `SemanticWorker`'s try/catch turns into a silent skip rather than a crash.
+ */
+export class CliLabelProvider {
+    argv;
+    constructor(argv) {
+        this.argv = argv;
+    }
+    async label(input) {
+        if (!this.argv)
+            throw new Error("no summary provider configured");
+        const prompt = buildLabelPrompt(input);
+        const raw = await runProviderCommand(this.argv, prompt, { timeoutMs: LABEL_TIMEOUT_MS });
+        return parseLabelFields(raw);
+    }
+}
+/** The `CliLabelProvider` for the user's current config (`gmux setup`). */
+export async function defaultLabelProvider() {
+    const config = await readConfig();
+    return new CliLabelProvider(resolveSummaryCommand(config));
+}
+/**
+ * Priority for the pane a `PendingJob` labels: the active/visible pane
+ * outranks any background pane, and a background pane that's mid-`working`
+ * outranks an idle one. Ties (any two panes at the same priority) are broken
+ * by scan order — `nextJob()` keeps the first one it sees.
+ */
+function priorityOf(entry) {
+    if (entry.identity.active)
+        return 3;
+    if (entry.state === "working")
+        return 2;
+    return 1;
+}
+/**
+ * A bounded worker pool that labels gated observations without ever letting
+ * a slow or hung provider call block another pane, or the caller of
+ * `enqueue`.
+ *
+ * `enqueue` is synchronous from the caller's point of view: it consults the
+ * gate, coalesces this pane's pending job (a newer observation replaces an
+ * older, not-yet-started one), and kicks the pump — it never awaits the
+ * provider itself. Up to `concurrency` jobs run side by side; a pane whose
+ * `provider.label()` never resolves simply never frees its pool slot, while
+ * every other slot keeps turning over.
+ */
+export class SemanticWorker {
+    model;
+    provider;
+    gate;
+    concurrency;
+    running = 0;
+    pending = new Map();
+    waiters = [];
+    pumpScheduled = false;
+    constructor(model, provider, gate, concurrency = 4) {
+        this.model = model;
+        this.provider = provider;
+        this.gate = gate;
+        this.concurrency = concurrency;
+    }
+    /** Gate, coalesce, and schedule — never awaits the provider. */
+    enqueue(entry, obs, now) {
+        if (!this.gate.shouldSummarize(entry.identity.paneId, obs, now))
+            return;
+        this.gate.noteQueued(entry.identity.paneId, obs, now);
+        this.pending.set(entry.identity.paneId, { entry, obs, now }); // coalesce: newest wins
+        this.schedulePump();
+    }
+    /**
+     * Defer the next `pump()` to a microtask instead of dispatching inline.
+     *
+     * A caller commonly fires several synchronous `enqueue` calls back to back
+     * (one scan tick touching many panes). Dispatching inline would let the
+     * very first `enqueue` claim a free pool slot before its siblings even
+     * land in `pending`, making `nextJob()`'s priority pick blind to the rest
+     * of the burst. Coalescing all of them into `pending` before the first
+     * pick — via one microtask hop — is what makes prioritization observable;
+     * it changes nothing about concurrency or the fire-and-forget run below.
+     */
+    schedulePump() {
+        if (this.pumpScheduled)
+            return;
+        this.pumpScheduled = true;
+        queueMicrotask(() => {
+            this.pumpScheduled = false;
+            this.pump();
+        });
+    }
+    /** Scan `pending` for the highest-`priorityOf` job; null when empty. */
+    nextJob() {
+        let best = null;
+        for (const kv of this.pending) {
+            if (!best || priorityOf(kv[1].entry) > priorityOf(best[1].entry))
+                best = kv;
+        }
+        return best;
+    }
+    pump() {
+        while (this.running < this.concurrency && this.pending.size > 0) {
+            const next = this.nextJob();
+            if (!next)
+                break; // Guards against a concurrent-mutation edge case under noUncheckedIndexedAccess.
+            const [paneId, job] = next;
+            this.pending.delete(paneId);
+            this.running += 1;
+            void this.run(paneId, job).finally(() => {
+                this.running -= 1;
+                this.pump();
+                if (this.running === 0 && this.pending.size === 0) {
+                    const waiters = this.waiters;
+                    this.waiters = [];
+                    waiters.forEach((w) => w());
+                }
+            });
+        }
+    }
+    async run(paneId, job) {
+        try {
+            const cwd = job.entry.identity.cwd;
+            const project = cwd ? (cwd.split("/").pop() ?? null) : null;
+            const { label, card } = await this.provider.label({ paneId, project, tailLines: job.obs.tailLines });
+            const semantics = {
+                label,
+                card,
+                fingerprint: simhash64(job.obs.tailLines.join("\n")),
+                updatedAt: job.now,
+                stale: false,
+            };
+            this.model.applySemantics(paneId, semantics);
+        }
+        catch {
+            // A provider failure marks nothing rather than crashing the worker;
+            // the next meaningful change re-triggers the gate and retries.
+        }
+    }
+    /** Resolves once no job is running and none is pending. */
+    drain() {
+        if (this.running === 0 && this.pending.size === 0)
+            return Promise.resolve();
+        return new Promise((r) => this.waiters.push(r));
+    }
+}
+//# sourceMappingURL=semantic.js.map