palmier 0.8.1 → 0.8.3

package/src/commands/serve.ts

@@ -16,16 +16,14 @@ import { StringCodec, type NatsConnection } from "nats";
 import { addNotification } from "../notification-store.js";
 import { addSmsMessage } from "../sms-store.js";
 import { enqueueEvent } from "../event-queues.js";
+import { recordApp } from "../app-registry.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: HostConfig,
@@ -46,14 +44,12 @@ async function checkStaleTasks(
     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()
@@ -71,7 +67,7 @@ async function checkStaleTasks(
     let taskName = taskId;
     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",
@@ -81,18 +77,14 @@ async function checkStaleTasks(
   }
 }
 
-/**
- * Start the persistent RPC handler (NATS + HTTP).
- */
 export async function serveCommand(): Promise<void> {
   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);
@@ -106,10 +98,9 @@ export async function serveCommand(): Promise<void> {
     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) {
@@ -120,7 +111,6 @@ export async function serveCommand(): Promise<void> {
     }
   }
 
-  // Poll for crashed tasks every 30 seconds
   setInterval(() => {
     checkStaleTasks(config, nc).catch((err) => {
       console.error("[monitor] Error checking stale tasks:", err);
@@ -130,18 +120,29 @@ export async function serveCommand(): Promise<void> {
   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: "on_new_notification" | "on_new_sms", payload: string): void {
+    // Match phone numbers regardless of formatting; letters preserved for shortcodes.
+    function normalizeSender(raw: string): string {
+      return raw.replace(/[\s\-()+]/g, "").toLowerCase();
+    }
+
+    function dispatchDeviceEvent(scheduleType: "on_new_notification" | "on_new_sms", payload: string, parsed?: unknown): void {
       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 as { packageName?: string } | undefined)?.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 as { sender?: string } | undefined)?.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) => {
@@ -155,13 +156,16 @@ export async function serveCommand(): Promise<void> {
     (async () => {
       for await (const msg of notifSub) {
         const raw = sc.decode(msg.data);
+        let parsed: unknown;
         try {
-          const data = JSON.parse(raw);
-          addNotification({ ...data, receivedAt: Date.now() });
+          parsed = JSON.parse(raw);
+          const data = parsed as { packageName?: string; appName?: string };
+          addNotification({ ...(parsed as object), receivedAt: Date.now() } as Parameters<typeof addNotification>[0]);
+          if (data.packageName && data.appName) recordApp(data.packageName, data.appName);
         } catch (err) {
           console.error("[nats] Failed to parse device notification:", err);
         }
-        dispatchDeviceEvent("on_new_notification", raw);
+        dispatchDeviceEvent("on_new_notification", raw, parsed);
       }
     })();
 
@@ -169,17 +173,17 @@ export async function serveCommand(): Promise<void> {
     (async () => {
       for await (const msg of smsSub) {
         const raw = sc.decode(msg.data);
+        let parsed: unknown;
         try {
-          const data = JSON.parse(raw);
-          addSmsMessage({ ...data, receivedAt: Date.now() });
+          parsed = JSON.parse(raw);
+          addSmsMessage({ ...(parsed as object), receivedAt: Date.now() } as Parameters<typeof addSmsMessage>[0]);
         } 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);
 }

package/src/config.ts

@@ -6,10 +6,6 @@ import type { HostConfig } from "./types.js";
 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(): HostConfig {
   if (!fs.existsSync(CONFIG_FILE)) {
     throw new Error(
@@ -32,10 +28,6 @@ export function loadConfig(): HostConfig {
   return config;
 }
 
-/**
- * Persist host configuration to ~/.config/palmier/host.json.
- * Creates parent directories if needed.
- */
 export function saveConfig(config: HostConfig): void {
   fs.mkdirSync(CONFIG_DIR, { recursive: true });
   fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), "utf-8");

package/src/device-capabilities.ts

@@ -12,10 +12,11 @@ export interface RegisteredDevice {
 export type DeviceCapability =
   | "location"
   | "notifications"
-  | "sms"
+  | "sms-read"
+  | "sms-send"
   | "contacts"
   | "calendar"
-  | "alert"
+  | "alarm"
   | "battery"
   | "send-email"
   | "dnd";

package/src/event-queues.ts

@@ -1,18 +1,12 @@
 /**
- * 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;
@@ -20,10 +14,6 @@ const MAX_QUEUE_SIZE = 100;
 const queues = new Map<string, string[]>();
 const activeRuns = new Set<string>();
 
-/**
- * Queue a raw (JSON-string) event payload for a task. Returns whether the
- * caller should now start the run process.
- */
 export function enqueueEvent(taskId: string, payload: string): { shouldStart: boolean } {
   const queue = queues.get(taskId) ?? [];
   if (queue.length >= MAX_QUEUE_SIZE) queue.shift();
@@ -35,11 +25,6 @@ export function enqueueEvent(taskId: string, payload: string): { shouldStart: bo
   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: string): { event: string } | { empty: true } {
   const queue = queues.get(taskId);
   if (queue && queue.length > 0) {

package/src/events.ts

@@ -3,12 +3,6 @@ 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: NatsConnection | undefined,
   hostId: string,
@@ -31,7 +25,5 @@ export async function publishHostEvent(
       body: JSON.stringify({ task_id: 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 */ }
 }

package/src/index.ts

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

package/src/mcp-handler.ts

@@ -15,14 +15,13 @@ export interface McpResponse {
   stream?: boolean;
 }
 
-// Resource subscriptions: sessionId → Set of resource URIs
+/** sessionId → subscribed resource URIs */
 const resourceSubscriptions = new Map<string, Set<string>>();
 
 export function getResourceSubscriptions(): Map<string, Set<string>> {
   return resourceSubscriptions;
 }
 
-// Session-to-agent name map with 24h TTL
 const SESSION_TTL_MS = 24 * 60 * 60 * 1000;
 const sessionAgents = new Map<string, { agentName: string; expiresAt: number }>();
 

package/src/mcp-tools.ts

@@ -462,8 +462,8 @@ const sendSmsTool: ToolDefinition = {
   async handler(args, ctx) {
     if (!ctx.nc) throw new ToolError("Not connected to server (NATS unavailable)", 503);
 
-    const device = getCapabilityDevice("sms");
-    if (!device) throw new ToolError("No device has SMS access enabled", 400);
+    const device = getCapabilityDevice("sms-send");
+    if (!device) throw new ToolError("No device has SMS Send enabled", 400);
 
     const { to, body } = args as { to: string; body: string };
     if (!to || !body) throw new ToolError("to and body are required", 400);
@@ -502,10 +502,10 @@ const sendSmsTool: ToolDefinition = {
   },
 };
 
-const sendAlertTool: ToolDefinition = {
-  name: "send-alert",
+const sendAlarmTool: ToolDefinition = {
+  name: "send-alarm",
   description: [
-    "Send an alert to the user's mobile device with an alarm sound and full-screen popup.",
+    "Trigger an alarm on the user's mobile device with an alarm sound and full-screen popup.",
     "Use this to urgently get the user's attention. The device will play an alarm sound and show a full-screen dialog even on the lock screen.",
     "Blocks until the device responds (up to 30 seconds).",
     'Response: `{"ok": true}` on success, or `{"error": "..."}` on failure.',
@@ -513,16 +513,16 @@ const sendAlertTool: ToolDefinition = {
   inputSchema: {
     type: "object",
     properties: {
-      title: { type: "string", description: "Alert title" },
-      description: { type: "string", description: "Alert description/details" },
+      title: { type: "string", description: "Alarm title" },
+      description: { type: "string", description: "Alarm description/details" },
     },
     required: ["title"],
   },
   async handler(args, ctx) {
     if (!ctx.nc) throw new ToolError("Not connected to server (NATS unavailable)", 503);
 
-    const device = getCapabilityDevice("alert");
-    if (!device) throw new ToolError("No device has alert access enabled", 400);
+    const device = getCapabilityDevice("alarm");
+    if (!device) throw new ToolError("No device has alarm access enabled", 400);
 
     const { title, description } = args as { title: string; description?: string };
     if (!title) throw new ToolError("title is required", 400);
@@ -536,7 +536,7 @@ const sendAlertTool: ToolDefinition = {
     if (description) payload.description = description;
 
     const ackReply = await ctx.nc.request(
-      `host.${ctx.config.hostId}.fcm.alert`,
+      `host.${ctx.config.hostId}.fcm.alarm`,
       sc.encode(JSON.stringify(payload)),
       { timeout: 5_000 },
     );
@@ -544,7 +544,7 @@ const sendAlertTool: ToolDefinition = {
     if (ack.error) throw new ToolError(ack.error, 502);
 
     const responsePromise = new Promise<string>((resolve, reject) => {
-      const sub = ctx.nc!.subscribe(`host.${ctx.config.hostId}.alert.${ctx.sessionId}`, { max: 1 });
+      const sub = ctx.nc!.subscribe(`host.${ctx.config.hostId}.alarm.${ctx.sessionId}`, { max: 1 });
       const timer = setTimeout(() => {
         sub.unsubscribe();
         reject(new ToolError("Device did not respond within 30 seconds", 504));
@@ -733,11 +733,9 @@ const sendEmailTool: ToolDefinition = {
   },
 };
 
-export const agentTools: ToolDefinition[] = [notifyTool, requestInputTool, requestConfirmationTool, deviceGeolocationTool, readContactsTool, createContactTool, readCalendarTool, createCalendarEventTool, sendSmsTool, sendEmailTool, sendAlertTool, readBatteryTool, setRingerModeTool];
+export const agentTools: ToolDefinition[] = [notifyTool, requestInputTool, requestConfirmationTool, deviceGeolocationTool, readContactsTool, createContactTool, readCalendarTool, createCalendarEventTool, sendSmsTool, sendEmailTool, sendAlarmTool, readBatteryTool, setRingerModeTool];
 export const agentToolMap = new Map<string, ToolDefinition>(agentTools.map((t) => [t.name, t]));
 
-// ── MCP Resources ─────────────────────────────────────────────────────
-
 export interface ResourceDefinition {
   /** MCP resource URI (e.g. "notifications://device"). */
   uri: string;
@@ -783,9 +781,6 @@ const deviceSmsResource: ResourceDefinition = {
 export const agentResources: ResourceDefinition[] = [deviceNotificationsResource, deviceSmsResource];
 export const agentResourceMap = new Map<string, ResourceDefinition>(agentResources.map((r) => [r.uri, r]));
 
-/**
- * Generate the HTTP Endpoints markdown section for agent-instructions.md from the tool registry.
- */
 export function generateEndpointDocs(
   port: number,
   taskId: string,
@@ -803,7 +798,6 @@ export function generateEndpointDocs(
     const props = schema.properties ?? {};
     const required = new Set(schema.required ?? []);
 
-    // Build example JSON (body only, no taskId)
     const example: Record<string, unknown> = {};
     for (const [key, prop] of Object.entries(props)) {
       if (prop.type === "array") example[key] = ["..."];

package/src/nats-client.ts

@@ -1,9 +1,6 @@
 import { connect, jwtAuthenticator, type NatsConnection } from "nats";
 import type { HostConfig } from "./types.js";
 
-/**
- * Connect to NATS using the host config's JWT credentials.
- */
 export async function connectNats(config: HostConfig): Promise<NatsConnection> {
   if (!config.natsJwt || !config.natsNkeySeed) {
     throw new Error("NATS JWT credentials not configured. Re-run palmier init.");
@@ -17,6 +14,6 @@ export async function connectNats(config: HostConfig): Promise<NatsConnection> {
     ),
   });
 
-  // Do not log anything as that will pollute stdout for mcp server.
+  // Do not log — it would pollute stdout for the MCP server.
   return nc;
 }

package/src/pending-requests.ts

@@ -22,10 +22,9 @@ export interface PendingRequest {
 const pending = new Map<string, PendingRequest>();
 
 /**
- * Register a pending request keyed by either a sessionId (confirmation / input)
- * or a taskId (permission). The `meta` is surfaced to PWAs that connect after
- * the request was opened, so their modals can render without replaying events.
- * Only one pending request per key at a time.
+ * Key is sessionId for confirmation/input, taskId for permission. Only one
+ * pending request per key at a time. `meta` is surfaced via host.info so a
+ * freshly-connected PWA can render the modal without replaying events.
  */
 export function registerPending(
   key: string,
@@ -42,10 +41,6 @@ export function registerPending(
   });
 }
 
-/**
- * Resolve a pending request with the user's response.
- * Returns true if a pending request was found and resolved.
- */
 export function resolvePending(key: string, value: string[]): boolean {
   const entry = pending.get(key);
   if (!entry) return false;
@@ -54,24 +49,15 @@ export function resolvePending(key: string, value: string[]): boolean {
   return true;
 }
 
-/**
- * Get the current pending request for a key (if any).
- */
 export function getPending(key: string): PendingRequest | undefined {
   return pending.get(key);
 }
 
-/**
- * Remove a pending request without resolving it.
- */
 export function removePending(key: string): void {
   pending.delete(key);
 }
 
-/**
- * List all currently-pending requests, stripped of the unserializable `resolve`
- * callback. Used by `host.info` so the PWA can seed its modal state on connect.
- */
+/** Pending requests stripped of the unserializable `resolve` callback. */
 export function listPending(): Array<{
   key: string;
   type: PendingRequest["type"];

package/src/platform/index.ts

@@ -2,10 +2,7 @@ import type { PlatformService } from "./platform.js";
 import { LinuxPlatform } from "./linux.js";
 import { WindowsPlatform } from "./windows.js";
 
-/**
- * On Windows, execSync needs an explicit shell so .cmd shims resolve correctly.
- * On Unix, undefined lets Node use the default shell.
- */
+/** Windows needs an explicit shell for execSync to resolve .cmd shims. */
 export const SHELL: string | undefined = process.platform === "win32" ? "cmd.exe" : undefined;
 
 let _instance: PlatformService | undefined;

package/src/platform/linux.ts

@@ -22,15 +22,9 @@ function getServiceName(taskId: string): string {
 }
 
 /**
- * Convert a cron expression to a systemd OnCalendar string.
- *
- * Only the 4 cron patterns the PWA UI can produce are supported:
- *   hourly:  "0 * * * *"
- *   daily:   "MM HH * * *"
- *   weekly:  "MM HH * * D"
- *   monthly: "MM HH D * *"
- * Arbitrary cron expressions (ranges, lists, steps beyond hourly) are NOT
- * handled because the UI never generates them.
+ * Only the 4 cron patterns the PWA UI produces are supported:
+ *   hourly "0 * * * *", daily "MM HH * * *", weekly "MM HH * * D", monthly "MM HH D * *".
+ * Arbitrary expressions (ranges, lists, sub-hour steps) are not handled.
  */
 export function cronToOnCalendar(cron: string): string {
   const parts = cron.trim().split(/\s+/);
@@ -40,7 +34,6 @@ export function cronToOnCalendar(cron: string): string {
 
   const [minute, hour, dayOfMonth, , dayOfWeek] = parts;
 
-  // Map cron day-of-week numbers to systemd abbreviated names
   const dowMap: Record<string, string> = {
     "0": "Sun", "1": "Mon", "2": "Tue", "3": "Wed",
     "4": "Thu", "5": "Fri", "6": "Sat", "7": "Sun",
@@ -73,8 +66,8 @@ export class LinuxPlatform implements PlatformService {
     fs.mkdirSync(UNIT_DIR, { recursive: true });
 
     const palmierBin = process.argv[1] || "palmier";
-    // Save the user's shell PATH so restartDaemon can use it later
-    // (the daemon itself runs under systemd with a limited PATH).
+    // Save the user's shell PATH so restartDaemon can reuse it later — under
+    // systemd the daemon itself runs with a limited PATH.
     const userPath = process.env.PATH || "/usr/local/bin:/usr/bin:/bin";
     fs.mkdirSync(path.dirname(PATH_FILE), { recursive: true });
     fs.writeFileSync(PATH_FILE, userPath, "utf-8");
@@ -110,7 +103,7 @@ WantedBy=default.target
       console.error("You may need to start it manually: systemctl --user enable --now palmier.service");
     }
 
-    // Enable lingering so service runs without active login session
+    // Lingering lets the service run without an active login session.
     try {
       execSync(`loginctl enable-linger ${process.env.USER || ""}`, { stdio: "inherit" });
       console.log("Login lingering enabled.");
@@ -127,11 +120,9 @@ WantedBy=default.target
       execSync("systemctl --user disable palmier.service 2>/dev/null", { stdio: "pipe" });
     } catch { /* service may not exist */ }
 
-    // Remove daemon service file
     const servicePath = path.join(UNIT_DIR, "palmier.service");
     try { fs.unlinkSync(servicePath); } catch { /* ignore */ }
 
-    // Remove all task timers and services
     try {
       const files = fs.readdirSync(UNIT_DIR).filter((f) => f.startsWith("palmier-task-"));
       for (const f of files) {
@@ -148,8 +139,8 @@ WantedBy=default.target
   }
 
   async restartDaemon(): Promise<void> {
-    // If called from a user's terminal, save the current PATH for future use.
-    // If called from the daemon (auto-update), read the saved PATH instead.
+    // From a TTY, snapshot the current PATH; from the daemon (auto-update),
+    // reuse whatever was last saved.
     if (process.stdin.isTTY) {
       fs.mkdirSync(path.dirname(PATH_FILE), { recursive: true });
       fs.writeFileSync(PATH_FILE, process.env.PATH || "", "utf-8");
@@ -196,7 +187,6 @@ Environment=PATH=${process.env.PATH || "/usr/local/bin:/usr/bin:/bin"}
     fs.writeFileSync(path.join(UNIT_DIR, serviceName), serviceContent, "utf-8");
     daemonReload();
 
-    // Only create and enable a timer if the schedule exists and is enabled
     if (!task.frontmatter.schedule_enabled) return;
     const scheduleType = task.frontmatter.schedule_type;
     const scheduleValues = task.frontmatter.schedule_values;
@@ -260,7 +250,6 @@ WantedBy=timers.target
   }
 
   isTaskRunning(taskId: string): boolean {
-    // Check systemd first (for scheduled/on-demand runs)
     const serviceName = getServiceName(taskId);
     try {
       const out = execSync(
@@ -271,7 +260,7 @@ WantedBy=timers.target
       if (state === "active" || state === "activating") return true;
     } catch { /* service may not exist */ }
 
-    // Fall back to PID check (for follow-up runs spawned directly)
+    // Follow-up runs are spawned directly, so check PID too.
     try {
       const taskDir = getTaskDir(loadConfig().projectRoot, taskId);
       const status = readTaskStatus(taskDir);

package/src/platform/platform.ts

@@ -1,9 +1,6 @@
 import type { HostConfig, ParsedTask } from "../types.js";
 
-/**
- * Abstracts OS-specific daemon, scheduling, and process management.
- * Linux uses systemd; Windows uses Task Scheduler; macOS will use launchd.
- */
+/** Linux: systemd. Windows: Task Scheduler. macOS: launchd (planned). */
 export interface PlatformService {
   /** Install the main `palmier serve` daemon to start at boot. */
   installDaemon(config: HostConfig): void;