lsd-pi 1.2.3 → 1.3.2

package/dist/resources/extensions/subagent/agent-switcher-component.js

@@ -0,0 +1,208 @@
+import { Key, matchesKey, truncateToWidth, visibleWidth } from "@gsd/pi-tui";
+const MAX_VISIBLE_ROWS = 10;
+function stateIcon(theme, target) {
+    if (target.kind === "parent")
+        return theme.fg("accent", "●");
+    if (target.state === "running")
+        return theme.fg("warning", "▶");
+    if (target.state === "failed")
+        return theme.fg("error", "✗");
+    return theme.fg("success", "✓");
+}
+function stateBadge(theme, target) {
+    if (target.kind === "parent")
+        return theme.fg("muted", "parent");
+    if (target.state === "running")
+        return theme.fg("warning", "running");
+    if (target.state === "failed")
+        return theme.fg("error", "failed");
+    return theme.fg("success", "completed");
+}
+function plainLabel(target) {
+    if (target.kind === "parent") {
+        const currentSuffix = target.isCurrent ? " (current)" : "";
+        return `● parent — main session${currentSuffix}`;
+    }
+    const icon = target.state === "running" ? "▶" : target.state === "failed" ? "✗" : "✓";
+    const currentSuffix = target.isCurrent ? " (current)" : "";
+    return `${icon} ${target.agentName} — ${target.taskPreview}${currentSuffix}`;
+}
+class AgentSwitcherComponent {
+    tui;
+    theme;
+    targets;
+    done;
+    selectedIndex;
+    statusLine;
+    cachedWidth;
+    cachedLines;
+    constructor(tui, theme, targets, done) {
+        this.tui = tui;
+        this.theme = theme;
+        this.targets = targets;
+        this.done = done;
+        this.selectedIndex = this.getInitialSelectionIndex();
+    }
+    getInitialSelectionIndex() {
+        const firstSwitchable = this.targets.findIndex((target) => target.selectionAction !== "blocked");
+        return firstSwitchable >= 0 ? firstSwitchable : 0;
+    }
+    move(delta) {
+        if (this.targets.length === 0)
+            return;
+        const next = Math.max(0, Math.min(this.targets.length - 1, this.selectedIndex + delta));
+        if (next === this.selectedIndex)
+            return;
+        this.selectedIndex = next;
+        this.statusLine = undefined;
+        this.invalidate();
+        this.tui.requestRender();
+    }
+    handleInput(data) {
+        if (matchesKey(data, Key.escape) || matchesKey(data, Key.ctrl("c"))) {
+            this.done(undefined);
+            return;
+        }
+        if (matchesKey(data, Key.up)) {
+            this.move(-1);
+            return;
+        }
+        if (matchesKey(data, Key.down)) {
+            this.move(1);
+            return;
+        }
+        if (matchesKey(data, Key.pageUp)) {
+            this.move(-MAX_VISIBLE_ROWS);
+            return;
+        }
+        if (matchesKey(data, Key.pageDown)) {
+            this.move(MAX_VISIBLE_ROWS);
+            return;
+        }
+        if (matchesKey(data, Key.enter) || matchesKey(data, Key.space)) {
+            const selected = this.targets[this.selectedIndex];
+            if (!selected) {
+                this.done(undefined);
+                return;
+            }
+            if (selected.selectionAction === "blocked") {
+                this.statusLine = selected.blockedReason ?? "This row cannot be selected yet.";
+                this.invalidate();
+                this.tui.requestRender();
+                return;
+            }
+            this.done(selected);
+        }
+    }
+    getVisibleWindow() {
+        if (this.targets.length <= MAX_VISIBLE_ROWS)
+            return { start: 0, end: this.targets.length };
+        const half = Math.floor(MAX_VISIBLE_ROWS / 2);
+        let start = Math.max(0, this.selectedIndex - half);
+        let end = Math.min(this.targets.length, start + MAX_VISIBLE_ROWS);
+        if (end - start < MAX_VISIBLE_ROWS) {
+            start = Math.max(0, end - MAX_VISIBLE_ROWS);
+        }
+        return { start, end };
+    }
+    renderRow(target, isSelected, width) {
+        const cursor = isSelected ? this.theme.fg("accent", "▸") : " ";
+        const icon = stateIcon(this.theme, target);
+        const baseLabel = target.kind === "parent"
+            ? "parent — main session"
+            : `${target.agentName} — ${target.taskPreview}`;
+        const currentTag = target.isCurrent ? this.theme.fg("accent", "(current)") : "";
+        const badge = stateBadge(this.theme, target);
+        const right = [currentTag, badge].filter(Boolean).join(" ");
+        const leftRaw = `${cursor} ${icon} ${baseLabel}`;
+        const rightWidth = right ? visibleWidth(right) + 1 : 0;
+        const maxLeft = Math.max(10, width - 4 - rightWidth);
+        const left = truncateToWidth(leftRaw, maxLeft, "…");
+        const spacing = Math.max(1, width - 4 - visibleWidth(left) - visibleWidth(right));
+        const composed = `${left}${" ".repeat(spacing)}${right}`;
+        if (!isSelected) {
+            if (target.selectionAction === "blocked")
+                return this.theme.fg("dim", composed);
+            return composed;
+        }
+        return this.theme.bold(composed);
+    }
+    box(inner, width) {
+        const bdr = (s) => this.theme.fg("borderMuted", s);
+        const iw = width - 4;
+        const lines = [];
+        lines.push(bdr("╭" + "─".repeat(width - 2) + "╮"));
+        for (const line of inner) {
+            const truncated = truncateToWidth(line, iw, "…");
+            const pad = Math.max(0, iw - visibleWidth(truncated));
+            lines.push(bdr("│") + " " + truncated + " ".repeat(pad) + " " + bdr("│"));
+        }
+        lines.push(bdr("╰" + "─".repeat(width - 2) + "╯"));
+        return lines;
+    }
+    render(width) {
+        if (this.cachedLines && this.cachedWidth === width)
+            return this.cachedLines;
+        const inner = [];
+        inner.push(this.theme.bold(this.theme.fg("accent", "Agent session switcher")));
+        inner.push(this.theme.fg("dim", "Parent + tracked subagents"));
+        inner.push("");
+        if (this.targets.length === 0) {
+            inner.push(this.theme.fg("dim", "No switch targets available."));
+        }
+        else {
+            const { start, end } = this.getVisibleWindow();
+            for (let i = start; i < end; i++) {
+                inner.push(this.renderRow(this.targets[i], i === this.selectedIndex, width));
+            }
+            if (start > 0 || end < this.targets.length) {
+                inner.push("");
+                inner.push(this.theme.fg("dim", `${this.selectedIndex + 1}/${this.targets.length}`));
+            }
+        }
+        inner.push("");
+        const actionHint = this.targets[this.selectedIndex]?.selectionAction === "attach_live"
+            ? "Enter attach live"
+            : "Enter switch";
+        inner.push(this.theme.fg("dim", `${actionHint} · Esc cancel`));
+        if (this.statusLine) {
+            inner.push(this.theme.fg("warning", this.statusLine));
+        }
+        this.cachedLines = this.box(inner, width);
+        this.cachedWidth = width;
+        return this.cachedLines;
+    }
+    invalidate() {
+        this.cachedWidth = undefined;
+        this.cachedLines = undefined;
+    }
+}
+export async function showAgentSwitcher(ctx, targets) {
+    const result = await ctx.ui.custom((tui, theme, _kb, done) => new AgentSwitcherComponent(tui, theme, targets, done), {
+        overlay: true,
+        overlayOptions: {
+            anchor: "center",
+            width: "65%",
+            minWidth: 60,
+            maxHeight: "70%",
+        },
+    });
+    if (result !== undefined && result !== null) {
+        return result;
+    }
+    if (targets.length === 0)
+        return undefined;
+    const labels = targets.map((target, index) => `${index + 1}. ${plainLabel(target)}`);
+    const selected = await ctx.ui.select("Switch agent session", labels);
+    if (!selected || Array.isArray(selected))
+        return undefined;
+    const selectedIndex = labels.indexOf(selected);
+    if (selectedIndex < 0)
+        return undefined;
+    const target = targets[selectedIndex];
+    if (target.selectionAction === "blocked") {
+        ctx.ui.notify(target.blockedReason ?? "That target is not selectable yet.", "warning");
+        return undefined;
+    }
+    return target;
+}

package/dist/resources/extensions/subagent/agent-switcher-model.js

@@ -0,0 +1,107 @@
+function summarizeTask(task, max = 72) {
+    const trimmed = task.replace(/\s+/g, " ").trim();
+    if (!trimmed)
+        return "(no task)";
+    return trimmed.length > max ? `${trimmed.slice(0, max)}…` : trimmed;
+}
+function stateRank(state) {
+    if (state === "running")
+        return 0;
+    if (state === "completed")
+        return 1;
+    return 2;
+}
+function shouldIncludeRunningJob(job, rootParentSessionFile, currentCwd) {
+    if (job.parentSessionFile)
+        return job.parentSessionFile === rootParentSessionFile;
+    if (currentCwd && job.cwd)
+        return currentCwd === job.cwd;
+    return false;
+}
+export function buildAgentSwitchTargets(input) {
+    const targetsBySessionFile = new Map();
+    for (const link of input.trackedLinks) {
+        const canAttachLive = link.state === "running";
+        targetsBySessionFile.set(link.subagentSessionFile, {
+            id: link.id,
+            kind: "subagent",
+            sessionFile: link.subagentSessionFile,
+            parentSessionFile: link.parentSessionFile,
+            agentName: link.agentName,
+            taskPreview: summarizeTask(link.task),
+            state: link.state,
+            isCurrent: link.subagentSessionFile === input.currentSessionFile,
+            isLiveAttachCapable: canAttachLive,
+            selectionAction: link.state === "running" ? (canAttachLive ? "attach_live" : "blocked") : "switch_saved",
+            blockedReason: link.state === "running" && !canAttachLive
+                ? "Live attach is not implemented yet for running subagents."
+                : undefined,
+            sortTime: link.updatedAt,
+        });
+    }
+    const runningExtras = [];
+    for (const job of input.runningJobs) {
+        if (!shouldIncludeRunningJob(job, input.rootParentSessionFile, input.currentCwd))
+            continue;
+        if (job.sessionFile && targetsBySessionFile.has(job.sessionFile)) {
+            const existing = targetsBySessionFile.get(job.sessionFile);
+            existing.state = "running";
+            existing.isLiveAttachCapable = true;
+            existing.selectionAction = "attach_live";
+            existing.blockedReason = undefined;
+            existing.runningJobId = job.id;
+            existing.sortTime = Math.max(existing.sortTime, job.startedAt);
+            continue;
+        }
+        const canAttachLive = Boolean(job.sessionFile);
+        const syntheticSessionFile = job.sessionFile ?? `${input.rootParentSessionFile}#${job.id}`;
+        runningExtras.push({
+            id: job.id,
+            kind: "subagent",
+            sessionFile: syntheticSessionFile,
+            parentSessionFile: job.parentSessionFile ?? input.rootParentSessionFile,
+            agentName: job.agentName,
+            taskPreview: summarizeTask(job.task),
+            state: "running",
+            isCurrent: Boolean(job.sessionFile && job.sessionFile === input.currentSessionFile),
+            isLiveAttachCapable: canAttachLive,
+            selectionAction: canAttachLive ? "attach_live" : "blocked",
+            blockedReason: canAttachLive ? undefined : "Live attach is not implemented yet for running subagents.",
+            runningJobId: job.id,
+            sortTime: job.startedAt,
+        });
+    }
+    const parentTarget = {
+        id: "parent",
+        kind: "parent",
+        sessionFile: input.rootParentSessionFile,
+        agentName: "parent",
+        taskPreview: "Main session",
+        state: "completed",
+        isCurrent: input.currentSessionFile === input.rootParentSessionFile,
+        isLiveAttachCapable: false,
+        selectionAction: input.currentSessionFile === input.rootParentSessionFile ? "blocked" : "switch_saved",
+        blockedReason: input.currentSessionFile === input.rootParentSessionFile
+            ? "You are already in the parent/main session."
+            : undefined,
+        sortTime: Number.MAX_SAFE_INTEGER,
+    };
+    const targets = [
+        parentTarget,
+        ...targetsBySessionFile.values(),
+        ...runningExtras,
+    ];
+    targets.sort((a, b) => {
+        if (a.isCurrent !== b.isCurrent)
+            return a.isCurrent ? -1 : 1;
+        if (a.kind !== b.kind)
+            return a.kind === "parent" ? -1 : 1;
+        const stateDiff = stateRank(a.state) - stateRank(b.state);
+        if (stateDiff !== 0)
+            return stateDiff;
+        if (a.sortTime !== b.sortTime)
+            return b.sortTime - a.sortTime;
+        return a.agentName.localeCompare(b.agentName);
+    });
+    return targets;
+}

package/dist/resources/extensions/subagent/agents.js

@@ -51,7 +51,8 @@ function loadAgentsFromDir(dir, source) {
         const tools = frontmatter.tools
             ?.split(",")
             .map((t) => t.trim())
-            .filter(Boolean);
+            .filter(Boolean)
+            .filter((tool, index, all) => all.indexOf(tool) === index);
         agents.push({
             name: frontmatter.name,
             description: frontmatter.description,

package/dist/resources/extensions/subagent/background-job-manager.js

@@ -28,15 +28,15 @@ export class BackgroundJobManager {
      * @param runFn      Async function that runs the agent and returns a result summary
      * @returns          Job ID prefixed with `sa_`
      */
-    register(agentName, task, cwd, runFn) {
+    register(agentName, task, cwd, runFn, metadata) {
         const abortController = new AbortController();
-        return this.attachJob(agentName, task, cwd, abortController, runFn(abortController.signal));
+        return this.attachJob(agentName, task, cwd, abortController, runFn(abortController.signal), metadata);
     }
     /**
      * Adopt an already-running foreground subagent into background tracking.
      */
-    adoptRunning(agentName, task, cwd, abortController, resultPromise) {
-        return this.attachJob(agentName, task, cwd, abortController, resultPromise);
+    adoptRunning(agentName, task, cwd, abortController, resultPromise, metadata) {
+        return this.attachJob(agentName, task, cwd, abortController, resultPromise, metadata);
     }
     /**
      * Cancel a running job.
@@ -84,7 +84,7 @@ export class BackgroundJobManager {
         }
     }
     // ── Private ──────────────────────────────────────────────────────────────
-    attachJob(agentName, task, cwd, abortController, resultPromise) {
+    attachJob(agentName, task, cwd, abortController, resultPromise, metadata) {
         const running = this.getRunningJobs();
         if (running.length >= this.maxRunning) {
             throw new Error(`Maximum concurrent background subagents reached (${this.maxRunning}). ` +
@@ -105,17 +105,22 @@ export class BackgroundJobManager {
             cwd,
             status: "running",
             startedAt: Date.now(),
+            model: metadata?.model,
+            sessionFile: metadata?.sessionFile,
+            parentSessionFile: metadata?.parentSessionFile,
             abortController,
             promise: undefined,
         };
         job.promise = resultPromise
-            .then(({ summary, stderr, exitCode, model }) => {
+            .then(({ summary, stderr, exitCode, model, sessionFile, parentSessionFile }) => {
             job.status = exitCode === 0 ? "completed" : "failed";
             job.completedAt = Date.now();
             job.resultSummary = summary;
             job.stderr = stderr;
             job.exitCode = exitCode;
             job.model = model;
+            job.sessionFile = sessionFile;
+            job.parentSessionFile = parentSessionFile;
             this.scheduleEviction(id);
             this.deliverResult(job);
         })

package/dist/resources/extensions/subagent/background-runner.js

@@ -30,7 +30,11 @@ runFn) {
             stderr: result.stderr,
             exitCode: result.exitCode,
             model: result.model,
+            sessionFile: result.sessionFile,
+            parentSessionFile: result.parentSessionFile,
         };
+    }, {
+        parentSessionFile: ctx.parentSessionFile,
     });
     return jobId;
 }