@esso0428/pi-subagents 0.15.0 → 0.15.2

package/dist/invocation-config.js

@@ -1,4 +1,8 @@
-export function resolveAgentInvocationConfig(agentConfig, params) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveAgentInvocationConfig = resolveAgentInvocationConfig;
+exports.resolveJoinMode = resolveJoinMode;
+function resolveAgentInvocationConfig(agentConfig, params) {
     return {
         modelInput: agentConfig?.model ?? params.model,
         modelFromParams: agentConfig?.model == null && params.model != null,
@@ -10,6 +14,6 @@ export function resolveAgentInvocationConfig(agentConfig, params) {
         isolation: agentConfig?.isolation ?? params.isolation,
     };
 }
-export function resolveJoinMode(defaultJoinMode, runInBackground) {
+function resolveJoinMode(defaultJoinMode, runInBackground) {
     return runInBackground ? defaultJoinMode : undefined;
 }

package/dist/memory.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * memory.ts — Persistent agent memory: per-agent memory directories that persist across sessions.
  *
@@ -10,17 +11,26 @@
  * is still honored (read + write) when it exists and the new location doesn't,
  * so existing memories aren't orphaned.
  */
-import { existsSync, lstatSync, mkdirSync, readFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join, } from "node:path";
-import { getAgentDir } from "@earendil-works/pi-coding-agent";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isUnsafeName = isUnsafeName;
+exports.isSymlink = isSymlink;
+exports.safeReadFile = safeReadFile;
+exports.resolveMemoryDir = resolveMemoryDir;
+exports.ensureMemoryDir = ensureMemoryDir;
+exports.readMemoryIndex = readMemoryIndex;
+exports.buildMemoryBlock = buildMemoryBlock;
+exports.buildReadOnlyMemoryBlock = buildReadOnlyMemoryBlock;
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const pi_coding_agent_1 = require("@earendil-works/pi-coding-agent");
 /** Maximum lines to read from MEMORY.md */
 const MAX_MEMORY_LINES = 200;
 /**
  * Returns true if a name contains characters not allowed in agent/skill names.
  * Uses a whitelist: only alphanumeric, hyphens, underscores, and dots (no leading dot).
  */
-export function isUnsafeName(name) {
+function isUnsafeName(name) {
     if (!name || name.length > 128)
         return true;
     return !/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(name);
@@ -28,9 +38,9 @@ export function isUnsafeName(name) {
 /**
  * Returns true if the given path is a symlink (defense against symlink attacks).
  */
-export function isSymlink(filePath) {
+function isSymlink(filePath) {
     try {
-        return lstatSync(filePath).isSymbolicLink();
+        return (0, node_fs_1.lstatSync)(filePath).isSymbolicLink();
     }
     catch {
         return false;
@@ -40,13 +50,13 @@ export function isSymlink(filePath) {
  * Safely read a file, rejecting symlinks.
  * Returns undefined if the file doesn't exist, is a symlink, or can't be read.
  */
-export function safeReadFile(filePath) {
-    if (!existsSync(filePath))
+function safeReadFile(filePath) {
+    if (!(0, node_fs_1.existsSync)(filePath))
         return undefined;
     if (isSymlink(filePath))
         return undefined;
     try {
-        return readFileSync(filePath, "utf-8");
+        return (0, node_fs_1.readFileSync)(filePath, "utf-8");
     }
     catch {
         return undefined;
@@ -56,26 +66,26 @@ export function safeReadFile(filePath) {
  * Resolve the memory directory path for a given agent + scope + cwd.
  * Throws if agentName contains path traversal characters.
  */
-export function resolveMemoryDir(agentName, scope, cwd) {
+function resolveMemoryDir(agentName, scope, cwd) {
     if (isUnsafeName(agentName)) {
         throw new Error(`Unsafe agent name for memory directory: "${agentName}"`);
     }
     switch (scope) {
         case "user": {
-            const current = join(getAgentDir(), "agent-memory", agentName);
+            const current = (0, node_path_1.join)((0, pi_coding_agent_1.getAgentDir)(), "agent-memory", agentName);
             // Legacy location from when this path was hardcoded. Keep using it if it
             // already holds this agent's memory and the new location hasn't been
             // created yet — otherwise existing memories would be silently orphaned.
-            const legacy = join(homedir(), ".pi", "agent-memory", agentName);
-            if (!existsSync(current) && existsSync(legacy) && !isSymlink(legacy)) {
+            const legacy = (0, node_path_1.join)((0, node_os_1.homedir)(), ".pi", "agent-memory", agentName);
+            if (!(0, node_fs_1.existsSync)(current) && (0, node_fs_1.existsSync)(legacy) && !isSymlink(legacy)) {
                 return legacy;
             }
             return current;
         }
         case "project":
-            return join(cwd, ".pi", "agent-memory", agentName);
+            return (0, node_path_1.join)(cwd, ".pi", "agent-memory", agentName);
         case "local":
-            return join(cwd, ".pi", "agent-memory-local", agentName);
+            return (0, node_path_1.join)(cwd, ".pi", "agent-memory-local", agentName);
     }
 }
 /**
@@ -83,25 +93,25 @@ export function resolveMemoryDir(agentName, scope, cwd) {
  * Refuses to create directories if any component in the path is a symlink
  * to prevent symlink-based directory traversal attacks.
  */
-export function ensureMemoryDir(memoryDir) {
+function ensureMemoryDir(memoryDir) {
     // If the directory already exists, verify it's not a symlink
-    if (existsSync(memoryDir)) {
+    if ((0, node_fs_1.existsSync)(memoryDir)) {
         if (isSymlink(memoryDir)) {
             throw new Error(`Refusing to use symlinked memory directory: ${memoryDir}`);
         }
         return;
     }
-    mkdirSync(memoryDir, { recursive: true });
+    (0, node_fs_1.mkdirSync)(memoryDir, { recursive: true });
 }
 /**
  * Read the first N lines of MEMORY.md from the memory directory, if it exists.
  * Returns undefined if no MEMORY.md exists or if the path is a symlink.
  */
-export function readMemoryIndex(memoryDir) {
+function readMemoryIndex(memoryDir) {
     // Reject symlinked memory directories
     if (isSymlink(memoryDir))
         return undefined;
-    const memoryFile = join(memoryDir, "MEMORY.md");
+    const memoryFile = (0, node_path_1.join)(memoryDir, "MEMORY.md");
     const content = safeReadFile(memoryFile);
     if (content === undefined)
         return undefined;
@@ -115,7 +125,7 @@ export function readMemoryIndex(memoryDir) {
  * Build the memory block to inject into the agent's system prompt.
  * Also ensures the memory directory exists (creates it if needed).
  */
-export function buildMemoryBlock(agentName, scope, cwd) {
+function buildMemoryBlock(agentName, scope, cwd) {
     const memoryDir = resolveMemoryDir(agentName, scope, cwd);
     // Create the memory directory so the agent can immediately write to it
     ensureMemoryDir(memoryDir);
@@ -128,7 +138,7 @@ Memory scope: ${scope}
 This memory persists across sessions. Use it to build up knowledge over time.`;
     const memoryContent = existingMemory
         ? `\n\n## Current MEMORY.md\n${existingMemory}`
-        : `\n\nNo MEMORY.md exists yet. Create one at ${join(memoryDir, "MEMORY.md")} to start building persistent memory.`;
+        : `\n\nNo MEMORY.md exists yet. Create one at ${(0, node_path_1.join)(memoryDir, "MEMORY.md")} to start building persistent memory.`;
     const instructions = `
 
 ## Memory Instructions
@@ -151,7 +161,7 @@ This memory persists across sessions. Use it to build up knowledge over time.`;
  * Build a read-only memory block for agents that lack write/edit tools.
  * Does NOT create the memory directory — agents can only consume existing memory.
  */
-export function buildReadOnlyMemoryBlock(agentName, scope, cwd) {
+function buildReadOnlyMemoryBlock(agentName, scope, cwd) {
     const memoryDir = resolveMemoryDir(agentName, scope, cwd);
     const existingMemory = readMemoryIndex(memoryDir);
     const header = `# Agent Memory (read-only)

package/dist/model-resolver.js

@@ -1,12 +1,15 @@
+"use strict";
 /**
  * Model resolution: exact match ("provider/modelId") with fuzzy fallback.
  */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveModel = resolveModel;
 /**
  * Resolve a model string to a Model instance.
  * Tries exact match first ("provider/modelId"), then fuzzy match against all available models.
  * Returns the Model on success, or an error message string on failure.
  */
-export function resolveModel(input, registry) {
+function resolveModel(input, registry) {
     // Available models (those with auth configured)
     const all = (registry.getAvailable?.() ?? registry.getAll());
     const availableSet = new Set(all.map(m => `${m.provider}/${m.id}`.toLowerCase()));

package/dist/nico-overrides.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * nico-overrides.ts — Read and apply agent overrides from `npm:pi-subagents`-style
  * `settings.json` (`subagents.agentOverrides`).
@@ -16,10 +17,15 @@
  *   [] | false → false  (none)
  *   omitted   → true   (all, fallback)
  */
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import { getAgentDir } from "@earendil-works/pi-coding-agent";
-import { BUILTIN_TOOL_NAMES } from "./agent-types.js";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readNicoAgentOverrides = readNicoAgentOverrides;
+exports.resolveNicoSkills = resolveNicoSkills;
+exports.applyNicoOverride = applyNicoOverride;
+exports.applyNicoOverridesToMap = applyNicoOverridesToMap;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const pi_coding_agent_1 = require("@earendil-works/pi-coding-agent");
+const agent_types_js_1 = require("./agent-types.js");
 // ============================================================================
 // Reader
 // ============================================================================
@@ -27,11 +33,11 @@ import { BUILTIN_TOOL_NAMES } from "./agent-types.js";
  * Read subagents.agentOverrides and subagents.defaultModel from both local
  * and global Nico-style settings.json. Local overrides global on key collision.
  */
-export function readNicoAgentOverrides(cwd) {
+function readNicoAgentOverrides(cwd) {
     const merged = {};
     let defaultModel;
     // Global: ~/.pi/agent/settings.json
-    const globalPath = join(getAgentDir(), "settings.json");
+    const globalPath = (0, node_path_1.join)((0, pi_coding_agent_1.getAgentDir)(), "settings.json");
     const globalSettings = readNicoSettingsFile(globalPath);
     if (globalSettings) {
         mergeOverrides(merged, globalSettings.agentOverrides);
@@ -39,8 +45,8 @@ export function readNicoAgentOverrides(cwd) {
             defaultModel = globalSettings.defaultModel;
     }
     // Local: .pi/settings.json
-    const localPath = join(cwd, ".pi", "settings.json");
-    if (existsSync(localPath)) {
+    const localPath = (0, node_path_1.join)(cwd, ".pi", "settings.json");
+    if ((0, node_fs_1.existsSync)(localPath)) {
         const localSettings = readNicoSettingsFile(localPath);
         if (localSettings) {
             mergeOverrides(merged, localSettings.agentOverrides);
@@ -51,10 +57,10 @@ export function readNicoAgentOverrides(cwd) {
     return { overrides: merged, defaultModel };
 }
 function readNicoSettingsFile(filePath) {
-    if (!existsSync(filePath))
+    if (!(0, node_fs_1.existsSync)(filePath))
         return undefined;
     try {
-        const raw = JSON.parse(readFileSync(filePath, "utf-8"));
+        const raw = JSON.parse((0, node_fs_1.readFileSync)(filePath, "utf-8"));
         const sub = raw?.subagents;
         if (!sub || typeof sub !== "object")
             return undefined;
@@ -75,7 +81,7 @@ function mergeOverrides(target, source) {
 // ============================================================================
 // Skill converter: Nico string[] → tintinweb true | string[] | false
 // ============================================================================
-export function resolveNicoSkills(skills) {
+function resolveNicoSkills(skills) {
     // Not set → inherit all (tintinweb default)
     if (skills === undefined)
         return true;
@@ -95,7 +101,7 @@ export function resolveNicoSkills(skills) {
  * Apply a Nico-style override to an existing tintinweb AgentConfig.
  * JSON values directly overwrite the config (highest priority).
  */
-export function applyNicoOverride(agent, override, nicoDefaultModel) {
+function applyNicoOverride(agent, override, nicoDefaultModel) {
     let modified = false;
     let next = agent;
     // model: explicit override wins; else use defaultModel when agent has none
@@ -135,7 +141,7 @@ function createAgentFromOverride(name, override, defaultModel) {
         description: `Auto-registered from npm:pi-subagents JSON settings`,
         builtinToolNames: override.tools !== undefined
             ? (override.tools === false ? [] : [...override.tools])
-            : [...BUILTIN_TOOL_NAMES],
+            : [...agent_types_js_1.BUILTIN_TOOL_NAMES],
         extensions: true,
         skills: resolveNicoSkills(override.skills),
         model: override.model !== undefined ? (override.model === false ? undefined : override.model) : defaultModel,
@@ -156,7 +162,7 @@ function createAgentFromOverride(name, override, defaultModel) {
  * Apply all Nico overrides to a map of agents (mutating in-place).
  * Agents that don't exist yet are auto-registered from the override.
  */
-export function applyNicoOverridesToMap(agents, overrides, defaultModel) {
+function applyNicoOverridesToMap(agents, overrides, defaultModel) {
     for (const [name, override] of Object.entries(overrides)) {
         const existing = agents.get(name);
         if (existing) {

package/dist/output-file.js

@@ -1,19 +1,25 @@
+"use strict";
 /**
  * output-file.ts — Streaming JSONL output file for agent transcripts.
  *
  * Creates a per-agent output file that streams conversation turns as JSONL,
  * matching Claude Code's task output file format.
  */
-import { appendFileSync, chmodSync, mkdirSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeCwd = encodeCwd;
+exports.createOutputFilePath = createOutputFilePath;
+exports.writeInitialEntry = writeInitialEntry;
+exports.streamToOutputFile = streamToOutputFile;
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
 /**
  * Encode a cwd path as a filesystem-safe directory name. Handles:
  *   - POSIX:   "/home/user/project"        → "home-user-project"
  *   - Windows: "C:\Users\foo\project"      → "Users-foo-project"
  *   - UNC:     "\\\\server\\share\\project"  → "server-share-project"
  */
-export function encodeCwd(cwd) {
+function encodeCwd(cwd) {
     return cwd
         .replace(/[/\\]/g, "-") // both separators → dash
         .replace(/^[A-Za-z]:-/, "") // strip Windows drive prefix ("C:-")
@@ -21,25 +27,25 @@ export function encodeCwd(cwd) {
 }
 /** Create the output file path, ensuring the directory exists.
  *  Mirrors Claude Code's layout: /tmp/{prefix}-{uid}/{encoded-cwd}/{sessionId}/tasks/{agentId}.output */
-export function createOutputFilePath(cwd, agentId, sessionId) {
+function createOutputFilePath(cwd, agentId, sessionId) {
     const encoded = encodeCwd(cwd);
-    const root = join(tmpdir(), `pi-subagents-${process.getuid?.() ?? 0}`);
-    mkdirSync(root, { recursive: true, mode: 0o700 });
+    const root = (0, node_path_1.join)((0, node_os_1.tmpdir)(), `pi-subagents-${process.getuid?.() ?? 0}`);
+    (0, node_fs_1.mkdirSync)(root, { recursive: true, mode: 0o700 });
     // chmod is a no-op on Windows and throws on some Windows filesystems.
     // On Unix we still want to enforce 0o700 past umask, so only swallow on Windows.
     try {
-        chmodSync(root, 0o700);
+        (0, node_fs_1.chmodSync)(root, 0o700);
     }
     catch (err) {
         if (process.platform !== "win32")
             throw err;
     }
-    const dir = join(root, encoded, sessionId, "tasks");
-    mkdirSync(dir, { recursive: true });
-    return join(dir, `${agentId}.output`);
+    const dir = (0, node_path_1.join)(root, encoded, sessionId, "tasks");
+    (0, node_fs_1.mkdirSync)(dir, { recursive: true });
+    return (0, node_path_1.join)(dir, `${agentId}.output`);
 }
 /** Write the initial user prompt entry. */
-export function writeInitialEntry(path, agentId, prompt, cwd) {
+function writeInitialEntry(path, agentId, prompt, cwd) {
     const entry = {
         isSidechain: true,
         agentId,
@@ -48,13 +54,13 @@ export function writeInitialEntry(path, agentId, prompt, cwd) {
         timestamp: new Date().toISOString(),
         cwd,
     };
-    writeFileSync(path, JSON.stringify(entry) + "\n", "utf-8");
+    (0, node_fs_1.writeFileSync)(path, JSON.stringify(entry) + "\n", "utf-8");
 }
 /**
  * Subscribe to session events and flush new messages to the output file on each turn_end.
  * Returns a cleanup function that does a final flush and unsubscribes.
  */
-export function streamToOutputFile(session, path, agentId, cwd) {
+function streamToOutputFile(session, path, agentId, cwd) {
     let writtenCount = 1; // initial user prompt already written
     const flush = () => {
         const messages = session.messages;
@@ -69,7 +75,7 @@ export function streamToOutputFile(session, path, agentId, cwd) {
                 cwd,
             };
             try {
-                appendFileSync(path, JSON.stringify(entry) + "\n", "utf-8");
+                (0, node_fs_1.appendFileSync)(path, JSON.stringify(entry) + "\n", "utf-8");
             }
             catch { /* ignore write errors */ }
             writtenCount++;

package/dist/prompts.js

@@ -1,6 +1,9 @@
+"use strict";
 /**
  * prompts.ts — System prompt builder for agents.
  */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildAgentPrompt = buildAgentPrompt;
 /**
  * Build the system prompt for an agent from its config.
  *
@@ -18,7 +21,7 @@
  * @param parentSystemPrompt  The parent agent's effective system prompt (for append mode).
  * @param extras  Optional extra sections to inject (memory, preloaded skills).
  */
-export function buildAgentPrompt(config, cwd, env, parentSystemPrompt, extras) {
+function buildAgentPrompt(config, cwd, env, parentSystemPrompt, extras) {
     const activeAgentTag = `<active_agent name="${config.name}"/>\n\n`;
     const envBlock = `# Environment
 Working directory: ${cwd}

package/dist/schedule-store.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * schedule-store.ts — File-backed store for scheduled subagents.
  *
@@ -9,8 +10,11 @@
  * mutation acquires a PID-based exclusion lock, re-reads the latest state
  * from disk, applies the change, atomic-writes via temp+rename, releases.
  */
-import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScheduleStore = void 0;
+exports.resolveStorePath = resolveStorePath;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
 const LOCK_RETRY_MS = 50;
 const LOCK_MAX_RETRIES = 100;
 function isProcessRunning(pid) {
@@ -25,15 +29,15 @@ function isProcessRunning(pid) {
 function acquireLock(lockPath) {
     for (let i = 0; i < LOCK_MAX_RETRIES; i++) {
         try {
-            writeFileSync(lockPath, `${process.pid}`, { flag: "wx" });
+            (0, node_fs_1.writeFileSync)(lockPath, `${process.pid}`, { flag: "wx" });
             return;
         }
         catch (e) {
             if (e.code === "EEXIST") {
                 try {
-                    const pid = parseInt(readFileSync(lockPath, "utf-8"), 10);
+                    const pid = parseInt((0, node_fs_1.readFileSync)(lockPath, "utf-8"), 10);
                     if (pid && !isProcessRunning(pid)) {
-                        unlinkSync(lockPath);
+                        (0, node_fs_1.unlinkSync)(lockPath);
                         continue;
                     }
                 }
@@ -49,15 +53,15 @@ function acquireLock(lockPath) {
 }
 function releaseLock(lockPath) {
     try {
-        unlinkSync(lockPath);
+        (0, node_fs_1.unlinkSync)(lockPath);
     }
     catch { /* ignore */ }
 }
 /** Resolve the storage path for a session-scoped store. */
-export function resolveStorePath(cwd, sessionId) {
-    return join(cwd, ".pi", "subagent-schedules", `${sessionId}.json`);
+function resolveStorePath(cwd, sessionId) {
+    return (0, node_path_1.join)(cwd, ".pi", "subagent-schedules", `${sessionId}.json`);
 }
-export class ScheduleStore {
+class ScheduleStore {
     filePath;
     lockPath;
     jobs = new Map();
@@ -68,14 +72,14 @@ export class ScheduleStore {
     }
     /** Create the backing directory lazily — only when we're about to persist. */
     ensureDir() {
-        mkdirSync(dirname(this.filePath), { recursive: true });
+        (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(this.filePath), { recursive: true });
     }
     /** Load from disk into the in-memory cache. Silent on parse errors. */
     load() {
-        if (!existsSync(this.filePath))
+        if (!(0, node_fs_1.existsSync)(this.filePath))
             return;
         try {
-            const data = JSON.parse(readFileSync(this.filePath, "utf-8"));
+            const data = JSON.parse((0, node_fs_1.readFileSync)(this.filePath, "utf-8"));
             this.jobs.clear();
             for (const j of data.jobs ?? [])
                 this.jobs.set(j.id, j);
@@ -86,8 +90,8 @@ export class ScheduleStore {
     save() {
         const data = { version: 1, jobs: [...this.jobs.values()] };
         const tmp = this.filePath + ".tmp";
-        writeFileSync(tmp, JSON.stringify(data, null, 2));
-        renameSync(tmp, this.filePath);
+        (0, node_fs_1.writeFileSync)(tmp, JSON.stringify(data, null, 2));
+        (0, node_fs_1.renameSync)(tmp, this.filePath);
     }
     /** Acquire lock → reload → mutate → save → release. */
     withLock(fn) {
@@ -145,11 +149,12 @@ export class ScheduleStore {
     }
     /** Delete the backing file (used when no jobs remain, optional cleanup). */
     deleteFileIfEmpty() {
-        if (this.jobs.size === 0 && existsSync(this.filePath)) {
+        if (this.jobs.size === 0 && (0, node_fs_1.existsSync)(this.filePath)) {
             try {
-                unlinkSync(this.filePath);
+                (0, node_fs_1.unlinkSync)(this.filePath);
             }
             catch { /* ignore */ }
         }
     }
 }
+exports.ScheduleStore = ScheduleStore;

package/dist/schedule.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * schedule.ts — `SubagentScheduler`: timer-driven dispatcher of scheduled subagents.
  *
@@ -14,10 +15,12 @@
  *   - Result delivery is implicit: spawn → background completion → existing
  *     `subagent-notification` followUp path. No new delivery code.
  */
-import { Cron } from "croner";
-import { nanoid } from "nanoid";
-import { resolveModel } from "./model-resolver.js";
-export class SubagentScheduler {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubagentScheduler = void 0;
+const croner_1 = require("croner");
+const nanoid_1 = require("nanoid");
+const model_resolver_js_1 = require("./model-resolver.js");
+class SubagentScheduler {
     jobs = new Map();
     intervals = new Map();
     store;
@@ -62,7 +65,7 @@ export class SubagentScheduler {
     buildJob(input) {
         const detected = SubagentScheduler.detectSchedule(input.schedule);
         return {
-            id: nanoid(10),
+            id: (0, nanoid_1.nanoid)(10),
             name: input.name,
             description: input.description,
             schedule: detected.normalized,
@@ -165,7 +168,7 @@ export class SubagentScheduler {
                 }
             }
             else {
-                const cron = new Cron(job.schedule, () => this.executeJob(job.id));
+                const cron = new croner_1.Cron(job.schedule, () => this.executeJob(job.id));
                 this.jobs.set(job.id, cron);
             }
         }
@@ -207,7 +210,7 @@ export class SubagentScheduler {
         // if resolution fails; the spawn path handles undefined model gracefully.
         let resolvedModel;
         if (job.model) {
-            const r = resolveModel(job.model, ctx.modelRegistry);
+            const r = (0, model_resolver_js_1.resolveModel)(job.model, ctx.modelRegistry);
             if (typeof r !== "string")
                 resolvedModel = r;
         }
@@ -313,7 +316,7 @@ export class SubagentScheduler {
         }
         try {
             // Croner validates by construction.
-            new Cron(expr, () => { });
+            new croner_1.Cron(expr, () => { });
             return { valid: true };
         }
         catch (e) {
@@ -336,3 +339,4 @@ export class SubagentScheduler {
         return parseInt(m[1], 10) * { s: 1000, m: 60_000, h: 3_600_000, d: 86_400_000 }[m[2]];
     }
 }
+exports.SubagentScheduler = SubagentScheduler;

package/dist/settings.js

@@ -1,9 +1,17 @@
+"use strict";
 // Persistence for pi-subagents operational settings.
 // - Global:  ~/.pi/agent/subagents.json (via getAgentDir()) — manual defaults, never written here
 // - Project: <cwd>/.pi/subagents.json — written by /agents → Settings; overrides global on load
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { getAgentDir } from "@earendil-works/pi-coding-agent";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadSettings = loadSettings;
+exports.saveSettings = saveSettings;
+exports.applySettings = applySettings;
+exports.persistToastFor = persistToastFor;
+exports.applyAndEmitLoaded = applyAndEmitLoaded;
+exports.saveAndEmitChanged = saveAndEmitChanged;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const pi_coding_agent_1 = require("@earendil-works/pi-coding-agent");
 const VALID_JOIN_MODES = new Set(["async", "group", "smart"]);
 const VALID_TOOL_DESCRIPTION_MODES = new Set(["full", "compact", "custom"]);
 const VALID_WIDGET_MODES = new Set(["all", "background", "off"]);
@@ -61,10 +69,10 @@ function sanitize(raw) {
     return out;
 }
 function globalPath() {
-    return join(getAgentDir(), "subagents.json");
+    return (0, node_path_1.join)((0, pi_coding_agent_1.getAgentDir)(), "subagents.json");
 }
 function projectPath(cwd) {
-    return join(cwd, ".pi", "subagents.json");
+    return (0, node_path_1.join)(cwd, ".pi", "subagents.json");
 }
 /**
  * Read a settings file. Missing file is silent (returns `{}`). A file that
@@ -72,10 +80,10 @@ function projectPath(cwd) {
  * silently reverted to defaults — and still returns `{}` so startup proceeds.
  */
 function readSettingsFile(path) {
-    if (!existsSync(path))
+    if (!(0, node_fs_1.existsSync)(path))
         return {};
     try {
-        return sanitize(JSON.parse(readFileSync(path, "utf-8")));
+        return sanitize(JSON.parse((0, node_fs_1.readFileSync)(path, "utf-8")));
     }
     catch (err) {
         const reason = err instanceof Error ? err.message : String(err);
@@ -84,7 +92,7 @@ function readSettingsFile(path) {
     }
 }
 /** Load merged settings: global provides defaults, project overrides. */
-export function loadSettings(cwd = process.cwd()) {
+function loadSettings(cwd = process.cwd()) {
     return { ...readSettingsFile(globalPath()), ...readSettingsFile(projectPath(cwd)) };
 }
 /**
@@ -92,11 +100,11 @@ export function loadSettings(cwd = process.cwd()) {
  * Returns `true` on success, `false` if the write (or mkdir) failed so the
  * caller can surface a warning — persistence isn't fatal but isn't silent.
  */
-export function saveSettings(s, cwd = process.cwd()) {
+function saveSettings(s, cwd = process.cwd()) {
     const path = projectPath(cwd);
     try {
-        mkdirSync(dirname(path), { recursive: true });
-        writeFileSync(path, JSON.stringify(s, null, 2), "utf-8");
+        (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(path), { recursive: true });
+        (0, node_fs_1.writeFileSync)(path, JSON.stringify(s, null, 2), "utf-8");
         return true;
     }
     catch {
@@ -104,7 +112,7 @@ export function saveSettings(s, cwd = process.cwd()) {
     }
 }
 /** Apply persisted settings to the in-memory state via caller-supplied setters. */
-export function applySettings(s, appliers) {
+function applySettings(s, appliers) {
     if (typeof s.maxConcurrent === "number")
         appliers.setMaxConcurrent(s.maxConcurrent);
     if (typeof s.defaultMaxTurns === "number")
@@ -133,7 +141,7 @@ export function applySettings(s, appliers) {
  * routes the success/failure of `saveSettings` into the right message + level
  * so the UI layer (index.ts) stays a thin wire between input and notification.
  */
-export function persistToastFor(successMsg, persisted) {
+function persistToastFor(successMsg, persisted) {
     return persisted
         ? { message: successMsg, level: "info" }
         : { message: `${successMsg} (session only; failed to persist)`, level: "warning" };
@@ -143,7 +151,7 @@ export function persistToastFor(successMsg, persisted) {
  * `subagents:settings_loaded` lifecycle event. Returns the loaded settings so
  * callers can log/inspect. Extension init wires this once.
  */
-export function applyAndEmitLoaded(appliers, emit, cwd = process.cwd()) {
+function applyAndEmitLoaded(appliers, emit, cwd = process.cwd()) {
     const settings = loadSettings(cwd);
     applySettings(settings, appliers);
     emit("subagents:settings_loaded", { settings });
@@ -155,7 +163,7 @@ export function applyAndEmitLoaded(appliers, emit, cwd = process.cwd()) {
  * return the toast the UI should display. Event payload carries the `persisted`
  * flag so listeners can react to write failures.
  */
-export function saveAndEmitChanged(snapshot, successMsg, emit, cwd = process.cwd()) {
+function saveAndEmitChanged(snapshot, successMsg, emit, cwd = process.cwd()) {
     const persisted = saveSettings(snapshot, cwd);
     emit("subagents:settings_changed", { settings: snapshot, persisted });
     return persistToastFor(successMsg, persisted);