pi-vault-mind 0.16.34 → 0.16.36

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## 0.16.36 — 2026-08-30
+
+### Changed
+
+- **Node 24 runtime floor.** The supported Node.js floor is now `24.19.0+`, matching the current local/runtime toolchain and simplifying support expectations.
+- **GitHub workflows disabled.** The repository no longer runs the generic `ci.yml` or `release-obsidian.yml` automation. Verification and publishing are currently a local operator workflow; the former workflow files are preserved under `.github/workflows-disabled/` for future reuse.
+
+## 0.16.35 — 2026-08-30
+
+### Added
+
+- **Watcher request-block preservation.** The vault watcher no longer destructively replaces `@agent` markers with subagent output. The original request block is preserved in the source note; only the running-status line is updated with a brief completion summary. Requests are reviewable and the vault note remains a faithful record of what was asked.
+- **Reserved `@agent:main` identity.** The `@agent:main` marker is recognized by the watcher but never auto-dispatched to a background subagent. It is reserved for the interactive main session. Use `/vm main sweep [file-or-folder]` to collect pending `@agent:main` markers and address them in the current session.
+- **Stock `system.md` and `AGENTS.md` baseline provisioning.** `pvm setup` provisions vault-local `system.md` (agent system prompt) and vault-root `AGENTS.md` (agent conventions) from curated stock baselines when those files do not already exist, giving every fresh vault a working agent identity without manual authoring. Baselines are demarcated with `<!-- vm:baseline:start/end -->` tags so `/vm personalize` can update only the personalization section without touching the baseline.
+- **`vm_script` tool and run-sdk scaffold.** A sandboxed JavaScript/TypeScript execution tool (`vm_script`) is scaffolded using the `run` QuickJS package. Scripts execute with no ambient filesystem, network, or timer access beyond declared host functions (`vm.*`, `vault.read`, `log`). Enabled by default for manager and main agents. Follow-up: HITL interruption path, `vault.write`, and `pvm run <script>` CLI subcommand.
+
+### Changed
+
+- **docling replaces any2md.** The Miner's document-conversion path (`vm_ingest`) now uses `docling` (via `uvx` or a globally installed `pip install docling`) for PDF, DOCX, HTML, and URL normalization. The `any2md` npm package is no longer a dependency or runtime requirement.
+
+
 ## 0.16.34 — 2026-08-29
 
 ### Added

package/README.md

@@ -12,7 +12,7 @@ Passive Obsidian vault extension for the [pi](https://github.com/mariozechner/pi
 
 ## Features
 
-- **Passive File Watcher** — drop `@agent-Miner`, `@agent-Broadcaster`, etc. in any Obsidian note. Save the file. The watcher detects the marker, groups by role, and dispatches isolated subagent forks (`vault-mind-{role}` agents). No chat pollution, no manual triggers.
+- **Passive File Watcher** — drop `@agent:<role>` (or `@agent-<role>`) markers in any Obsidian note. Save. The watcher detects the marker, groups by role, and dispatches isolated subagent forks. The original request block is preserved in the note; only the running-status line is updated with the result summary. `@agent:main` is reserved for the current interactive session and is never auto-dispatched — sweep it manually with `/vm main sweep`. No chat pollution, no manual triggers.
 - **Multi-Agent Architecture** — five specialist agents under the `vault-mind-{role}` skill naming: **Manager** (interactive orchestrator), **Miner** (research + entity extraction), **Broadcaster** (NotebookLM artifacts), **Heavy-Lifter** (external delegation), **Watcher** (passive file observer).
 - **LanceDB Vector + FTS + Graph** — hybrid semantic + keyword search with automatic entity extraction and BFS graph traversal. All local, no external binaries.
 - **JSONL Source-of-Truth + LanceDB Index** — every fact lives in a durable, human-readable, version-control-friendly `collections/*.jsonl` file. The LanceDB index is derived and rebuildable via `/vm reindex --all --reembed`.
@@ -171,7 +171,7 @@ The Broadcaster agent can generate podcasts, study guides, and slide decks from
 
 ### Prerequisites
 
-- **Node.js** 22.19.0+ (matches `engines` in `package.json`)
+- **Node.js** 24.19.0+ (matches `engines` in `package.json`)
 - **Embedding Provider** — choose one:
   - `@xenova/transformers` — built-in, no external deps (uses all-MiniLM-L6-v2, offline-capable)
   - `ollama` — requires Ollama running locally with `embeddinggemma` (higher quality)
@@ -200,8 +200,10 @@ context, model-routing, task, and subagent extensions inside
 `<vault>/.vault-mind/.pi/agent/`; installs the curated `obsidian-cli`,
 `obsidian-markdown`, `obsidian-bases`, and `json-canvas` skills; and
 merge-safely scaffolds Vault Mind, model-router, and main-agent configuration.
-Existing user configuration, collections, model choices, and `system.md` are
-preserved.
+On first run it also creates stock `.pi/agent/system.md` and vault-root
+`AGENTS.md` baseline regions. All of these are preserved on repeat runs —
+existing user configuration, collections, model choices, and personalizations
+are never overwritten.
 
 Refresh only extensions, tools, and skills without touching vault
 configuration:
@@ -360,16 +362,33 @@ applies no boundary while the persona is `main`.
 ### Use specialist agents without changing the main session
 
 Normally, leave the interactive session on `main` and dispatch specialist work
-through the passive watcher:
+through the passive watcher. Both marker forms are equivalent:
 
 ```text
-@agent-Miner
+@agent:miner
 Research and extract the durable facts from this note.
 ```
 
-The watcher runs that work as an isolated specialist job. It does not turn the
-interactive terminal into the Miner persona. The same distinction applies to
-`@agent-Broadcaster`, `@agent-Manager`, and `@agent-Heavy-Lifter`.
+or
+
+```text
+@agent-miner
+Research and extract the durable facts from this note.
+```
+
+The watcher runs that work as an isolated specialist job, preserving the
+request block in the source note and replacing only the running-status line
+with a result summary. It does not turn the interactive terminal into the
+Miner persona. The same applies to `@agent:broadcaster`, `@agent:manager`,
+and `@agent:heavy-lifter`.
+
+`@agent:main` is reserved for the current interactive session and is never
+auto-dispatched. To sweep reserved markers into the active session:
+
+```text
+/vm main sweep
+/vm main sweep path/to/note.md
+```
 
 ### Explicitly change the interactive persona
 
@@ -535,7 +554,8 @@ belongs in `vaultMind.identities` or an explicit environment override.
 | `vm_describe`   | Introspect schema, count, and sample entries            |
 | `vm_stats`      | Dashboard: counts, sizes, LanceDB status                |
 | `vm_export`     | Export to JSON, CSV, or Markdown                        |
-| `vm_promote`    | Promote entries between collections via pending queue  |
+| `vm_ingest`     | Convert URLs and documents to markdown via docling       |
+| `vm_script`     | Execute sandboxed JS/TS with vm.*, vault.read, log.*    |
 
 ## Commands
 
@@ -555,7 +575,8 @@ belongs in `vaultMind.identities` or an explicit environment override.
 | `/vm embedding status \| use \| model \| models \| pull` | Manage embedding provider |
 | `/vm identity status \| set <role> \| on \| off` | Inspect or explicitly control the interactive agent persona boundary |
 | `/vm remote status \| config \| sync \| jobs \| migrate` | Manage remote embedding + vector sync |
-| `/vm watcher start \| stop \| status` | Manage the passive file watcher                  |
+| `/vm watcher start \| stop \| status` | Manage the passive file watcher        |
+| `/vm main sweep [file]`      | Sweep `@agent:main` markers into the current interactive session |
 | `/vm server status` | Show HTTP server status, port, and uptime |
 
 ## Documentation

package/dist/src/agent-docs.js

@@ -0,0 +1,55 @@
+import * as path from "node:path";
+export const BASELINE_START = "<!-- vm:baseline:start -->";
+export const BASELINE_END = "<!-- vm:baseline:end -->";
+export const PERSONALIZATION_START = "<!-- vm:personalization:start -->";
+export const PERSONALIZATION_END = "<!-- vm:personalization:end -->";
+export const buildDefaultSystemMd = (vaultPath) => {
+    const vaultName = path.basename(vaultPath);
+    return `# Pi main agent: ${vaultName}
+
+${BASELINE_START}
+You are the unrestricted main interactive agent for this vault. Bundled specialist skills are available resources; their presence does not change your active identity. Adopt a specialist identity only when explicitly launched as that subagent.
+
+## Operating baseline
+- Read \`00-system/SYSTEM.md\` first when it exists. If it does not exist, fall back to a vault-root \`SYSTEM.md\`. Then read the vault-root \`AGENTS.md\`.
+- Prefer the vault's own operating manual and schemas over generic assumptions.
+- Use the \`vm_*\` tools, collections, and queue as the durable system of record for agent work.
+- Prefer \`uv\` for Python tools and CLIs. Use \`pnpm\`/\`npm\` for JavaScript and TypeScript packages such as \`run\`.
+- Use \`docling\` for document conversion in ingest flows.
+- Use \`vm_script\` for reusable sandboxed JS/TS workflows when the task fits the approved host-function surface.
+- Never auto-publish, never fabricate facts, and keep human approval at external side effects.
+- The watcher recognizes \`@agent:<role>\` and \`@agent-<role>\` anywhere in watchable files. \`@agent:main\` is reserved for the main interactive flow and is not auto-dispatched.
+${BASELINE_END}
+
+${PERSONALIZATION_START}
+Add vault-specific priorities, domain language, and working preferences here. /vm personalize may update only this section.
+${PERSONALIZATION_END}
+`;
+};
+export const buildDefaultAgentsMd = () => `# AGENTS: pi-vault-mind operating baseline
+
+${BASELINE_START}
+## Agent roles
+- \`main\` — the interactive agent you work with directly.
+- \`manager\` — synthesis, orchestration, and roadmap work.
+- \`miner\` — extraction, ingestion, and structured knowledge capture.
+- \`broadcaster\` — human-facing artifact generation.
+- \`heavy-lifter\` — large-context implementation and deeper delegated work.
+- \`personalization\` — resolves annotated feedback on generated system/agent docs.
+
+## Watcher + inline requests
+- Use \`@agent:<role>\` or \`@agent-<role>\` in watchable files to request agent help.
+- \`@agent:main\` is recognized but never auto-dispatched; it is for main-agent or human-led follow-up.
+- Auto-dispatched watcher jobs preserve the request block in the source note and replace only the running-status line with the result summary.
+- Watcher dispatches should be logged to collections so they can be queried later.
+
+## Tooling baseline
+- Prefer \`uv\` for Python tools.
+- Prefer reusable \`vm_script\` workflows over ad-hoc one-off scripts when the workflow should be repeatable.
+- Keep reusable content, test, and update workflows in skills/tools rather than scattered shell snippets.
+${BASELINE_END}
+
+${PERSONALIZATION_START}
+Add vault-specific agent roster details, domain-specific prompts, and delegation rules here. /vm personalize may update only this section.
+${PERSONALIZATION_END}
+`;

package/dist/src/agent-queue.js

@@ -12,6 +12,7 @@
  */
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { dispatchStatusLine } from "./dispatch-writeback.js";
 import { loadConfig, resolveVaultFile } from "./utils.js";
 const queueSubscribers = new Set();
 /** Subscribe to queue events. Returns an unsubscribe function. */
@@ -138,11 +139,11 @@ export const cancelJob = (vaultPath, id) => {
         return undefined;
     return updateJob(vaultPath, id, "cancelled");
 };
-/** True if the file still contains the dispatch marker for this job. */
+/** True if the file still contains the pending dispatch status placeholder. */
 export const markerStillPresent = (filePath, dispatchId) => {
     try {
         const content = fs.readFileSync(filePath, "utf-8");
-        return content.includes(`<!-- pi-dispatch:${dispatchId} -->`);
+        return content.includes(dispatchStatusLine(dispatchId));
     }
     catch {
         return false;

package/dist/src/agents/BroadcasterAgent.js

@@ -6,6 +6,7 @@
  * Writes output only under Agent/Presentations/.
  */
 import { Agent } from "../agent-bus/Agent.js";
+import { buildDispatchResultLine, dispatchStatusLine } from "../dispatch-writeback.js";
 export class BroadcasterAgent extends Agent {
     taskQueue = null;
     constructor(config, bus, llm) {
@@ -58,8 +59,8 @@ export class BroadcasterAgent extends Agent {
             path: job.filePath,
             edits: [
                 {
-                    oldText: `<!-- pi-dispatch:${job.dispatchId} -->`,
-                    newText: `> Broadcaster completed. See dispatch ${job.dispatchId}.`,
+                    oldText: dispatchStatusLine(job.dispatchId),
+                    newText: buildDispatchResultLine(job.dispatchId, `Broadcaster completed. See dispatch ${job.dispatchId}.`),
                 },
             ],
         });

package/dist/src/agents/HeavyLifterAgent.js

@@ -6,6 +6,7 @@
  * Runs bash in isolated worktree.
  */
 import { Agent } from "../agent-bus/Agent.js";
+import { buildDispatchResultLine, dispatchStatusLine } from "../dispatch-writeback.js";
 export class HeavyLifterAgent extends Agent {
     taskQueue = null;
     constructor(config, bus, llm) {
@@ -61,8 +62,8 @@ export class HeavyLifterAgent extends Agent {
             path: job.filePath,
             edits: [
                 {
-                    oldText: `<!-- pi-dispatch:${job.dispatchId} -->`,
-                    newText: `> Heavy-Lifter completed. See dispatch ${job.dispatchId}.`,
+                    oldText: dispatchStatusLine(job.dispatchId),
+                    newText: buildDispatchResultLine(job.dispatchId, `Heavy-Lifter completed. See dispatch ${job.dispatchId}.`),
                 },
             ],
         });

package/dist/src/agents/ManagerAgent.js

@@ -7,6 +7,7 @@
  * Only the Manager can dispatch subagents and publish to the human-facing vault.
  */
 import { Agent } from "../agent-bus/Agent.js";
+import { buildDispatchResultLine, dispatchStatusLine } from "../dispatch-writeback.js";
 export class ManagerAgent extends Agent {
     taskQueue = null;
     constructor(config, bus, llm) {
@@ -59,8 +60,8 @@ export class ManagerAgent extends Agent {
             path: job.filePath,
             edits: [
                 {
-                    oldText: `<!-- pi-dispatch:${job.dispatchId} -->`,
-                    newText: `> Manager completed. See dispatch ${job.dispatchId}.`,
+                    oldText: dispatchStatusLine(job.dispatchId),
+                    newText: buildDispatchResultLine(job.dispatchId, `Manager completed. See dispatch ${job.dispatchId}.`),
                 },
             ],
         });

package/dist/src/agents/MinerAgent.js

@@ -6,6 +6,7 @@
  * Cannot publish (vm_sync disabled).
  */
 import { Agent } from "../agent-bus/Agent.js";
+import { buildDispatchResultLine, dispatchStatusLine } from "../dispatch-writeback.js";
 export class MinerAgent extends Agent {
     taskQueue = null;
     constructor(config, bus, llm) {
@@ -58,8 +59,8 @@ export class MinerAgent extends Agent {
             path: job.filePath,
             edits: [
                 {
-                    oldText: `<!-- pi-dispatch:${job.dispatchId} -->`,
-                    newText: `> Miner extracted findings. See dispatch ${job.dispatchId}.`,
+                    oldText: dispatchStatusLine(job.dispatchId),
+                    newText: buildDispatchResultLine(job.dispatchId, `Miner extracted findings. See dispatch ${job.dispatchId}.`),
                 },
             ],
         });

package/dist/src/commands.js

@@ -19,11 +19,11 @@ import { scaffoldVaultConfig } from "./scaffold.js";
 import { createServerState, startServer } from "./server.js";
 import { createCollectionWizard, createInjectorWizard, openSettingsDashboard, setupWizard, } from "./settings-ui.js";
 import { getActiveCollection, setActiveCollection } from "./state.js";
+import { createWatcherState, getWatcherStatus, isWatchableFile, scanFile, startWatcher, stopWatcher } from "./watcher.js";
 import { reindexRemote, syncAll, syncCollection } from "./sync.js";
 import { tombstoneEntryById } from "./tombstone.js";
 import { DEFAULT_CONFIG } from "./types.js";
 import { collectionNames, ensureDir, expandHome, findConfig, getConfigPath, getPiContextConfig, hasPiContextTools, isVaultMindReady, loadConfig, resolveVaultMindPaths, } from "./utils.js";
-import { createWatcherState, getWatcherStatus, startWatcher, stopWatcher } from "./watcher.js";
 import { updateActiveCollectionWidget } from "./widget.js";
 // ── Shared helpers ───────────────────────────────────────────────────────────
 const VM_USAGE = [
@@ -51,15 +51,15 @@ const VM_USAGE = [
     "  /vm remote auto            Discover models from the configured Remote URL",
     "  /vm remote sync            Pull server vectors into local LanceDB [--full]",
     "  /vm remote jobs <id>       Poll a remote bulk embed job",
-    "  /vm watcher start          Start passive file watcher",
+    "  /vm watcher start [roles]  Start passive file watcher (optional role allowlist)",
     "  /vm watcher stop           Stop passive file watcher",
     "  /vm watcher status         Show watcher status",
     "  /vm watcher queue [status] Show agent dispatch queue (pending|running|done|failed|cancelled|all)",
     "  /vm watcher retry <id>     Retry a failed or cancelled agent job",
     "  /vm watcher cancel <id>    Cancel a pending agent job",
+    "  /vm main sweep [file]      Sweep @agent:main markers into the current session",
     "  /vm server status          Show HTTP server status + port",
     "  /vm server start           Start the in-process HTTP server",
-    "  /vm personalize            Analyze vault and suggest personality tuning for system.md + AGENTS.md",
     "  /vm setup                  Onboarding flow: config + personalize (auto-uses cwd when it's a vault)",
     "  /vm setup --vault <path>   CLI: set vault path",
     "  /vm setup --remoteUrl <url> CLI: set remote embedding URL",
@@ -1297,6 +1297,90 @@ const handleServer = (args, ctx, pi) => {
     }
     ctx.ui.notify(lines.join("\n"), "info");
 };
+const MAIN_SWEEP_IGNORE_DIRS = {
+    ".git": true,
+    ".obsidian": true,
+    node_modules: true,
+    ".trash": true,
+    __pycache__: true,
+    ".DS_Store": true,
+    ".pi": true,
+    ".lancedb": true,
+};
+const collectSweepFiles = (targetPath) => {
+    const stat = fs.statSync(targetPath);
+    if (stat.isFile())
+        return isWatchableFile(targetPath) ? [targetPath] : [];
+    if (!stat.isDirectory())
+        return [];
+    const files = [];
+    for (const entry of fs.readdirSync(targetPath, { withFileTypes: true })) {
+        if (MAIN_SWEEP_IGNORE_DIRS[entry.name])
+            continue;
+        const child = path.join(targetPath, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...collectSweepFiles(child));
+        }
+        else if (entry.isFile() && isWatchableFile(child)) {
+            files.push(child);
+        }
+    }
+    return files;
+};
+const handleMain = async (args, ctx, pi) => {
+    const parts = args.trim().split(/\s+/g).filter(Boolean);
+    const subcommand = parts[0]?.toLowerCase() || "sweep";
+    if (subcommand !== "sweep") {
+        ctx.ui.notify("Usage: /vm main sweep [file-or-folder]", "error");
+        return;
+    }
+    const configuredVault = loadConfig(ctx.cwd).vaultMind.vaults?.default?.path;
+    const vaultRoot = configuredVault ? expandHome(configuredVault) : ctx.cwd;
+    const targetArg = parts.slice(1).join(" ").trim();
+    const targetPath = targetArg
+        ? path.isAbsolute(targetArg)
+            ? targetArg
+            : path.join(ctx.cwd, targetArg)
+        : vaultRoot;
+    if (!fs.existsSync(targetPath)) {
+        ctx.ui.notify(`Main sweep target not found: ${targetPath}`, "error");
+        return;
+    }
+    const items = collectSweepFiles(targetPath)
+        .flatMap((filePath) => scanFile(filePath, vaultRoot).flatMap((group) => group.role !== "main"
+        ? []
+        : group.markers.map((marker) => ({
+            filePath,
+            lineNumber: marker.lineNumber,
+            instruction: marker.instruction || marker.rawLine.trim(),
+            context: marker.context,
+        }))));
+    if (items.length === 0) {
+        ctx.ui.notify("No unresolved @agent:main markers found.", "info");
+        return;
+    }
+    const prompt = [
+        "# Main Agent Sweep",
+        "",
+        "Review the following inline @agent:main requests. These are reserved for the current interactive main session and are not auto-dispatched.",
+        "Address the requests directly in this session. Keep the source notes intact unless an edit is explicitly needed.",
+        "",
+        ...items.flatMap((item, index) => [
+            `## Item ${index + 1}`,
+            `- File: ${item.filePath}`,
+            `- Line: ${item.lineNumber}`,
+            `- Request: ${item.instruction}`,
+            "",
+            "Context:",
+            "```",
+            item.context,
+            "```",
+            "",
+        ]),
+    ].join("\n");
+    pi.sendMessage({ customType: "vm-main-sweep", content: prompt, display: false }, { triggerTurn: true });
+    ctx.ui.notify(`Sweeping ${items.length} @agent:main item(s) from ${new Set(items.map((item) => item.filePath)).size} file(s).`, "info");
+};
 const handleWatcher = async (args, ctx, pi) => {
     const parts = args.trim().split(/\s+/g);
     const subcommand = parts[0]?.toLowerCase() || "status";
@@ -1316,7 +1400,12 @@ const handleWatcher = async (args, ctx, pi) => {
                 ctx.ui.notify("Watcher is already running.", "info");
                 return;
             }
-            startWatcher(pi, cfg.vaultMind.vaults, watcherState);
+            const requestedRoles = parts
+                .slice(1)
+                .flatMap((part) => part.split(","))
+                .map((role) => role.trim().toLowerCase())
+                .filter(Boolean);
+            startWatcher(pi, cfg.vaultMind.vaults, watcherState, requestedRoles.length > 0 ? requestedRoles : undefined);
             ctx.ui.notify(getWatcherStatus(watcherState), "info");
             return;
         }
@@ -1711,8 +1800,8 @@ export const registerCommands = (pi) => {
                 "embedding",
                 "remote",
                 "watcher",
+                "main",
                 "personalize",
-                "setup",
                 "token",
                 "index",
                 "reindex",
@@ -1741,6 +1830,11 @@ export const registerCommands = (pi) => {
                         .filter((c) => c.startsWith(prefix))
                         .map((c) => ({ label: c, value: c, description: `identity ${c}` }));
                 }
+                if (subcommand === "main") {
+                    return ["sweep"]
+                        .filter((c) => c.startsWith(prefix))
+                        .map((c) => ({ label: c, value: c, description: `main ${c}` }));
+                }
                 if (subcommand === "discover-schema") {
                     return ["--name", "--sample"]
                         .filter((c) => c.startsWith(prefix))
@@ -1825,6 +1919,8 @@ export const registerCommands = (pi) => {
                     return handleServer(rest, ctx, pi);
                 case "watcher":
                     return handleWatcher(rest, ctx, pi);
+                case "main":
+                    return handleMain(rest, ctx, pi);
                 case "remote":
                     return handleModal(rest, ctx, pi);
                 case "personalize":

package/dist/src/dispatch-writeback.js

@@ -0,0 +1,20 @@
+export const dispatchMarker = (dispatchId) => `<!-- pi-dispatch:${dispatchId} -->`;
+export const dispatchStatusLine = (dispatchId) => `> Status [${dispatchId}]: running`;
+const summarizeInstruction = (instruction) => {
+    const trimmed = instruction.trim();
+    return trimmed.length > 0 ? trimmed : "(no instruction provided)";
+};
+export const buildPrimaryDispatchBlock = (dispatchId, role, instructions, markerCount) => {
+    const lines = [dispatchMarker(dispatchId), `> Agent: ${role}`];
+    if (markerCount > 1) {
+        lines.push(`> Grouped markers: ${markerCount}`);
+    }
+    lines.push("> Requests:");
+    for (const instruction of instructions) {
+        lines.push(`> - ${summarizeInstruction(instruction)}`);
+    }
+    lines.push(dispatchStatusLine(dispatchId));
+    return lines.join("\n");
+};
+export const buildJoinedDispatchNote = (dispatchId, role, instruction, lineNumber) => `> Joined dispatch ${dispatchId} (${role}, line ${lineNumber}): ${summarizeInstruction(instruction)}`;
+export const buildDispatchResultLine = (dispatchId, result) => `> Result [${dispatchId}]: ${result}`;

package/dist/src/docling.js

@@ -0,0 +1,43 @@
+import { execFile } 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 execFileAsync = promisify(execFile);
+export const DOCLING_DOC_EXTS = {
+    ".pdf": true,
+    ".docx": true,
+    ".pptx": true,
+    ".xlsx": true,
+    ".epub": true,
+    ".html": true,
+    ".htm": true,
+    ".xml": true,
+};
+const doclingErrorMessage = (error) => error instanceof Error ? error.message : String(error);
+export const sourceNeedsDocling = (source, sourceType) => {
+    if (sourceType === "url")
+        return true;
+    if (sourceType !== "file")
+        return false;
+    return DOCLING_DOC_EXTS[path.extname(source).toLowerCase()] === true;
+};
+export const convertWithDocling = async (source, cwd) => {
+    const outputDir = fs.mkdtempSync(path.join(os.tmpdir(), "pvm-docling-"));
+    try {
+        await execFileAsync("docling", ["convert", source, "--to", "md", "--output", outputDir, "--quiet"], { cwd, timeout: 120000 });
+        const markdownFile = fs
+            .readdirSync(outputDir)
+            .find((file) => path.extname(file).toLowerCase() === ".md");
+        if (!markdownFile) {
+            throw new Error(`docling did not produce a markdown file for ${source}`);
+        }
+        return fs.readFileSync(path.join(outputDir, markdownFile), "utf-8");
+    }
+    catch (error) {
+        throw new Error(`docling failed: ${doclingErrorMessage(error)}`);
+    }
+    finally {
+        fs.rmSync(outputDir, { recursive: true, force: true });
+    }
+};

package/dist/src/engine.js

@@ -217,6 +217,7 @@ export function buildIdentityFromRole(role, id) {
                     "vm_codegraph_impact",
                     "vault_write",
                     "vault_append",
+                    "vm_script",
                 ],
                 writeCollections: ["main", "research", "presentations"],
                 canPublish: true,
@@ -248,6 +249,7 @@ export function buildIdentityFromRole(role, id) {
                     "vm_related",
                     "vm_broken_links",
                     "vm_codegraph_impact",
+                    "vm_script",
                 ],
                 readCollections: ["main"],
                 writeCollections: [],

package/dist/src/personalize.js

@@ -4,6 +4,7 @@ import { parseFrontmatter } from "@earendil-works/pi-coding-agent";
 import { notifyAcmReminder } from "./context-capture.js";
 import { getStatus } from "./lance.js";
 import { scaffoldVaultConfig } from "./scaffold.js";
+import { BASELINE_END, BASELINE_START, PERSONALIZATION_END, PERSONALIZATION_START, buildDefaultAgentsMd, buildDefaultSystemMd, } from "./agent-docs.js";
 import { expandHome, getPersonalizedMarkerPath, hasPiContextTools, isPersonalized, loadConfig, resolveAgentDir, } from "./utils.js";
 class PersonalizationCancelledError extends Error {
     constructor() {
@@ -197,6 +198,8 @@ const buildPrompt = (profile, currentConfig) => {
             },
         ],
     };
+    const seededSystemMd = currentConfig.systemMd ?? buildDefaultSystemMd(profile.vaultPath);
+    const seededAgentsMd = currentConfig.agentsMd ?? buildDefaultAgentsMd();
     const lines = [
         "# Vault Personality Tuning",
         "",
@@ -222,12 +225,12 @@ const buildPrompt = (profile, currentConfig) => {
         "",
         "### .pi/agent/system.md",
         "```markdown",
-        currentConfig.systemMd ?? "(file does not exist)",
+        seededSystemMd,
         "```",
         "",
         "### AGENTS.md",
         "```markdown",
-        currentConfig.agentsMd ?? "(file does not exist)",
+        seededAgentsMd,
         "```",
         "",
         "## Instructions",
@@ -242,6 +245,9 @@ const buildPrompt = (profile, currentConfig) => {
         "- If a file does not currently exist, use action: create.",
         "- If a file exists but needs changes, use action: update and provide the full new content.",
         "- If a file is fine as-is, use action: skip and omit content.",
+        "- Keep all content between the baseline markers unchanged.",
+        `- The baseline markers are: ${BASELINE_START}, ${BASELINE_END}, ${PERSONALIZATION_START}, ${PERSONALIZATION_END}.`,
+        "- Put vault-specific tuning only inside the personalization section.",
         "- Tailor the voice, priorities, and conventions to the vault's domains and tags.",
         "- Keep files concise and actionable.",
     ];

package/dist/src/tool-catalog.js

@@ -46,6 +46,7 @@ const EXTENSION_TOOLS = [
         description: "Promote a pending entry to the main collection",
     },
     { name: "vm_ingest", kind: "vm_data", description: "Ingest content into a vault collection" },
+    { name: "vm_script", kind: "vm_data", description: "Execute sandboxed JS/TS against curated host functions" },
     { name: "vm_export", kind: "vm_data", description: "Export collection data" },
     {
         name: "vm_stats",