gsd-pi 2.33.0-dev.bafba33 → 2.33.1-dev.235d83a

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

@@ -0,0 +1,384 @@
+/**
+ * Task isolation backends for subagent execution.
+ *
+ * Provides filesystem isolation via git worktrees or FUSE overlays
+ * so concurrent subagents don't stomp on each other's files.
+ * Changes are captured as patches and merged back to the main repo.
+ */
+import { execFile as execFileCb } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { promisify } from "node:util";
+const execFile = promisify(execFileCb);
+// ============================================================================
+// Directory helpers
+// ============================================================================
+function encodeCwd(cwd) {
+    return cwd.replace(/\//g, "--");
+}
+function getIsolationBaseDir(cwd, taskId) {
+    return path.join(os.homedir(), ".gsd", "wt", encodeCwd(cwd), taskId);
+}
+// Track active isolation dirs for cleanup on exit
+const activeIsolations = new Set();
+let exitHandlerRegistered = false;
+function registerExitHandler() {
+    if (exitHandlerRegistered)
+        return;
+    exitHandlerRegistered = true;
+    const cleanup = () => {
+        for (const dir of activeIsolations) {
+            try {
+                // Best-effort sync cleanup: remove git worktree
+                const { execFileSync } = require("node:child_process");
+                try {
+                    execFileSync("git", ["worktree", "remove", "--force", dir], {
+                        stdio: "ignore",
+                        timeout: 5000,
+                    });
+                }
+                catch {
+                    // Worktree may not exist (FUSE mode), just rm
+                }
+                fs.rmSync(dir, { recursive: true, force: true });
+            }
+            catch {
+                // Best effort
+            }
+        }
+    };
+    process.on("exit", cleanup);
+}
+// ============================================================================
+// Git helpers
+// ============================================================================
+async function git(args, cwd) {
+    const { stdout } = await execFile("git", args, {
+        cwd,
+        maxBuffer: 50 * 1024 * 1024, // 50MB for large diffs
+    });
+    return stdout;
+}
+async function gitSilent(args, cwd) {
+    try {
+        return await git(args, cwd);
+    }
+    catch {
+        return "";
+    }
+}
+// ============================================================================
+// Baseline: capture and apply dirty state
+// ============================================================================
+async function captureBaseline(repoRoot) {
+    // Staged changes
+    const stagedDiff = await gitSilent(["diff", "--cached", "--binary"], repoRoot);
+    // Unstaged changes (tracked files only)
+    const unstagedDiff = await gitSilent(["diff", "--binary"], repoRoot);
+    // Untracked files
+    const untrackedOutput = await gitSilent(["ls-files", "--others", "--exclude-standard", "-z"], repoRoot);
+    const untrackedPaths = untrackedOutput
+        .split("\0")
+        .filter((p) => p.length > 0);
+    const untrackedFiles = [];
+    for (const relativePath of untrackedPaths) {
+        const fullPath = path.join(repoRoot, relativePath);
+        try {
+            const stat = fs.statSync(fullPath);
+            if (stat.isFile() && stat.size < 10 * 1024 * 1024) {
+                // Skip files > 10MB
+                untrackedFiles.push({
+                    relativePath,
+                    content: fs.readFileSync(fullPath),
+                });
+            }
+        }
+        catch {
+            // Skip unreadable files
+        }
+    }
+    return { stagedDiff, unstagedDiff, untrackedFiles };
+}
+async function applyBaseline(worktreeDir, baseline) {
+    // Apply staged diff
+    if (baseline.stagedDiff.trim()) {
+        const patchPath = path.join(worktreeDir, ".gsd-staged.patch");
+        fs.writeFileSync(patchPath, baseline.stagedDiff);
+        try {
+            await git(["apply", "--binary", patchPath], worktreeDir);
+            await git(["add", "-A"], worktreeDir);
+        }
+        catch {
+            // Non-fatal: staged diff may not apply cleanly
+        }
+        finally {
+            fs.unlinkSync(patchPath);
+        }
+    }
+    // Apply unstaged diff on top
+    if (baseline.unstagedDiff.trim()) {
+        const patchPath = path.join(worktreeDir, ".gsd-unstaged.patch");
+        fs.writeFileSync(patchPath, baseline.unstagedDiff);
+        try {
+            await git(["apply", "--binary", patchPath], worktreeDir);
+        }
+        catch {
+            // Non-fatal: unstaged diff may not apply cleanly
+        }
+        finally {
+            fs.unlinkSync(patchPath);
+        }
+    }
+    // Copy untracked files
+    for (const file of baseline.untrackedFiles) {
+        const dest = path.join(worktreeDir, file.relativePath);
+        const destDir = path.dirname(dest);
+        fs.mkdirSync(destDir, { recursive: true });
+        fs.writeFileSync(dest, file.content);
+    }
+    // Commit the baseline state so captureDeltaPatch can diff against it
+    // without accidentally including the parent's dirty state in the delta.
+    await gitSilent(["add", "-A"], worktreeDir);
+    await gitSilent(["commit", "--allow-empty", "-m", "gsd: baseline snapshot"], worktreeDir);
+}
+// ============================================================================
+// Delta capture
+// ============================================================================
+async function captureDeltaPatch(isolationDir) {
+    const patches = [];
+    // Add all changes (tracked + untracked) to index for diffing
+    await gitSilent(["add", "-A"], isolationDir);
+    // Capture the full diff against HEAD
+    const diff = await gitSilent(["diff", "--cached", "--binary", "HEAD"], isolationDir);
+    if (diff.trim()) {
+        patches.push({
+            path: path.join(isolationDir, "delta.patch"),
+            content: diff,
+        });
+    }
+    return patches;
+}
+// ============================================================================
+// Worktree backend
+// ============================================================================
+export async function createWorktreeIsolation(repoRoot, taskId) {
+    const worktreeDir = getIsolationBaseDir(repoRoot, taskId);
+    registerExitHandler();
+    activeIsolations.add(worktreeDir);
+    // Create parent directories
+    fs.mkdirSync(path.dirname(worktreeDir), { recursive: true });
+    // Remove stale worktree if it exists
+    try {
+        await git(["worktree", "remove", "--force", worktreeDir], repoRoot);
+    }
+    catch {
+        // Doesn't exist, that's fine
+    }
+    // Also clean up any leftover directory
+    fs.rmSync(worktreeDir, { recursive: true, force: true });
+    // Create the worktree
+    await git(["worktree", "add", "--detach", worktreeDir, "HEAD"], repoRoot);
+    // Capture and apply the parent's dirty state
+    const baseline = await captureBaseline(repoRoot);
+    await applyBaseline(worktreeDir, baseline);
+    return {
+        workDir: worktreeDir,
+        async captureDelta() {
+            return captureDeltaPatch(worktreeDir);
+        },
+        async cleanup() {
+            activeIsolations.delete(worktreeDir);
+            try {
+                await Promise.race([
+                    git(["worktree", "remove", "--force", worktreeDir], repoRoot),
+                    new Promise((_, reject) => setTimeout(() => reject(new Error("Worktree cleanup timed out")), 10_000)),
+                ]);
+            }
+            catch {
+                try {
+                    fs.rmSync(worktreeDir, { recursive: true, force: true });
+                }
+                catch { /* best effort */ }
+            }
+        },
+    };
+}
+// ============================================================================
+// FUSE overlay backend (Linux only)
+// ============================================================================
+async function findBinary(name) {
+    try {
+        const { stdout } = await execFile("which", [name]);
+        const p = stdout.trim();
+        return p || null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function createFuseOverlayIsolation(repoRoot, taskId) {
+    const baseDir = getIsolationBaseDir(repoRoot, taskId);
+    const upperDir = path.join(baseDir, "upper");
+    const workDir = path.join(baseDir, "work");
+    const mergedDir = path.join(baseDir, "merged");
+    // Check for fuse-overlayfs
+    const fuseBin = await findBinary("fuse-overlayfs");
+    if (!fuseBin) {
+        // Fall back to worktree
+        return createWorktreeIsolation(repoRoot, taskId);
+    }
+    registerExitHandler();
+    activeIsolations.add(baseDir);
+    // Clean up any stale mount/directory
+    fs.rmSync(baseDir, { recursive: true, force: true });
+    // Create directory structure
+    fs.mkdirSync(upperDir, { recursive: true });
+    fs.mkdirSync(workDir, { recursive: true });
+    fs.mkdirSync(mergedDir, { recursive: true });
+    // Mount the overlay
+    await execFile(fuseBin, [
+        "-o",
+        `lowerdir=${repoRoot},upperdir=${upperDir},workdir=${workDir}`,
+        mergedDir,
+    ]);
+    // Capture the parent's dirty file set so we can exclude them from the delta.
+    // Upper dir will contain both parent-dirty files (visible through overlay) and
+    // subagent-written files — we only want the latter.
+    const parentDirtyFiles = new Set();
+    const parentStatus = await gitSilent(["status", "--porcelain", "-z"], repoRoot);
+    for (const entry of parentStatus.split("\0").filter(Boolean)) {
+        // Porcelain format: XY filename (skip 3-char prefix)
+        const filePath = entry.slice(3);
+        if (filePath)
+            parentDirtyFiles.add(filePath);
+    }
+    return {
+        workDir: mergedDir,
+        async captureDelta() {
+            // Generate patches from upper dir (files actually written by the subagent).
+            // Exclude files that were already dirty in the parent repo.
+            const patches = [];
+            const diffs = [];
+            const walk = (dir, prefix) => {
+                for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+                    const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+                    if (entry.isDirectory()) {
+                        walk(path.join(dir, entry.name), rel);
+                    }
+                    else if (entry.isFile() && !parentDirtyFiles.has(rel)) {
+                        // This file was written by the subagent, not inherited from parent
+                        diffs.push(rel);
+                    }
+                }
+            };
+            walk(upperDir, "");
+            if (diffs.length > 0) {
+                // Use git diff in the merged dir (which has the .git) for only subagent files
+                const diff = await gitSilent(["diff", "--binary", "HEAD", "--", ...diffs], mergedDir);
+                if (diff.trim()) {
+                    patches.push({
+                        path: path.join(mergedDir, "delta.patch"),
+                        content: diff,
+                    });
+                }
+            }
+            return patches;
+        },
+        async cleanup() {
+            activeIsolations.delete(baseDir);
+            try {
+                // Unmount
+                const fusermount = (await findBinary("fusermount")) || "fusermount";
+                await execFile(fusermount, ["-u", mergedDir]);
+            }
+            catch {
+                // Try fusermount3 as fallback
+                try {
+                    await execFile("fusermount3", ["-u", mergedDir]);
+                }
+                catch {
+                    // Best effort
+                }
+            }
+            // Remove all dirs
+            fs.rmSync(baseDir, { recursive: true, force: true });
+        },
+    };
+}
+// ============================================================================
+// Unified creation
+// ============================================================================
+export async function createIsolation(repoRoot, taskId, mode) {
+    switch (mode) {
+        case "fuse-overlay":
+            return createFuseOverlayIsolation(repoRoot, taskId);
+        case "worktree":
+            return createWorktreeIsolation(repoRoot, taskId);
+        default:
+            throw new Error(`Isolation mode "${mode}" requires no isolation environment`);
+    }
+}
+// ============================================================================
+// Patch merge
+// ============================================================================
+export async function mergeDeltaPatches(repoRoot, patches) {
+    if (patches.length === 0) {
+        return { success: true, appliedPatches: [], failedPatches: [] };
+    }
+    // Combine all patches into one
+    const combined = patches.map((p) => p.content).join("\n");
+    const patchFile = path.join(os.tmpdir(), `gsd-merge-${Date.now()}.patch`);
+    const appliedPatches = [];
+    const failedPatches = [];
+    try {
+        fs.writeFileSync(patchFile, combined);
+        // Dry run first
+        try {
+            await git(["apply", "--check", "--binary", patchFile], repoRoot);
+        }
+        catch (err) {
+            // Dry run failed — patches conflict
+            for (const p of patches)
+                failedPatches.push(p.path);
+            return {
+                success: false,
+                appliedPatches,
+                failedPatches,
+                error: `Patch conflict: ${err instanceof Error ? err.message : String(err)}`,
+            };
+        }
+        // Apply for real
+        await git(["apply", "--binary", patchFile], repoRoot);
+        for (const p of patches)
+            appliedPatches.push(p.path);
+        return { success: true, appliedPatches, failedPatches };
+    }
+    finally {
+        try {
+            fs.unlinkSync(patchFile);
+        }
+        catch {
+            // Best effort
+        }
+    }
+}
+// ============================================================================
+// Settings reader (reads directly from settings file)
+// ============================================================================
+export function readIsolationMode() {
+    try {
+        const { getAgentDir } = require("@gsd/pi-coding-agent");
+        const settingsPath = path.join(getAgentDir(), "settings.json");
+        if (!fs.existsSync(settingsPath))
+            return "none";
+        const settings = JSON.parse(fs.readFileSync(settingsPath, "utf-8"));
+        const mode = settings?.taskIsolation?.mode;
+        if (mode === "worktree" || mode === "fuse-overlay")
+            return mode;
+        return "none";
+    }
+    catch {
+        return "none";
+    }
+}

package/dist/resources/extensions/subagent/worker-registry.js

@@ -0,0 +1,73 @@
+/**
+ * Worker Registry — Tracks active subagent sessions for dashboard visibility.
+ *
+ * Provides a global registry of currently-running parallel workers so the
+ * GSD dashboard overlay can display real-time worker status.
+ */
+const activeWorkers = new Map();
+let workerIdCounter = 0;
+/**
+ * Register a new worker. Returns the worker ID for later updates.
+ */
+export function registerWorker(agent, task, index, batchSize, batchId) {
+    const id = `worker-${++workerIdCounter}`;
+    activeWorkers.set(id, {
+        id,
+        agent,
+        task,
+        startedAt: Date.now(),
+        status: "running",
+        index,
+        batchSize,
+        batchId,
+    });
+    return id;
+}
+/**
+ * Update worker status when it completes or fails.
+ */
+export function updateWorker(id, status) {
+    const entry = activeWorkers.get(id);
+    if (entry) {
+        entry.status = status;
+        // Remove after a brief display window (5 seconds)
+        setTimeout(() => {
+            activeWorkers.delete(id);
+        }, 5000);
+    }
+}
+/**
+ * Get all currently-tracked workers (running + recently completed).
+ */
+export function getActiveWorkers() {
+    return Array.from(activeWorkers.values());
+}
+/**
+ * Get workers grouped by batch.
+ */
+export function getWorkerBatches() {
+    const batches = new Map();
+    for (const worker of activeWorkers.values()) {
+        const batch = batches.get(worker.batchId) ?? [];
+        batch.push(worker);
+        batches.set(worker.batchId, batch);
+    }
+    return batches;
+}
+/**
+ * Check if any parallel workers are currently running.
+ */
+export function hasActiveWorkers() {
+    for (const worker of activeWorkers.values()) {
+        if (worker.status === "running")
+            return true;
+    }
+    return false;
+}
+/**
+ * Reset registry state. Used for testing.
+ */
+export function resetWorkerRegistry() {
+    activeWorkers.clear();
+    workerIdCounter = 0;
+}

package/dist/resources/extensions/ttsr/index.js

@@ -0,0 +1,144 @@
+/**
+ * TTSR Extension — Time Traveling Stream Rules
+ *
+ * Zero-context-cost guardrails that monitor streaming output against regex
+ * patterns. On match: abort stream, inject rule as system reminder, retry.
+ * Rules cost nothing until they fire.
+ *
+ * Hooks:
+ *   session_start  → load rules, populate manager
+ *   turn_start     → reset buffers
+ *   message_update → check delta against rules, abort on match
+ *   turn_end       → increment message count
+ *   agent_end      → if pending violation, inject rule via sendMessage
+ */
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { TtsrManager } from "./ttsr-manager.js";
+import { loadRules } from "./rule-loader.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+function buildInterruptContent(rule) {
+    const template = readFileSync(join(__dirname, "ttsr-interrupt.md"), "utf-8");
+    return template
+        .replace("{{name}}", rule.name)
+        .replace("{{path}}", rule.path)
+        .replace("{{content}}", rule.content);
+}
+/**
+ * Extract match context from an AssistantMessageEvent delta.
+ * Returns null for non-delta events.
+ */
+function extractDeltaContext(event) {
+    if (event.type === "text_delta") {
+        return {
+            delta: event.delta,
+            context: { source: "text", streamKey: "text" },
+        };
+    }
+    if (event.type === "thinking_delta") {
+        return {
+            delta: event.delta,
+            context: { source: "thinking", streamKey: "thinking" },
+        };
+    }
+    if (event.type === "toolcall_delta") {
+        // Extract tool name and file paths from the partial message
+        const partial = event.partial;
+        const contentBlock = partial?.content?.[event.contentIndex];
+        const toolName = contentBlock && "name" in contentBlock ? contentBlock.name : undefined;
+        // Try to extract file paths from partial JSON arguments
+        const filePaths = [];
+        if (contentBlock && "partialJson" in contentBlock) {
+            const json = contentBlock.partialJson;
+            if (json) {
+                // Look for file_path or path in partial JSON
+                const pathMatch = json.match(/"(?:file_path|path)"\s*:\s*"([^"]+)"/);
+                if (pathMatch)
+                    filePaths.push(pathMatch[1]);
+            }
+        }
+        return {
+            delta: event.delta,
+            context: {
+                source: "tool",
+                toolName,
+                filePaths: filePaths.length > 0 ? filePaths : undefined,
+                streamKey: `toolcall:${event.contentIndex}`,
+            },
+        };
+    }
+    return null;
+}
+// Re-exports for external consumers
+export { TtsrManager } from "./ttsr-manager.js";
+export { loadRules } from "./rule-loader.js";
+export default function (pi) {
+    let manager = null;
+    let pendingViolation = null;
+    // ── session_start: load rules, populate manager ─────────────────────
+    pi.on("session_start", async (_event, ctx) => {
+        const rules = loadRules(ctx.cwd);
+        if (rules.length === 0) {
+            manager = null;
+            return;
+        }
+        manager = new TtsrManager();
+        let loaded = 0;
+        for (const rule of rules) {
+            if (manager.addRule(rule))
+                loaded++;
+        }
+        if (loaded === 0) {
+            manager = null;
+        }
+    });
+    // ── turn_start: reset buffers ───────────────────────────────────────
+    pi.on("turn_start", async () => {
+        if (!manager)
+            return;
+        manager.resetBuffer();
+        pendingViolation = null;
+    });
+    // ── message_update: check delta against rules ───────────────────────
+    pi.on("message_update", async (event, ctx) => {
+        if (!manager || !manager.hasRules())
+            return;
+        if (pendingViolation)
+            return; // Already matched, waiting for agent_end
+        const extracted = extractDeltaContext(event.assistantMessageEvent);
+        if (!extracted)
+            return;
+        const { delta, context } = extracted;
+        const matches = manager.checkDelta(delta, context);
+        if (matches.length === 0)
+            return;
+        // Match found — set pending violation and abort
+        pendingViolation = { rules: matches };
+        manager.markInjected(matches);
+        ctx.abort();
+    });
+    // ── turn_end: increment message count ───────────────────────────────
+    pi.on("turn_end", async () => {
+        if (!manager)
+            return;
+        manager.incrementMessageCount();
+    });
+    // ── agent_end: inject violation if pending ──────────────────────────
+    pi.on("agent_end", async () => {
+        if (!manager || !pendingViolation)
+            return;
+        const violation = pendingViolation;
+        pendingViolation = null;
+        // Build interrupt content for all matching rules
+        const interruptParts = violation.rules.map(buildInterruptContent);
+        const fullInterrupt = interruptParts.join("\n\n");
+        // Inject as a message that triggers a new turn
+        pi.sendMessage({
+            customType: "ttsr-violation",
+            content: fullInterrupt,
+            display: false,
+        }, { triggerTurn: true });
+    });
+}

package/dist/resources/extensions/ttsr/rule-loader.js

@@ -0,0 +1,70 @@
+/**
+ * TTSR Rule Loader
+ *
+ * Scans global (~/.gsd/agent/rules/*.md) and project-local (.gsd/rules/*.md)
+ * rule files. Parses YAML frontmatter for condition, scope, globs.
+ * Project rules override global rules with the same name.
+ */
+import { readdirSync, readFileSync, existsSync } from "node:fs";
+import { join, basename } from "node:path";
+import { homedir } from "node:os";
+import { splitFrontmatter, parseFrontmatterMap } from "../shared/frontmatter.js";
+function parseRuleFile(filePath) {
+    let content;
+    try {
+        content = readFileSync(filePath, "utf-8");
+    }
+    catch {
+        return null;
+    }
+    const [fmLines, body] = splitFrontmatter(content);
+    if (!fmLines)
+        return null;
+    const meta = parseFrontmatterMap(fmLines);
+    const condition = meta.condition;
+    if (!Array.isArray(condition) || condition.length === 0)
+        return null;
+    const name = basename(filePath, ".md");
+    return {
+        name,
+        path: filePath,
+        content: body.trim(),
+        condition: condition,
+        scope: Array.isArray(meta.scope) ? meta.scope : undefined,
+        globs: Array.isArray(meta.globs) ? meta.globs : undefined,
+    };
+}
+function scanDir(dir) {
+    if (!existsSync(dir))
+        return [];
+    const rules = [];
+    try {
+        const files = readdirSync(dir).filter((f) => f.endsWith(".md"));
+        for (const file of files) {
+            const rule = parseRuleFile(join(dir, file));
+            if (rule)
+                rules.push(rule);
+        }
+    }
+    catch {
+        // Directory unreadable — skip
+    }
+    return rules;
+}
+/**
+ * Load all TTSR rules from global and project-local directories.
+ * Project rules override global rules with the same name.
+ */
+export function loadRules(cwd) {
+    const globalDir = join(homedir(), ".gsd", "agent", "rules");
+    const projectDir = join(cwd, ".gsd", "rules");
+    const globalRules = scanDir(globalDir);
+    const projectRules = scanDir(projectDir);
+    // Merge: project rules override global by name
+    const byName = new Map();
+    for (const rule of globalRules)
+        byName.set(rule.name, rule);
+    for (const rule of projectRules)
+        byName.set(rule.name, rule);
+    return Array.from(byName.values());
+}