@esso0428/pi-subagents 0.15.5 → 0.15.6

package/dist/invocation-config.js

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

package/dist/memory.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * memory.ts — Persistent agent memory: per-agent memory directories that persist across sessions.
  *
@@ -11,26 +10,17 @@
  * is still honored (read + write) when it exists and the new location doesn't,
  * so existing memories aren't orphaned.
  */
-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");
+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";
 /** 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).
  */
-function isUnsafeName(name) {
+export function isUnsafeName(name) {
     if (!name || name.length > 128)
         return true;
     return !/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(name);
@@ -38,9 +28,9 @@ function isUnsafeName(name) {
 /**
  * Returns true if the given path is a symlink (defense against symlink attacks).
  */
-function isSymlink(filePath) {
+export function isSymlink(filePath) {
     try {
-        return (0, node_fs_1.lstatSync)(filePath).isSymbolicLink();
+        return lstatSync(filePath).isSymbolicLink();
     }
     catch {
         return false;
@@ -50,13 +40,13 @@ 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.
  */
-function safeReadFile(filePath) {
-    if (!(0, node_fs_1.existsSync)(filePath))
+export function safeReadFile(filePath) {
+    if (!existsSync(filePath))
         return undefined;
     if (isSymlink(filePath))
         return undefined;
     try {
-        return (0, node_fs_1.readFileSync)(filePath, "utf-8");
+        return readFileSync(filePath, "utf-8");
     }
     catch {
         return undefined;
@@ -66,26 +56,26 @@ function safeReadFile(filePath) {
  * Resolve the memory directory path for a given agent + scope + cwd.
  * Throws if agentName contains path traversal characters.
  */
-function resolveMemoryDir(agentName, scope, cwd) {
+export function resolveMemoryDir(agentName, scope, cwd) {
     if (isUnsafeName(agentName)) {
         throw new Error(`Unsafe agent name for memory directory: "${agentName}"`);
     }
     switch (scope) {
         case "user": {
-            const current = (0, node_path_1.join)((0, pi_coding_agent_1.getAgentDir)(), "agent-memory", agentName);
+            const current = join(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 = (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)) {
+            const legacy = join(homedir(), ".pi", "agent-memory", agentName);
+            if (!existsSync(current) && existsSync(legacy) && !isSymlink(legacy)) {
                 return legacy;
             }
             return current;
         }
         case "project":
-            return (0, node_path_1.join)(cwd, ".pi", "agent-memory", agentName);
+            return join(cwd, ".pi", "agent-memory", agentName);
         case "local":
-            return (0, node_path_1.join)(cwd, ".pi", "agent-memory-local", agentName);
+            return join(cwd, ".pi", "agent-memory-local", agentName);
     }
 }
 /**
@@ -93,25 +83,25 @@ 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.
  */
-function ensureMemoryDir(memoryDir) {
+export function ensureMemoryDir(memoryDir) {
     // If the directory already exists, verify it's not a symlink
-    if ((0, node_fs_1.existsSync)(memoryDir)) {
+    if (existsSync(memoryDir)) {
         if (isSymlink(memoryDir)) {
             throw new Error(`Refusing to use symlinked memory directory: ${memoryDir}`);
         }
         return;
     }
-    (0, node_fs_1.mkdirSync)(memoryDir, { recursive: true });
+    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.
  */
-function readMemoryIndex(memoryDir) {
+export function readMemoryIndex(memoryDir) {
     // Reject symlinked memory directories
     if (isSymlink(memoryDir))
         return undefined;
-    const memoryFile = (0, node_path_1.join)(memoryDir, "MEMORY.md");
+    const memoryFile = join(memoryDir, "MEMORY.md");
     const content = safeReadFile(memoryFile);
     if (content === undefined)
         return undefined;
@@ -125,7 +115,7 @@ 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).
  */
-function buildMemoryBlock(agentName, scope, cwd) {
+export 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);
@@ -138,7 +128,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 ${(0, node_path_1.join)(memoryDir, "MEMORY.md")} to start building persistent memory.`;
+        : `\n\nNo MEMORY.md exists yet. Create one at ${join(memoryDir, "MEMORY.md")} to start building persistent memory.`;
     const instructions = `
 
 ## Memory Instructions
@@ -161,7 +151,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.
  */
-function buildReadOnlyMemoryBlock(agentName, scope, cwd) {
+export 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,15 +1,12 @@
-"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.
  */
-function resolveModel(input, registry) {
+export 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,4 +1,3 @@
-"use strict";
 /**
  * nico-overrides.ts — Read and apply agent overrides from `npm:pi-subagents`-style
  * `settings.json` (`subagents.agentOverrides`).
@@ -17,15 +16,10 @@
  *   [] | false → false  (none)
  *   omitted   → true   (all, fallback)
  */
-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");
+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";
 // ============================================================================
 // Reader
 // ============================================================================
@@ -33,11 +27,11 @@ const agent_types_js_1 = require("./agent-types.js");
  * Read subagents.agentOverrides and subagents.defaultModel from both local
  * and global Nico-style settings.json. Local overrides global on key collision.
  */
-function readNicoAgentOverrides(cwd) {
+export function readNicoAgentOverrides(cwd) {
     const merged = {};
     let defaultModel;
     // Global: ~/.pi/agent/settings.json
-    const globalPath = (0, node_path_1.join)((0, pi_coding_agent_1.getAgentDir)(), "settings.json");
+    const globalPath = join(getAgentDir(), "settings.json");
     const globalSettings = readNicoSettingsFile(globalPath);
     if (globalSettings) {
         mergeOverrides(merged, globalSettings.agentOverrides);
@@ -45,8 +39,8 @@ function readNicoAgentOverrides(cwd) {
             defaultModel = globalSettings.defaultModel;
     }
     // Local: .pi/settings.json
-    const localPath = (0, node_path_1.join)(cwd, ".pi", "settings.json");
-    if ((0, node_fs_1.existsSync)(localPath)) {
+    const localPath = join(cwd, ".pi", "settings.json");
+    if (existsSync(localPath)) {
         const localSettings = readNicoSettingsFile(localPath);
         if (localSettings) {
             mergeOverrides(merged, localSettings.agentOverrides);
@@ -57,10 +51,10 @@ function readNicoAgentOverrides(cwd) {
     return { overrides: merged, defaultModel };
 }
 function readNicoSettingsFile(filePath) {
-    if (!(0, node_fs_1.existsSync)(filePath))
+    if (!existsSync(filePath))
         return undefined;
     try {
-        const raw = JSON.parse((0, node_fs_1.readFileSync)(filePath, "utf-8"));
+        const raw = JSON.parse(readFileSync(filePath, "utf-8"));
         const sub = raw?.subagents;
         if (!sub || typeof sub !== "object")
             return undefined;
@@ -81,7 +75,7 @@ function mergeOverrides(target, source) {
 // ============================================================================
 // Skill converter: Nico string[] → tintinweb true | string[] | false
 // ============================================================================
-function resolveNicoSkills(skills) {
+export function resolveNicoSkills(skills) {
     // Not set → inherit all (tintinweb default)
     if (skills === undefined)
         return true;
@@ -101,7 +95,7 @@ function resolveNicoSkills(skills) {
  * Apply a Nico-style override to an existing tintinweb AgentConfig.
  * JSON values directly overwrite the config (highest priority).
  */
-function applyNicoOverride(agent, override, nicoDefaultModel) {
+export function applyNicoOverride(agent, override, nicoDefaultModel) {
     let modified = false;
     let next = agent;
     // model: explicit override wins; else use defaultModel when agent has none
@@ -141,7 +135,7 @@ function createAgentFromOverride(name, override, defaultModel) {
         description: `Auto-registered from npm:pi-subagents JSON settings`,
         builtinToolNames: override.tools !== undefined
             ? (override.tools === false ? [] : [...override.tools])
-            : [...agent_types_js_1.BUILTIN_TOOL_NAMES],
+            : [...BUILTIN_TOOL_NAMES],
         extensions: true,
         skills: resolveNicoSkills(override.skills),
         model: override.model !== undefined ? (override.model === false ? undefined : override.model) : defaultModel,
@@ -162,7 +156,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.
  */
-function applyNicoOverridesToMap(agents, overrides, defaultModel) {
+export 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,25 +1,19 @@
-"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.
  */
-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");
+import { appendFileSync, chmodSync, mkdirSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "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"
  */
-function encodeCwd(cwd) {
+export function encodeCwd(cwd) {
     return cwd
         .replace(/[/\\]/g, "-") // both separators → dash
         .replace(/^[A-Za-z]:-/, "") // strip Windows drive prefix ("C:-")
@@ -27,25 +21,25 @@ 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 */
-function createOutputFilePath(cwd, agentId, sessionId) {
+export function createOutputFilePath(cwd, agentId, sessionId) {
     const encoded = encodeCwd(cwd);
-    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 });
+    const root = join(tmpdir(), `pi-subagents-${process.getuid?.() ?? 0}`);
+    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 {
-        (0, node_fs_1.chmodSync)(root, 0o700);
+        chmodSync(root, 0o700);
     }
     catch (err) {
         if (process.platform !== "win32")
             throw err;
     }
-    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`);
+    const dir = join(root, encoded, sessionId, "tasks");
+    mkdirSync(dir, { recursive: true });
+    return join(dir, `${agentId}.output`);
 }
 /** Write the initial user prompt entry. */
-function writeInitialEntry(path, agentId, prompt, cwd) {
+export function writeInitialEntry(path, agentId, prompt, cwd) {
     const entry = {
         isSidechain: true,
         agentId,
@@ -54,15 +48,15 @@ function writeInitialEntry(path, agentId, prompt, cwd) {
         timestamp: new Date().toISOString(),
         cwd,
     };
-    (0, node_fs_1.writeFileSync)(path, JSON.stringify(entry) + "\n", "utf-8");
+    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.
  */
-function streamToOutputFile(session, path, agentId, cwd, historyPath) {
-    const outputPaths = historyPath && historyPath !== path ? [path, historyPath] : [path];
+export function streamToOutputFile(session, path, agentId, cwd, historyPath) {
     let writtenCount = 1; // initial user prompt already written
+    const outputPaths = historyPath && historyPath !== path ? [path, historyPath] : [path];
     const flush = () => {
         const messages = session.messages;
         while (writtenCount < messages.length) {
@@ -77,7 +71,7 @@ function streamToOutputFile(session, path, agentId, cwd, historyPath) {
             };
             for (const outputPath of outputPaths) {
                 try {
-                    (0, node_fs_1.appendFileSync)(outputPath, JSON.stringify(entry) + "\n", "utf-8");
+                    appendFileSync(outputPath, JSON.stringify(entry) + "\n", "utf-8");
                 }
                 catch { /* ignore write errors */ }
             }

package/dist/prompts.js

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

package/dist/schedule.js

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