pi-vault-mind 0.7.4 → 0.8.0

package/dist/src/tombstone.d.ts

@@ -0,0 +1,13 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+export interface TombstoneResult {
+    success: boolean;
+    lineIndex?: number;
+    tombstonedAt?: string;
+    message: string;
+}
+/**
+ * Replace a JSONL entry with a tombstone record at the same line position.
+ * Preserves blank lines and malformed lines so line numbers stay stable.
+ */
+export declare const tombstoneEntryById: (collectionPath: string, entryId: string) => TombstoneResult;
+export declare const registerTombstoneTool: (pi: ExtensionAPI) => void;

package/dist/src/tombstone.js

@@ -0,0 +1,103 @@
+import * as fs from "node:fs";
+import { Type } from "typebox";
+import { collectionNames, loadConfig } from "./utils.js";
+/**
+ * Replace a JSONL entry with a tombstone record at the same line position.
+ * Preserves blank lines and malformed lines so line numbers stay stable.
+ */
+export const tombstoneEntryById = (collectionPath, entryId) => {
+    if (!fs.existsSync(collectionPath)) {
+        return {
+            success: false,
+            message: `Collection file not found at ${collectionPath}.`,
+        };
+    }
+    const raw = fs.readFileSync(collectionPath, "utf-8");
+    const hasTrailingNewline = raw.endsWith("\n");
+    const lines = raw.split("\n");
+    const entries = hasTrailingNewline ? lines.slice(0, -1) : lines;
+    let foundIndex = -1;
+    let originalDomain = "";
+    for (let i = 0; i < entries.length; i++) {
+        const line = entries[i].trim();
+        if (!line)
+            continue;
+        try {
+            const entry = JSON.parse(line);
+            if (entry && entry.id === entryId) {
+                foundIndex = i;
+                originalDomain = typeof entry.domain === "string" ? entry.domain : "";
+                break;
+            }
+        }
+        catch {
+            /* skip malformed */
+        }
+    }
+    if (foundIndex === -1) {
+        return {
+            success: false,
+            message: `Entry "${entryId}" not found in ${collectionPath}.`,
+        };
+    }
+    const tombstonedAt = new Date().toISOString();
+    const tombstone = {
+        id: entryId,
+        domain: "tombstone",
+        source: "redaction",
+        fact: "",
+        tag: "tombstone",
+        artifact: "",
+        tombstoned_at: tombstonedAt,
+        original_domain: originalDomain,
+    };
+    entries[foundIndex] = JSON.stringify(tombstone);
+    const output = `${entries.join("\n")}\n`;
+    fs.writeFileSync(collectionPath, output, "utf-8");
+    return {
+        success: true,
+        lineIndex: foundIndex,
+        tombstonedAt,
+        message: `Tombstoned entry "${entryId}" at line ${foundIndex + 1} in ${collectionPath}.`,
+    };
+};
+export const registerTombstoneTool = (pi) => {
+    pi.registerTool({
+        name: "tombstone_entry",
+        label: "Tombstone Wiki Entry",
+        description: "Mark a wiki entry as deleted by replacing it with a tombstone record in the JSONL log.",
+        promptSnippet: 'tombstone_entry(collection="main", entryId="...")',
+        promptGuidelines: [
+            "Use to redact or remove an entry without breaking the append-only JSONL format.",
+            "The original entry is replaced by a tombstone record at the same line position.",
+        ],
+        parameters: Type.Object({
+            collection: Type.String({ description: "Collection name containing the entry" }),
+            entryId: Type.String({ description: "ID of the entry to tombstone" }),
+        }),
+        async execute(_id, params, _signal, _onUpdate, ctx) {
+            const cfg = loadConfig(ctx.cwd);
+            const def = cfg.collections[params.collection];
+            if (!def) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Unknown collection "${params.collection}". Available: ${collectionNames(cfg).join(", ")}`,
+                        },
+                    ],
+                    details: {},
+                };
+            }
+            const result = tombstoneEntryById(def.path, params.entryId);
+            return {
+                content: [{ type: "text", text: result.message }],
+                details: {
+                    success: result.success,
+                    lineIndex: result.lineIndex,
+                    tombstonedAt: result.tombstonedAt,
+                },
+            };
+        },
+    });
+};

package/dist/src/tools.d.ts

@@ -1,2 +1,10 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+/** Jaccard similarity over character bigrams. Returns 0–1. */
+export declare const jaccardSimilarity: (a: string, b: string) => number;
+/** Decide whether any search result is a duplicate of the incoming value. */
+export declare const isDuplicateResult: (results: unknown[], dedupField: string, incomingValue: string, mode: "exact" | "fuzzy", threshold: number) => {
+    duplicate: boolean;
+    matchedValue?: string;
+    similarity?: number;
+};
 export declare const registerTools: (pi: ExtensionAPI) => void;

package/dist/src/tools.js

@@ -1,10 +1,56 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { Type } from "typebox";
+import { registerDiscoverSchemaTool } from "./discover-schema.js";
 import { graphUpsert, queryGraph } from "./graph.js";
 import { getStatus, searchFts, searchHybrid, upsertEntry, } from "./lance.js";
+import { registerTombstoneTool } from "./tombstone.js";
 import { collectionNames, ensureDir, findConfig, loadConfig } from "./utils.js";
 import { VaultWriter } from "./vault-writer.js";
+/** Jaccard similarity over character bigrams. Returns 0–1. */
+export const jaccardSimilarity = (a, b) => {
+    if (a === b)
+        return 1;
+    const bigrams = (value) => {
+        const set = new Set();
+        const lower = value.toLowerCase();
+        for (let i = 0; i < lower.length - 1; i++) {
+            set.add(lower.slice(i, i + 2));
+        }
+        return set;
+    };
+    const setA = bigrams(a);
+    const setB = bigrams(b);
+    if (setA.size === 0 || setB.size === 0)
+        return 0;
+    let intersection = 0;
+    for (const g of setA) {
+        if (setB.has(g))
+            intersection++;
+    }
+    return intersection / (setA.size + setB.size - intersection);
+};
+/** Decide whether any search result is a duplicate of the incoming value. */
+export const isDuplicateResult = (results, dedupField, incomingValue, mode, threshold) => {
+    if (!incomingValue)
+        return { duplicate: false };
+    for (const result of results) {
+        const candidate = result?.[dedupField];
+        if (typeof candidate !== "string")
+            continue;
+        if (mode === "exact") {
+            if (candidate === incomingValue) {
+                return { duplicate: true, matchedValue: candidate };
+            }
+            continue;
+        }
+        const similarity = jaccardSimilarity(candidate, incomingValue);
+        if (similarity >= threshold) {
+            return { duplicate: true, matchedValue: candidate, similarity };
+        }
+    }
+    return { duplicate: false };
+};
 export const registerTools = (pi) => {
     /* ── promote_wiki ── */
     pi.registerTool({
@@ -358,12 +404,18 @@ export const registerTools = (pi) => {
             // autopilot
             if (def.dedupField && fs.existsSync(def.path)) {
                 try {
-                    const results = await searchHybrid(cfg.wiki.dataDir, params.collection, params.entry[def.dedupField] || "", 1, cfg.wiki);
-                    if (results.length > 0 &&
-                        results[0][def.dedupField] === params.entry[def.dedupField]) {
+                    const mode = def.dedupMode ?? cfg.wiki.dedupMode ?? "exact";
+                    const threshold = def.dedupThreshold ?? cfg.wiki.dedupThreshold ?? 0.85;
+                    const searchLimit = mode === "fuzzy" ? 10 : 1;
+                    const results = await searchHybrid(cfg.wiki.dataDir, params.collection, params.entry[def.dedupField] || "", searchLimit, cfg.wiki);
+                    const dup = isDuplicateResult(results, def.dedupField, params.entry[def.dedupField] || "", mode, threshold);
+                    if (dup.duplicate) {
                         return {
                             content: [
-                                { type: "text", text: `Duplicate detected via "${def.dedupField}". Skipped.` },
+                                {
+                                    type: "text",
+                                    text: `Duplicate detected via "${def.dedupField}" (mode=${mode}${dup.similarity !== undefined ? `, similarity=${dup.similarity.toFixed(2)}` : ""}). Skipped.`,
+                                },
                             ],
                             details: {},
                         };
@@ -769,4 +821,6 @@ export const registerTools = (pi) => {
             }
         },
     });
+    registerDiscoverSchemaTool(pi);
+    registerTombstoneTool(pi);
 };

package/dist/src/types.d.ts

@@ -2,6 +2,10 @@ export interface CollectionDef {
     path: string;
     schema: string[];
     dedupField?: string;
+    /** Dedup strategy: exact string match (default) or fuzzy Jaccard similarity. */
+    dedupMode?: "exact" | "fuzzy";
+    /** Jaccard similarity threshold for fuzzy dedup. Default 0.85. */
+    dedupThreshold?: number;
 }
 export interface InjectorDef {
     name: string;
@@ -140,6 +144,12 @@ export interface WikiConfig {
     vaults?: Record<string, VaultConfig>;
     ftsEnabled?: boolean;
     httpPort?: number;
+    /** Whether to watch collection directories and auto-reindex on changes (default false). */
+    autoIndex?: boolean;
+    /** Default dedup strategy for collections without their own setting. */
+    dedupMode?: "exact" | "fuzzy";
+    /** Default Jaccard similarity threshold for fuzzy dedup. Default 0.85. */
+    dedupThreshold?: number;
 }
 export interface PiContextDef {
     enabled?: boolean;
@@ -207,3 +217,40 @@ export interface WikiIngestInput {
     source: string;
     sourceType?: "url" | "file" | "text";
 }
+export interface TombstoneWikiInput {
+    collection: string;
+    entryId: string;
+}
+export interface IntakeQuestionOption {
+    label: string;
+    description?: string;
+}
+export interface IntakeQuestion {
+    question: string;
+    header: string;
+    options?: IntakeQuestionOption[];
+    multi_select: boolean;
+}
+export interface AskIntakeInput {
+    questions: IntakeQuestion[];
+    persist?: "none" | "ledger" | "vault" | "both";
+    collection?: string;
+}
+export interface DiscoverSchemaInput {
+    file: string;
+    name?: string;
+    sample?: number;
+}
+export interface AskIntakeResult {
+    answers: Record<string, string | string[]>;
+    cancelled: boolean;
+    partial: boolean;
+    ledgerEntry?: {
+        id: string;
+        path: string;
+        tag: string;
+    };
+    vaultEntry?: {
+        path: string;
+    };
+}

package/dist/src/types.js

@@ -38,6 +38,7 @@ export const DEFAULT_CONFIG = {
         },
         ftsEnabled: true,
         httpPort: 11435,
+        autoIndex: false,
     },
     extensionCompatibility: {
         "pi-context": {

package/dist/src/utils.d.ts

@@ -1,8 +1,10 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import type { PiContextDef, UniversalConfig } from "./types.js";
 export declare const CONFIG_FILES: string[];
-export declare const GLOBAL_CONFIG_DIR: string;
-export declare const GLOBAL_CONFIG_PATH: string;
+/** Lazy — recomputes HOME each call so tests can override it. */
+export declare const getGlobalConfigDir: () => string;
+/** Lazy — recomputes HOME each call so tests can override it. */
+export declare const getGlobalConfigPath: () => string;
 export declare const EXT_ROOT: string;
 /** Expand a leading `~` to the user's home directory. */
 export declare const expandHome: (p: string) => string;

package/dist/src/utils.js

@@ -3,8 +3,10 @@ import * as path from "node:path";
 import { DEFAULT_CONFIG } from "./types.js";
 // Config filenames, in priority order (first match wins).
 export const CONFIG_FILES = ["pi-vault-mind.config.json", ".pi/vault-mind.config.json"];
-export const GLOBAL_CONFIG_DIR = path.join(process.env.HOME || process.env.USERPROFILE || "", ".pi", "agent");
-export const GLOBAL_CONFIG_PATH = path.join(GLOBAL_CONFIG_DIR, "vault-mind.config.json");
+/** Lazy — recomputes HOME each call so tests can override it. */
+export const getGlobalConfigDir = () => path.join(process.env.HOME || process.env.USERPROFILE || "", ".pi", "agent");
+/** Lazy — recomputes HOME each call so tests can override it. */
+export const getGlobalConfigPath = () => path.join(getGlobalConfigDir(), "vault-mind.config.json");
 export const EXT_ROOT = path.join(import.meta.dirname, "..");
 /** Expand a leading `~` to the user's home directory. */
 export const expandHome = (p) => {
@@ -30,8 +32,9 @@ export const ensureDir = (filePath) => {
 };
 export const findConfig = (cwd) => {
     const result = {};
-    if (fs.existsSync(GLOBAL_CONFIG_PATH)) {
-        result.global = GLOBAL_CONFIG_PATH;
+    const globalPath = getGlobalConfigPath();
+    if (fs.existsSync(globalPath)) {
+        result.global = globalPath;
     }
     for (const rel of CONFIG_FILES) {
         const fp = path.join(cwd, rel);
@@ -90,6 +93,8 @@ const mergeConfigLayer = (base, layer, cwd) => {
             path: resolvePath(cwd, def.path || (resolvedBase?.path ?? "")),
             schema: typeof def.schema === "string" ? (resolvedBase?.schema ?? []) : def.schema,
             dedupField: def.dedupField ?? resolvedBase?.dedupField,
+            dedupMode: def.dedupMode ?? resolvedBase?.dedupMode,
+            dedupThreshold: def.dedupThreshold ?? resolvedBase?.dedupThreshold,
         };
     }
     merged.collections = resolvedCollections;

package/dist/src/watcher.d.ts

@@ -39,6 +39,8 @@ interface AgentGroup {
     combinedInstruction: string;
     /** Unique dispatch ID for tracking and writeback */
     dispatchId: string;
+    /** Vault root this group belongs to (used for queue persistence). */
+    vaultPath?: string;
 }
 export interface WatcherState {
     /** Active file watchers keyed by vault name */
@@ -55,6 +57,10 @@ export interface WatcherState {
     activeDispatches: number;
     /** Queue of pending dispatch tasks */
     pendingQueue: AgentGroup[];
+    /** Per-vault+role batch flush timers, keyed by `${vault}\u0000${role}`. */
+    batchTimers: Map<string, ReturnType<typeof setTimeout>>;
+    /** Pending job IDs per vault+role key, awaiting a batch flush. */
+    batchPending: Map<string, string[]>;
     /** Active dispatch records (for status reporting) */
     activeDispatches_: Map<string, DispatchRecord>;
 }
@@ -75,7 +81,7 @@ interface DispatchRecord {
  * 2. Different role markers create separate groups.
  * 3. Named IDs (e.g., @agent-Miner:customId) force isolation regardless of role.
  */
-export declare function scanFile(filePath: string): AgentGroup[];
+export declare function scanFile(filePath: string, vaultPath?: string): AgentGroup[];
 /**
  * Generate a unique dispatch ID for tracking and writeback targeting.
  * Exported for testing.

package/dist/src/watcher.js

@@ -16,12 +16,17 @@
  */
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { createJob, getJob, markBatchRunning, markJobDone, markJobFailed, markJobRunning, markerStillPresent, sweepCompletedJobs, } from "./agent-queue.js";
 import { expandHome } from "./utils.js";
 // ── Constants ────────────────────────────────────────────────────────────────────
 const MARKER_REGEX = /@agent-(\w+)(?::(\S+))?\s*(.*)/;
 const WRITEBACK_MARKER_REGEX = /<!--\s*pi-dispatch:(\S+)\s*-->/;
 const DEBOUNCE_MS = 1000;
 const MAX_CONCURRENT = 3;
+/** How long to wait after the last new marker before flushing a batch. */
+const BATCH_FLUSH_MS = 2000;
+/** Maximum number of pending jobs in a single role batch before forcing a flush. */
+const BATCH_MAX_SIZE = 6;
 const CONTEXT_LINES = 15;
 const WATCHED_EXTENSIONS = new Set([
     ".txt",
@@ -104,7 +109,7 @@ function isWatchableFile(filePath) {
  * 2. Different role markers create separate groups.
  * 3. Named IDs (e.g., @agent-Miner:customId) force isolation regardless of role.
  */
-export function scanFile(filePath) {
+export function scanFile(filePath, vaultPath) {
     let content;
     try {
         content = fs.readFileSync(filePath, "utf-8");
@@ -176,6 +181,7 @@ export function scanFile(filePath) {
             filePath,
             combinedInstruction,
             dispatchId: generateDispatchId(role),
+            vaultPath,
         });
     }
     return groups;
@@ -253,7 +259,7 @@ export function startWatcher(pi, vaults, state) {
                 clearTimeout(existingTimer);
             const timer = setTimeout(() => {
                 state.debounceTimers.delete(filePath);
-                handleFileChange(pi, filePath, state);
+                handleFileChange(pi, vaultPath, filePath, state);
             }, DEBOUNCE_MS);
             state.debounceTimers.set(filePath, timer);
         });
@@ -280,22 +286,32 @@ export function stopWatcher(state) {
     state.processing.clear();
     console.log("[pi-vault-mind] Watcher stopped.");
 }
-function handleFileChange(pi, filePath, state) {
+function handleFileChange(pi, vaultPath, filePath, state) {
     if (state.processing.has(filePath))
         return;
-    const groups = scanFile(filePath);
+    // Sweep completed jobs before creating new ones
+    sweepCompletedJobs(vaultPath);
+    const groups = scanFile(filePath, vaultPath);
     if (groups.length === 0)
         return;
     state.processing.add(filePath);
     console.log(`[pi-vault-mind] Detected ${groups.length} task group(s) in ${filePath}`);
     // Replace markers with dispatch comments (embeds dispatch ID for writeback)
     markProcessing(filePath, groups, state.activeDispatches_);
-    // Queue the groups for dispatch
+    // Create persistent job records and queue them for batched dispatch
     for (const group of groups) {
+        createJob(vaultPath, {
+            id: group.dispatchId,
+            vaultPath,
+            filePath,
+            role: group.role,
+            agentName: resolveAgentName(group.role),
+            instruction: group.combinedInstruction,
+            markerCount: group.markers.length,
+        });
         state.pendingQueue.push(group);
+        enqueueBatch(pi, vaultPath, group, state);
     }
-    // Process the queue
-    processQueue(pi, state);
 }
 export function processQueue(pi, state) {
     while (state.pendingQueue.length > 0 && state.activeDispatches < state.maxConcurrent) {
@@ -305,9 +321,7 @@ export function processQueue(pi, state) {
         dispatchGroup(pi, group, state);
     }
 }
-function dispatchGroup(pi, group, state) {
-    state.activeDispatches++;
-    const role = group.role;
+const resolveAgentName = (role) => {
     const agentMap = {
         miner: "vault-mind-miner",
         manager: "vault-mind-manager",
@@ -317,11 +331,154 @@ function dispatchGroup(pi, group, state) {
         researcher: "vault-mind-miner",
         podcast: "vault-mind-broadcaster",
     };
-    const agentName = agentMap[role] || `vault-mind-${role}`;
+    return agentMap[role] || `vault-mind-${role}`;
+};
+const batchKey = (vaultPath, role) => `${vaultPath}\u0000${role}`;
+/**
+ * Add a group to the per-vault+role batch buffer. Flushes immediately when
+ * the buffer reaches BATCH_MAX_SIZE, or schedules a flush after BATCH_FLUSH_MS
+ * of inactivity.
+ */
+function enqueueBatch(pi, vaultPath, group, state) {
+    const key = batchKey(vaultPath, group.role);
+    const buffer = state.batchPending.get(key) ?? [];
+    buffer.push(group.dispatchId);
+    state.batchPending.set(key, buffer);
+    if (buffer.length >= BATCH_MAX_SIZE) {
+        flushBatch(pi, key, state);
+        return;
+    }
+    const existing = state.batchTimers.get(key);
+    if (existing)
+        clearTimeout(existing);
+    const timer = setTimeout(() => flushBatch(pi, key, state), BATCH_FLUSH_MS);
+    state.batchTimers.set(key, timer);
+}
+/** Dispatch a combined task for all pending jobs in the same vault+role buffer. */
+function flushBatch(pi, key, state) {
+    const timer = state.batchTimers.get(key);
+    if (timer) {
+        clearTimeout(timer);
+        state.batchTimers.delete(key);
+    }
+    const ids = state.batchPending.get(key);
+    if (!ids || ids.length === 0)
+        return;
+    state.batchPending.delete(key);
+    const firstId = ids[0];
+    if (!firstId)
+        return;
+    // All jobs in the buffer share the same vault+role; use the first to derive.
+    const first = state.pendingQueue.find((g) => g.dispatchId === firstId);
+    if (!first)
+        return;
+    const vaultPath = first.vaultPath;
+    const role = first.role;
+    const agentName = resolveAgentName(role);
+    const groups = ids
+        .map((id) => state.pendingQueue.find((g) => g.dispatchId === id))
+        .filter((g) => g !== undefined);
+    if (groups.length === 0)
+        return;
+    const batchId = `batch-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    markBatchRunning(vaultPath, ids, batchId);
+    state.activeDispatches++;
+    // Build a combined task description that lists every member's file and marker.
+    const memberList = groups
+        .map((g, i) => `${i + 1}. **${g.filePath}** — dispatch id \`${g.dispatchId}\` (${g.markers.length} marker(s))`)
+        .join("\n");
+    const memberInstructions = groups
+        .map((g, i) => `### Task ${i + 1} — ${g.filePath}\n\n${g.combinedInstruction}`)
+        .join("\n\n---\n\n");
+    const writebackInstructions = [
+        "## Result Writeback",
+        "For EACH task above, replace the `<!-- pi-dispatch:DISPATCH_ID -->` marker in its file with a brief summary (1-3 lines, prefixed with `> ` to render as a blockquote).",
+        "",
+        "Example replacement:",
+        "> Extracted 3 entities (PPO, Reward Model, RLHF) and 2 relationships. Stored in LanceDB.",
+    ].join("\n");
+    const taskDescription = [
+        `Batched agent dispatch (${groups.length} task(s)) for @agent-${role}:`,
+        "",
+        memberList,
+        "",
+        "Please dispatch a SINGLE subagent to handle all of them. The subagent must replace every dispatch marker listed above.",
+        "",
+        "```",
+        "subagent({",
+        `  agent: "${agentName}",`,
+        `  task: ${JSON.stringify(`${memberInstructions}\n\n${writebackInstructions}`)},`,
+        `  context: "fork",`,
+        "  async: true,",
+        "})",
+        "```",
+        "",
+        `Batch ID: ${batchId}`,
+        `Agent: ${agentName}`,
+    ].join("\n");
+    try {
+        pi.sendUserMessage(taskDescription, { deliverAs: "followUp" });
+        console.log(`[pi-vault-mind] Dispatched ${agentName} batch (${groups.length} task(s), id=${batchId})`);
+        // Schedule a timeout guard for the whole batch. If any member's marker is
+        // still present after BATCH_TIMEOUT_MS, mark that one failed; others that
+        // completed (marker gone) will be marked done by the sweep.
+        setTimeout(() => {
+            for (const id of ids) {
+                const job = getJob(vaultPath, id);
+                if (!job || job.status !== "running")
+                    continue;
+                if (markerStillPresent(job.filePath, id)) {
+                    markJobFailed(vaultPath, id, "Batch timeout: marker not replaced in time");
+                }
+            }
+        }, 10 * 60 * 1000);
+    }
+    catch (err) {
+        console.error(`[pi-vault-mind] Failed to dispatch ${agentName} batch:`, err.message);
+        for (const id of ids) {
+            markJobFailed(vaultPath, id, `Dispatch error: ${err.message}`);
+        }
+    }
+    finally {
+        state.activeDispatches--;
+        processQueue(pi, state);
+    }
+}
+/** True if the file still contains the dispatch marker for a given job id. */
+const markerStillPresentFor = (filePath, dispatchId) => {
+    try {
+        const content = fs.readFileSync(filePath, "utf-8");
+        return content.includes(`<!-- pi-dispatch:${dispatchId} -->`);
+    }
+    catch {
+        return false;
+    }
+};
+function dispatchGroup(pi, group, state) {
+    state.activeDispatches++;
+    const role = group.role;
+    const agentName = resolveAgentName(role);
     // Update the dispatch record with the resolved agent name
     const record = state.activeDispatches_.get(group.dispatchId);
     if (record)
         record.agentName = agentName;
+    // Persist job as running and schedule a timeout check
+    const vaultPath = group.vaultPath;
+    markJobRunning(vaultPath, group.dispatchId);
+    const timeoutMs = 10 * 60 * 1000; // 10 minutes; subagent long tasks can take a while
+    setTimeout(() => {
+        const job = getJob(vaultPath, group.dispatchId);
+        if (!job || job.status !== "running")
+            return;
+        // If the marker is gone, the subagent completed without us noticing
+        if (!fs.existsSync(job.filePath) ||
+            !fs.readFileSync(job.filePath, "utf-8").includes(`<!-- pi-dispatch:${job.id} -->`)) {
+            markJobDone(vaultPath, job.id);
+        }
+        else {
+            markJobFailed(vaultPath, job.id, "Timeout: subagent did not replace the dispatch marker in time");
+        }
+    }, timeoutMs);
     // Build writeback instructions: tell the subagent exactly how to replace its marker
     const writebackInstructions = [
         "## Result Writeback",
@@ -407,6 +564,8 @@ export function createWatcherState() {
         maxConcurrent: MAX_CONCURRENT,
         activeDispatches: 0,
         pendingQueue: [],
+        batchTimers: new Map(),
+        batchPending: new Map(),
         activeDispatches_: new Map(),
     };
 }