palmier 0.8.1 → 0.8.4

package/dist/commands/run.js

@@ -10,16 +10,13 @@ import { getPlatform } from "../platform/index.js";
 import { TASK_SUCCESS_MARKER, TASK_FAILURE_MARKER, TASK_REPORT_PREFIX, TASK_PERMISSION_PREFIX } from "../agents/shared-prompt.js";
 import { publishHostEvent } from "../events.js";
 /**
- * Invoke the agent CLI with a continuation loop for permissions and user input.
- *
- * Both standard and command-triggered execution use this.
- * The `invokeTask` is the ParsedTask whose prompt is passed to the agent
- * (for command-triggered mode this is the per-line augmented task).
+ * Invoke the agent CLI in a continuation loop to handle permission requests.
+ * `invokeTask` is the ParsedTask whose prompt is passed to the agent (in
+ * command-triggered mode this is the per-line augmented task).
  */
 async function invokeAgentWithRetries(ctx, invokeTask) {
     // eslint-disable-next-line no-constant-condition
     while (true) {
-        // Stream agent output to TASKRUN.md in real-time, throttled to 500ms
         const writer = beginStreamingMessage(ctx.taskDir, ctx.runId, Date.now());
         let lineBuf = "";
         let notifyPending = false;
@@ -56,11 +53,9 @@ async function invokeAgentWithRetries(ctx, invokeTask) {
         const outcome = result.exitCode !== 0 ? "failed" : parseTaskOutcome(result.output);
         const reportFiles = parseReportFiles(result.output);
         const requiredPermissions = parsePermissions(result.output);
-        // Flush remaining buffered content
         if (lineBuf && !lineBuf.startsWith("[PALMIER")) {
             writer.write(lineBuf);
         }
-        // Include permission requests in the assistant message
         if (requiredPermissions.length > 0) {
             const permLines = requiredPermissions.map((p) => `- **${p.name}** ${p.description}`).join("\n");
             writer.write(`\n\n**Permissions requested:**\n${permLines}\n`);
@@ -75,7 +70,6 @@ async function invokeAgentWithRetries(ctx, invokeTask) {
                 report_files: reportFiles,
             });
         }
-        // Permission handling — agent requested permissions
         if (requiredPermissions.length > 0) {
             const response = await requestPermission(ctx.config, ctx.task, ctx.taskDir, requiredPermissions);
             if (response === "aborted") {
@@ -103,31 +97,22 @@ async function invokeAgentWithRetries(ctx, invokeTask) {
             else {
                 ctx.transientPermissions = [...ctx.transientPermissions, ...newPerms];
             }
-            // If the agent actually failed, retry with the new permissions
+            // Retry with the new permissions if the agent failed.
             if (outcome === "failed") {
                 continue;
             }
         }
-        // Normal completion (success or terminal failure)
         return { outcome };
     }
 }
-/**
- * Strip [PALMIER_*] marker lines from agent output.
- */
 export function stripPalmierMarkers(output) {
     return output.split("\n").filter((l) => !l.startsWith("[PALMIER")).join("\n").trim();
 }
-/**
- * Append a conversation message to the RESULT file and notify connected clients.
- */
 async function appendAndNotify(ctx, msg) {
     appendRunMessage(ctx.taskDir, ctx.runId, msg);
     await publishHostEvent(ctx.nc, ctx.config.hostId, ctx.taskId, { event_type: "result-updated", run_id: ctx.runId });
 }
-/**
- * Find the latest run dir that has no status messages yet (just created by the RPC handler).
- */
+/** The latest run dir with no status messages yet — freshly created by the RPC handler. */
 function findLatestPendingRunId(taskDir) {
     const dirs = fs.readdirSync(taskDir)
         .filter((f) => /^\d+$/.test(f) && fs.existsSync(path.join(taskDir, f, "TASKRUN.md")))
@@ -140,8 +125,8 @@ function findLatestPendingRunId(taskDir) {
     return hasStatus ? null : latest;
 }
 /**
- * If the RPC handler already wrote "aborted" to status.json (e.g. via task.abort),
- * respect that instead of overwriting with the process's own outcome.
+ * If the RPC handler already wrote "aborted" (via task.abort), respect that
+ * instead of overwriting with the process's own outcome.
  */
 function resolveOutcome(taskDir, outcome) {
     const current = readTaskStatus(taskDir);
@@ -149,9 +134,6 @@ function resolveOutcome(taskDir, outcome) {
         return "aborted";
     return outcome;
 }
-/**
- * Execute a task by ID.
- */
 export async function runCommand(taskId) {
     const config = loadConfig();
     const taskDir = getTaskDir(config.projectRoot, taskId);
@@ -159,7 +141,6 @@ export async function runCommand(taskId) {
     console.log(`Running task: ${taskId}`);
     let nc;
     const taskName = task.frontmatter.name;
-    // Use existing run dir if just created by RPC, otherwise create a new one
     const existingRunId = findLatestPendingRunId(taskDir);
     const runId = existingRunId ?? createRunDir(taskDir, taskName, Date.now(), task.frontmatter.agent);
     if (!existingRunId) {
@@ -175,7 +156,6 @@ export async function runCommand(taskId) {
         await publishTaskEvent(nc, config, taskDir, taskId, "started", taskName, runId);
         appendRunMessage(taskDir, runId, { role: "status", time: Date.now(), content: "", type: "started" });
         await publishHostEvent(nc, config.hostId, taskId, { event_type: "result-updated", run_id: runId });
-        // If requires_confirmation, notify clients and wait
         if (task.frontmatter.requires_confirmation) {
             const confirmed = await requestConfirmation(config, task, taskDir);
             const confirmPrompt = `**Task Confirmation**\n\nRun task "${taskName || task.frontmatter.user_prompt}"?`;
@@ -194,7 +174,6 @@ export async function runCommand(taskId) {
             appendRunMessage(taskDir, runId, { role: "status", time: Date.now(), content: "", type: "confirmation" });
             await publishHostEvent(nc, config.hostId, taskId, { event_type: "result-updated", run_id: runId });
         }
-        // Shared invocation context
         const guiEnv = getPlatform().getGuiEnv();
         const agent = getAgent(task.frontmatter.agent);
         const ctx = {
@@ -202,7 +181,6 @@ export async function runCommand(taskId) {
             transientPermissions: [],
         };
         if (task.frontmatter.command) {
-            // Command-triggered mode
             const result = await runCommandTriggeredMode(ctx);
             const outcome = resolveOutcome(taskDir, result.outcome);
             appendRunMessage(taskDir, runId, { role: "status", time: Date.now(), content: "", type: outcome });
@@ -211,7 +189,6 @@ export async function runCommand(taskId) {
         }
         else if (task.frontmatter.schedule_type === "on_new_notification"
             || task.frontmatter.schedule_type === "on_new_sms") {
-            // Event-triggered mode (driven by NATS pub/sub of device notifications/SMS)
             const result = await runEventTriggeredMode(ctx);
             const outcome = resolveOutcome(taskDir, result.outcome);
             appendRunMessage(taskDir, runId, { role: "status", time: Date.now(), content: "", type: outcome });
@@ -219,7 +196,6 @@ export async function runCommand(taskId) {
             console.log(`Task ${taskId} completed (event-triggered).`);
         }
         else {
-            // Standard execution — add user prompt as first message
             await appendAndNotify(ctx, {
                 role: "user",
                 time: Date.now(),
@@ -254,11 +230,9 @@ const MAX_LOG_ENTRIES = 1000;
 /** Max input line length (chars). Long emails can take up to 200k chars. */
 const MAX_LINE_LENGTH = 200_000;
 /**
- * Command-triggered execution mode.
- *
- * Spawns a long-running shell command and, for each line of stdout,
- * invokes the agent CLI with the user's prompt augmented by that line.
- * Processes lines sequentially with a bounded queue.
+ * Spawn a long-running shell command and invoke the agent CLI once per stdout
+ * line, with the user's prompt augmented by that line. Sequential with a
+ * bounded queue.
  */
 async function runCommandTriggeredMode(ctx) {
     const commandStr = ctx.task.frontmatter.command;
@@ -280,7 +254,6 @@ async function runCommandTriggeredMode(ctx) {
     function appendLog(line, agentOutput, outcome) {
         const entry = `[${new Date().toISOString()}] (${outcome}) input: ${line}\n${agentOutput}\n---\n`;
         fs.appendFileSync(logPath, entry, "utf-8");
-        // Trim log if too large (keep last MAX_LOG_ENTRIES entries)
         try {
             const content = fs.readFileSync(logPath, "utf-8");
             const entries = content.split("\n---\n").filter(Boolean);
@@ -312,7 +285,7 @@ async function runCommandTriggeredMode(ctx) {
             invocationsFailed++;
         }
         appendLog(line, "", result.outcome);
-        // Append monitoring status so the UI shows the task is waiting for more input
+        // Signal "waiting for more input" in the UI.
         appendRunMessage(ctx.taskDir, ctx.runId, { role: "status", time: Date.now(), content: "", type: "monitoring" });
         await publishHostEvent(ctx.nc, ctx.config.hostId, ctx.taskId, { event_type: "result-updated", run_id: ctx.runId });
     }
@@ -353,7 +326,6 @@ async function runCommandTriggeredMode(ctx) {
         stderrBuf += chunk;
         process.stderr.write(d);
     });
-    // Wait for command to exit
     const exitCode = await new Promise((resolve) => {
         child.on("close", (code) => {
             commandExited = true;
@@ -368,7 +340,6 @@ async function runCommandTriggeredMode(ctx) {
             resolve(1);
         });
     });
-    // Wait for any remaining queued lines to finish processing
     if (lineQueue.length > 0 || processing) {
         await new Promise((resolve) => {
             resolveWhenDone = resolve;
@@ -390,13 +361,10 @@ async function runCommandTriggeredMode(ctx) {
     return { outcome: "finished", endTime };
 }
 /**
- * Event-triggered execution mode.
- *
- * Drains the daemon-owned per-task event queue via the local /task-event/pop
- * HTTP endpoint, invoking the agent once per event with the payload spliced
- * into the user prompt. The run process itself holds no NATS subscription;
- * the daemon handles that and atomically clears the active flag when we see
- * an empty pop, so it can fire up a fresh run on the next incoming event.
+ * Drain the daemon-owned per-task event queue via /task-event/pop, invoking
+ * the agent once per event. The run process holds no NATS subscription — the
+ * daemon owns that and atomically clears the active flag on empty pop so it
+ * can fire a fresh run on the next incoming event.
  */
 async function runEventTriggeredMode(ctx) {
     const scheduleType = ctx.task.frontmatter.schedule_type;
@@ -488,10 +456,6 @@ async function requestConfirmation(config, task, taskDir) {
     });
     return confirmed;
 }
-/**
- * Extract report file names from agent output.
- * Looks for lines matching: [PALMIER_REPORT] <filename>
- */
 const ALLOWED_REPORT_EXT = [".md", ".txt", ".png", ".jpg", ".jpeg", ".gif", ".svg", ".webp"];
 export function parseReportFiles(output) {
     const regex = new RegExp(`^\\${TASK_REPORT_PREFIX}\\s+(.+)$`, "gm");
@@ -499,7 +463,7 @@ export function parseReportFiles(output) {
     let match;
     while ((match = regex.exec(output)) !== null) {
         const name = match[1].trim();
-        // Skip placeholder examples echoed from the prompt (e.g. "<filename>")
+        // Skip placeholder examples echoed from the prompt (e.g. "<filename>").
         if (!name || name.startsWith("<"))
             continue;
         const ext = name.lastIndexOf(".") >= 0 ? name.slice(name.lastIndexOf(".")).toLowerCase() : "";
@@ -509,17 +473,13 @@ export function parseReportFiles(output) {
     }
     return files;
 }
-/**
- * Extract required permissions from agent output.
- * Looks for lines matching: [PALMIER_PERMISSION] <tool> | <description>
- */
 export function parsePermissions(output) {
     const regex = new RegExp(`^\\${TASK_PERMISSION_PREFIX}\\s+(.+)$`, "gm");
     const perms = [];
     let match;
     while ((match = regex.exec(output)) !== null) {
         const raw = match[1].trim();
-        // Skip placeholder examples echoed from the prompt (e.g. "<tool_name> | <description>")
+        // Skip placeholder examples echoed from the prompt (e.g. "<tool_name> | <description>").
         if (raw.startsWith("<"))
             continue;
         const sep = raw.indexOf("|");
@@ -532,10 +492,7 @@ export function parsePermissions(output) {
     }
     return perms;
 }
-/**
- * Parse the agent's output for success/failure markers.
- * Falls back to "finished" if no marker is found.
- */
+/** Falls back to "finished" if no success/failure marker is found. */
 export function parseTaskOutcome(output) {
     const lastChunk = output.slice(-500);
     const regex = new RegExp(`^\\${TASK_FAILURE_MARKER}$|^\\${TASK_SUCCESS_MARKER}$`, "gm");

package/dist/commands/serve.d.ts

@@ -1,5 +1,2 @@
-/**
- * Start the persistent RPC handler (NATS + HTTP).
- */
 export declare function serveCommand(): Promise<void>;
 //# sourceMappingURL=serve.d.ts.map

package/dist/commands/serve.js

@@ -18,11 +18,8 @@ import { enqueueEvent } from "../event-queues.js";
 const POLL_INTERVAL_MS = 30_000;
 const DAEMON_PID_FILE = path.join(CONFIG_DIR, "daemon.pid");
 /**
- * Scan all tasks for any stuck in "started" state whose process is no longer alive.
- * Uses the system scheduler (Task Scheduler / systemd) as the authoritative source.
- *
- * Since run.ts creates the RESULT file and history entry at start, we just need to
- * finalize the existing RESULT file, append a failed status entry, and broadcast.
+ * Reconcile tasks stuck in "started" whose process is no longer alive.
+ * The system scheduler (Task Scheduler / systemd) is the authoritative source.
  */
 async function checkStaleTasks(config, nc) {
     const tasksJsonl = path.join(config.projectRoot, "tasks.jsonl");
@@ -42,13 +39,11 @@ async function checkStaleTasks(config, nc) {
         const status = readTaskStatus(taskDir);
         if (!status || status.running_state !== "started")
             continue;
-        // Ask the system scheduler if the task is still running
         if (platform.isTaskRunning(taskId))
             continue;
         console.log(`[monitor] Task ${taskId} process exited unexpectedly, marking as failed.`);
         const endTime = Date.now();
         writeTaskStatus(taskDir, { running_state: "failed", time_stamp: endTime });
-        // Find the latest run directory (created by run.ts at start)
         const runId = fs.readdirSync(taskDir)
             .filter((f) => /^\d+$/.test(f) && fs.existsSync(path.join(taskDir, f, "TASKRUN.md")))
             .sort()
@@ -65,7 +60,7 @@ async function checkStaleTasks(config, nc) {
         try {
             taskName = parseTaskFile(taskDir).frontmatter.name || taskId;
         }
-        catch { /* use taskId as fallback */ }
+        catch { /* fallback to taskId */ }
         await publishHostEvent(nc, config.hostId, taskId, {
             event_type: "running-state",
             running_state: "failed",
@@ -73,15 +68,11 @@ async function checkStaleTasks(config, nc) {
         });
     }
 }
-/**
- * Start the persistent RPC handler (NATS + HTTP).
- */
 export async function serveCommand() {
     const config = loadConfig();
-    // Write PID so `palmier restart` can find us regardless of how we were started
+    // PID file lets `palmier restart` find us regardless of how we were started
     fs.writeFileSync(DAEMON_PID_FILE, String(process.pid), "utf-8");
     console.log("Starting...");
-    // Re-detect agents on every daemon start
     const agents = await detectAgents();
     config.agents = agents;
     saveConfig(config);
@@ -94,9 +85,8 @@ export async function serveCommand() {
     catch (err) {
         console.warn(`[nats] Connection failed (server mode unavailable): ${err}`);
     }
-    // Reconcile any tasks stuck from before daemon started
     await checkStaleTasks(config, nc);
-    // Ensure all tasks have their scheduler entries (recovery after init/reinstall)
+    // Reinstall scheduler entries for all tasks (recovery after init/reinstall)
     const platform = getPlatform();
     const allTasks = listTasks(config.projectRoot);
     for (const task of allTasks) {
@@ -107,7 +97,6 @@ export async function serveCommand() {
             console.error(`Warning: failed to install timer for task ${task.frontmatter.id}: ${err}`);
         }
     }
-    // Poll for crashed tasks every 30 seconds
     setInterval(() => {
         checkStaleTasks(config, nc).catch((err) => {
             console.error("[monitor] Error checking stale tasks:", err);
@@ -115,18 +104,30 @@ export async function serveCommand() {
     }, POLL_INTERVAL_MS);
     const handleRpc = createRpcHandler(config, nc);
     const httpPort = config.httpPort ?? 7256;
-    // Start NATS transport (loops forever, fire-and-forget)
     if (nc) {
         startNatsTransport(config, handleRpc, nc);
-        // Subscribe to device notifications and SMS from Android
         const sc = StringCodec();
-        // Dispatch a raw event payload to every task whose schedule matches.
-        function dispatchDeviceEvent(scheduleType, payload) {
+        // Match phone numbers regardless of formatting; letters preserved for shortcodes.
+        function normalizeSender(raw) {
+            return raw.replace(/[\s\-()+]/g, "").toLowerCase();
+        }
+        function dispatchDeviceEvent(scheduleType, payload, parsed) {
             for (const task of listTasks(config.projectRoot)) {
                 if (task.frontmatter.schedule_type !== scheduleType)
                     continue;
                 if (!task.frontmatter.schedule_enabled)
                     continue;
+                if (scheduleType === "on_new_notification" && task.frontmatter.schedule_values && task.frontmatter.schedule_values.length > 0) {
+                    const pkg = parsed?.packageName;
+                    if (!pkg || !task.frontmatter.schedule_values.includes(pkg))
+                        continue;
+                }
+                if (scheduleType === "on_new_sms" && task.frontmatter.schedule_values && task.frontmatter.schedule_values.length > 0) {
+                    const sender = parsed?.sender;
+                    const normalizedSender = sender ? normalizeSender(sender) : "";
+                    if (!normalizedSender || !task.frontmatter.schedule_values.some((s) => normalizeSender(s) === normalizedSender))
+                        continue;
+                }
                 const { shouldStart } = enqueueEvent(task.frontmatter.id, payload);
                 if (shouldStart) {
                     platform.startTask(task.frontmatter.id).catch((err) => {
@@ -139,32 +140,33 @@ export async function serveCommand() {
         (async () => {
             for await (const msg of notifSub) {
                 const raw = sc.decode(msg.data);
+                let parsed;
                 try {
-                    const data = JSON.parse(raw);
-                    addNotification({ ...data, receivedAt: Date.now() });
+                    parsed = JSON.parse(raw);
+                    addNotification({ ...parsed, receivedAt: Date.now() });
                 }
                 catch (err) {
                     console.error("[nats] Failed to parse device notification:", err);
                 }
-                dispatchDeviceEvent("on_new_notification", raw);
+                dispatchDeviceEvent("on_new_notification", raw, parsed);
             }
         })();
         const smsSub = nc.subscribe(`host.${config.hostId}.device.sms`);
         (async () => {
             for await (const msg of smsSub) {
                 const raw = sc.decode(msg.data);
+                let parsed;
                 try {
-                    const data = JSON.parse(raw);
-                    addSmsMessage({ ...data, receivedAt: Date.now() });
+                    parsed = JSON.parse(raw);
+                    addSmsMessage({ ...parsed, receivedAt: Date.now() });
                 }
                 catch (err) {
                     console.error("[nats] Failed to parse device SMS:", err);
                 }
-                dispatchDeviceEvent("on_new_sms", raw);
+                dispatchDeviceEvent("on_new_sms", raw, parsed);
             }
         })();
     }
-    // Start HTTP transport (loops forever)
     await startHttpTransport(config, handleRpc, httpPort, nc);
 }
 //# sourceMappingURL=serve.js.map

package/dist/config.d.ts

@@ -1,15 +1,7 @@
 import type { HostConfig } from "./types.js";
 declare const CONFIG_DIR: string;
 declare const CONFIG_FILE: string;
-/**
- * Load host configuration from ~/.config/palmier/host.json.
- * Throws if the file is missing or invalid.
- */
 export declare function loadConfig(): HostConfig;
-/**
- * Persist host configuration to ~/.config/palmier/host.json.
- * Creates parent directories if needed.
- */
 export declare function saveConfig(config: HostConfig): void;
 export { CONFIG_DIR, CONFIG_FILE };
 //# sourceMappingURL=config.d.ts.map

package/dist/config.js

@@ -3,10 +3,6 @@ import * as path from "path";
 import { homedir } from "os";
 const CONFIG_DIR = path.join(homedir(), ".config", "palmier");
 const CONFIG_FILE = path.join(CONFIG_DIR, "host.json");
-/**
- * Load host configuration from ~/.config/palmier/host.json.
- * Throws if the file is missing or invalid.
- */
 export function loadConfig() {
     if (!fs.existsSync(CONFIG_FILE)) {
         throw new Error("Host not provisioned. Run `palmier init` first.\n" +
@@ -22,10 +18,6 @@ export function loadConfig() {
     }
     return config;
 }
-/**
- * Persist host configuration to ~/.config/palmier/host.json.
- * Creates parent directories if needed.
- */
 export function saveConfig(config) {
     fs.mkdirSync(CONFIG_DIR, { recursive: true });
     fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), "utf-8");

package/dist/device-capabilities.d.ts

@@ -2,7 +2,7 @@ export interface RegisteredDevice {
     clientToken: string;
     fcmToken: string;
 }
-export type DeviceCapability = "location" | "notifications" | "sms" | "contacts" | "calendar" | "alert" | "battery" | "send-email" | "dnd";
+export type DeviceCapability = "location" | "notifications" | "sms-read" | "sms-send" | "contacts" | "calendar" | "alarm" | "battery" | "send-email" | "dnd";
 export declare function getCapabilityDevice(capability: DeviceCapability): RegisteredDevice | null;
 export declare function setCapabilityDevice(capability: DeviceCapability, clientToken: string, fcmToken: string): void;
 export declare function clearCapabilityDevice(capability: DeviceCapability): void;

package/dist/event-queues.d.ts

@@ -1,31 +1,16 @@
 /**
- * Per-task in-memory event queues for event-triggered schedules
- * (schedule_type: "on_new_notification" | "on_new_sms").
- *
+ * Per-task in-memory event queues for on_new_notification / on_new_sms schedules.
  * The daemon owns the NATS subscription and populates these queues; the
- * `palmier run` process drains them via the localhost /task-event/pop HTTP
- * endpoint. `activeRuns` tracks whether a run process is currently draining,
- * so we don't race a fresh startTask with a teardown-phase run.
+ * `palmier run` process drains via /task-event/pop.
  *
- * Lifecycle invariants:
- *   - activeRuns is cleared atomically inside popEvent when the queue is
- *     drained. At that point the calling run has already finished its last
- *     agent invocation and is only tearing down.
- *   - enqueueEvent returns shouldStart=true only if the task transitioned
- *     from idle (no active run) to active — callers must then startTask.
- */
-/**
- * Queue a raw (JSON-string) event payload for a task. Returns whether the
- * caller should now start the run process.
+ * Invariants:
+ *   - popEvent clears activeRuns atomically when the queue empties, so a
+ *     fresh startTask cannot race the tearing-down run.
+ *   - enqueueEvent returns shouldStart=true only on the idle→active edge.
  */
 export declare function enqueueEvent(taskId: string, payload: string): {
     shouldStart: boolean;
 };
-/**
- * Pop the oldest queued event for a task. Returns `{ event }` when one is
- * available (keeps the task marked active), or `{ empty: true }` after
- * clearing the active flag atomically.
- */
 export declare function popEvent(taskId: string): {
     event: string;
 } | {

package/dist/event-queues.js

@@ -1,26 +1,16 @@
 /**
- * Per-task in-memory event queues for event-triggered schedules
- * (schedule_type: "on_new_notification" | "on_new_sms").
- *
+ * Per-task in-memory event queues for on_new_notification / on_new_sms schedules.
  * The daemon owns the NATS subscription and populates these queues; the
- * `palmier run` process drains them via the localhost /task-event/pop HTTP
- * endpoint. `activeRuns` tracks whether a run process is currently draining,
- * so we don't race a fresh startTask with a teardown-phase run.
+ * `palmier run` process drains via /task-event/pop.
  *
- * Lifecycle invariants:
- *   - activeRuns is cleared atomically inside popEvent when the queue is
- *     drained. At that point the calling run has already finished its last
- *     agent invocation and is only tearing down.
- *   - enqueueEvent returns shouldStart=true only if the task transitioned
- *     from idle (no active run) to active — callers must then startTask.
+ * Invariants:
+ *   - popEvent clears activeRuns atomically when the queue empties, so a
+ *     fresh startTask cannot race the tearing-down run.
+ *   - enqueueEvent returns shouldStart=true only on the idle→active edge.
  */
 const MAX_QUEUE_SIZE = 100;
 const queues = new Map();
 const activeRuns = new Set();
-/**
- * Queue a raw (JSON-string) event payload for a task. Returns whether the
- * caller should now start the run process.
- */
 export function enqueueEvent(taskId, payload) {
     const queue = queues.get(taskId) ?? [];
     if (queue.length >= MAX_QUEUE_SIZE)
@@ -32,11 +22,6 @@ export function enqueueEvent(taskId, payload) {
     activeRuns.add(taskId);
     return { shouldStart: true };
 }
-/**
- * Pop the oldest queued event for a task. Returns `{ event }` when one is
- * available (keeps the task marked active), or `{ empty: true }` after
- * clearing the active flag atomically.
- */
 export function popEvent(taskId) {
     const queue = queues.get(taskId);
     if (queue && queue.length > 0) {

package/dist/events.d.ts

@@ -1,9 +1,3 @@
 import { type NatsConnection } from "nats";
-/**
- * Broadcast an event to connected clients via NATS and HTTP SSE.
- *
- * - NATS: publishes to `host-event.{hostId}.{taskId}`
- * - HTTP: POSTs to the serve daemon's `/event` endpoint
- */
 export declare function publishHostEvent(nc: NatsConnection | undefined, hostId: string, taskId: string, payload: Record<string, unknown>): Promise<void>;
 //# sourceMappingURL=events.d.ts.map

package/dist/events.js

@@ -1,12 +1,6 @@
 import { StringCodec } from "nats";
 import { loadConfig } from "./config.js";
 const sc = StringCodec();
-/**
- * Broadcast an event to connected clients via NATS and HTTP SSE.
- *
- * - NATS: publishes to `host-event.{hostId}.{taskId}`
- * - HTTP: POSTs to the serve daemon's `/event` endpoint
- */
 export async function publishHostEvent(nc, hostId, taskId, payload) {
     const subject = `host-event.${hostId}.${taskId}`;
     if (nc) {
@@ -23,8 +17,6 @@ export async function publishHostEvent(nc, hostId, taskId, payload) {
         });
         console.log(`[http] host-event: ${taskId} →`, payload);
     }
-    catch {
-        // Serve HTTP may not be ready yet — ignore
-    }
+    catch { /* serve HTTP may not be ready yet */ }
 }
 //# sourceMappingURL=events.js.map

package/dist/index.js

@@ -82,7 +82,6 @@ program
     .action(async () => {
     await uninstallCommand();
 });
-// No subcommand → default to serve
 if (process.argv.length <= 2) {
     process.argv.push("serve");
 }

package/dist/mcp-handler.js

@@ -1,11 +1,10 @@
 import { randomUUID } from "crypto";
 import { agentTools, agentToolMap, agentResources, agentResourceMap, ToolError } from "./mcp-tools.js";
-// Resource subscriptions: sessionId → Set of resource URIs
+/** sessionId → subscribed resource URIs */
 const resourceSubscriptions = new Map();
 export function getResourceSubscriptions() {
     return resourceSubscriptions;
 }
-// Session-to-agent name map with 24h TTL
 const SESSION_TTL_MS = 24 * 60 * 60 * 1000;
 const sessionAgents = new Map();
 export function getAgentName(sessionId) {

package/dist/mcp-tools.d.ts

@@ -37,8 +37,5 @@ export interface ResourceDefinition {
 }
 export declare const agentResources: ResourceDefinition[];
 export declare const agentResourceMap: Map<string, ResourceDefinition>;
-/**
- * Generate the HTTP Endpoints markdown section for agent-instructions.md from the tool registry.
- */
 export declare function generateEndpointDocs(port: number, taskId: string, tools?: ToolDefinition[], resources?: ResourceDefinition[]): string;
 //# sourceMappingURL=mcp-tools.d.ts.map