@trevonistrevon/pi-loop 0.5.9 → 0.6.1

package/src/tools/loop-tools.ts

@@ -1,7 +1,9 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
+import { formatTrigger } from "../loop-format.js";
 import { parseInterval } from "../loop-parse.js";
 import type { LoopEntry, Trigger } from "../types.js";
+import { textResult } from "./tool-result.js";
 
 interface LoopStoreLike {
   list(): LoopEntry[];
@@ -14,6 +16,8 @@ interface LoopStoreLike {
     maxFires?: number;
   }): LoopEntry;
   pause(id: string): LoopEntry | undefined;
+  updateDynamic(id: string, fields: { prompt?: string; dynamic: Partial<NonNullable<LoopEntry["dynamic"]>> }): LoopEntry | undefined;
+  getDeletionTombstone(id: string): { reason: string; pendingCount?: number } | undefined;
   delete(id: string): boolean;
 }
 
@@ -46,10 +50,6 @@ export interface LoopToolsOptions {
   isTaskSystemReady: () => boolean;
 }
 
-function textResult(msg: string) {
-  return { content: [{ type: "text" as const, text: msg }], details: undefined as any };
-}
-
 function validateTrigger(trigger: Trigger): string | null {
   if (trigger.type === "cron") {
     const parts = trigger.schedule.trim().split(/\s+/);
@@ -85,6 +85,89 @@ function formatRemaining(ms: number): string {
   return `${Math.round(ms / 3600000)}h`;
 }
 
+function parseDelayMs(input: string): number | undefined {
+  const match = input.trim().match(/^(\d+)\s*(s|m|h|d)$/i);
+  if (!match) return undefined;
+  const value = Number.parseInt(match[1] ?? "", 10);
+  const unit = (match[2] ?? "").toLowerCase();
+  const multiplier = unit === "s" ? 1000 : unit === "m" ? 60000 : unit === "h" ? 3600000 : 86400000;
+  return value * multiplier;
+}
+
+interface LoopUpdateParams {
+  id: string;
+  status: "continue" | "completed" | "paused";
+  state?: string;
+  metrics?: string;
+  doneCriteria?: string;
+  nextInterval?: string;
+  prompt?: string;
+}
+
+function resolveNextWakeAt(nextInterval?: string): { nextWakeAt?: number; error?: string } {
+  if (!nextInterval) return { nextWakeAt: undefined };
+  const parsedDelayMs = parseDelayMs(nextInterval);
+  if (!parsedDelayMs) return { error: `Invalid nextInterval "${nextInterval}". Use formats like 3m, 30s, or 1h.` };
+  return { nextWakeAt: Date.now() + parsedDelayMs };
+}
+
+function formatDynamicUpdateResult(id: string, iteration: number | undefined, nextWakeAt: number | undefined): string {
+  const mode = nextWakeAt === undefined
+    ? "Next wake: when idle"
+    : `Next wake: ${formatRemaining(Math.max(0, nextWakeAt - Date.now()))}`;
+  return `Dynamic loop #${id} updated\n` +
+    `Iteration: ${iteration ?? "?"}` +
+    `\n${mode}`;
+}
+
+function formatDeletionTombstone(id: string, tombstone: { reason: string; pendingCount?: number }): string {
+  const detail = tombstone.pendingCount === undefined ? "" : ` (pending: ${tombstone.pendingCount})`;
+  return `Loop #${id} already auto-deleted: ${tombstone.reason}${detail}`;
+}
+
+function continueDynamicLoop(
+  params: LoopUpdateParams,
+  entry: LoopEntry & { dynamic: NonNullable<LoopEntry["dynamic"]> },
+  store: LoopStoreLike,
+  triggerSystem: TriggerSystemLike,
+): string {
+  const { nextWakeAt, error } = resolveNextWakeAt(params.nextInterval);
+  if (error) return error;
+
+  const updated = store.updateDynamic(params.id, {
+    prompt: params.prompt,
+    dynamic: {
+      goal: params.prompt ?? entry.dynamic.goal,
+      state: params.state,
+      metrics: params.metrics,
+      doneCriteria: params.doneCriteria,
+      iteration: (entry.dynamic.iteration ?? 0) + 1,
+      nextWakeAt,
+      awaitingUpdate: false,
+      lastUpdatedAt: Date.now(),
+    },
+  });
+  if (updated) {
+    triggerSystem.remove(params.id);
+    triggerSystem.add(updated);
+  }
+  return formatDynamicUpdateResult(params.id, updated?.dynamic?.iteration, nextWakeAt);
+}
+
+function stopDynamicLoop(
+  params: LoopUpdateParams,
+  store: LoopStoreLike,
+  triggerSystem: TriggerSystemLike,
+): string {
+  triggerSystem.remove(params.id);
+  if (params.status === "completed") {
+    store.delete(params.id);
+    return `Dynamic loop #${params.id} completed and deleted`;
+  }
+  store.pause(params.id);
+  return `Dynamic loop #${params.id} paused`;
+}
+
 export function registerLoopTools(options: LoopToolsOptions): void {
   const {
     pi,
@@ -219,11 +302,7 @@ Skip this tool when the task is a one-off check (just do it directly) or when th
       const bootstrapped = await maybeBootstrapTaskLoop(entry);
       updateWidget();
 
-      const triggerDesc = trigger.type === "cron"
-        ? `schedule: ${trigger.schedule}`
-        : trigger.type === "event"
-          ? `event: ${trigger.source}`
-          : `hybrid: cron ${trigger.cron} + event ${trigger.event.source}`;
+      const triggerDesc = formatTrigger(trigger, "create");
 
       return Promise.resolve(textResult(
         `Loop #${entry.id} created: ${entry.prompt.slice(0, 60)}\n` +
@@ -251,13 +330,9 @@ Use this before creating new loops to avoid duplicates, or to find IDs for LoopD
 
       const lines: string[] = [];
       for (const entry of loops) {
-        const triggerDesc = entry.trigger.type === "cron"
-          ? `cron: ${entry.trigger.schedule}`
-          : entry.trigger.type === "event"
-            ? `event: ${entry.trigger.source}`
-            : `hybrid: ${entry.trigger.cron} + ${entry.trigger.event.source}`;
+        const triggerDesc = formatTrigger(entry.trigger, "list");
 
-        const nextFire = entry.trigger.type !== "event" ? getScheduler().nextFire(entry.id) : undefined;
+        const nextFire = entry.trigger.type === "cron" || entry.trigger.type === "hybrid" || entry.dynamic?.nextWakeAt !== undefined ? getScheduler().nextFire(entry.id) : undefined;
         const statusIcon = entry.status === "active" ? "*" : entry.status === "paused" ? "-" : "x";
         let line = `${statusIcon} #${entry.id} [${entry.status}] ${entry.prompt.slice(0, 60)}`;
         line += ` (${triggerDesc})`;
@@ -274,6 +349,38 @@ Use this before creating new loops to avoid duplicates, or to find IDs for LoopD
     },
   });
 
+  pi.registerTool({
+    name: "LoopUpdate",
+    label: "LoopUpdate",
+    description: `Update progress for a dynamic loop.
+
+Use this after a dynamic loop wake. Mark status as "continue" with updated state/metrics and optional nextInterval, "completed" when the goal is done, or "paused" to stop temporarily.`,
+    parameters: Type.Object({
+      id: Type.String({ description: "Dynamic loop ID to update" }),
+      status: Type.String({ description: "continue, completed, or paused", enum: ["continue", "completed", "paused"] }),
+      state: Type.Optional(Type.String({ description: "Current progress/state summary" })),
+      metrics: Type.Optional(Type.String({ description: "Current metrics/check results" })),
+      doneCriteria: Type.Optional(Type.String({ description: "Definition of done for the dynamic loop" })),
+      nextInterval: Type.Optional(Type.String({ description: "When to wake next, e.g. 3m, 30s, 1h" })),
+      prompt: Type.Optional(Type.String({ description: "Optional updated goal/prompt text" })),
+    }),
+    execute(_toolCallId, params: LoopUpdateParams) {
+      const store = getStore();
+      const triggerSystem = getTriggerSystem();
+      const entry = store.get(params.id);
+      if (!entry) return Promise.resolve(textResult(`Loop #${params.id} not found`));
+      if (entry.trigger.type !== "dynamic" || !entry.dynamic) {
+        return Promise.resolve(textResult(`Loop #${params.id} is not a dynamic loop`));
+      }
+
+      const message = params.status === "continue"
+        ? continueDynamicLoop(params, entry as LoopEntry & { dynamic: NonNullable<LoopEntry["dynamic"]> }, store, triggerSystem)
+        : stopDynamicLoop(params, store, triggerSystem);
+      updateWidget();
+      return Promise.resolve(textResult(message));
+    },
+  });
+
   pi.registerTool({
     name: "LoopDelete",
     label: "LoopDelete",
@@ -289,7 +396,11 @@ Use "pause" to temporarily stop a loop without removing it. Use "delete" to perm
 
       if (action === "pause") {
         const entry = getStore().pause(id);
-        if (!entry) return Promise.resolve(textResult(`Loop #${id} not found`));
+        if (!entry) {
+          const tombstone = getStore().getDeletionTombstone(id);
+          if (tombstone) return Promise.resolve(textResult(formatDeletionTombstone(id, tombstone)));
+          return Promise.resolve(textResult(`Loop #${id} not found`));
+        }
         getTriggerSystem().remove(id);
         updateWidget();
         return Promise.resolve(textResult(`Loop #${id} paused`));
@@ -299,6 +410,8 @@ Use "pause" to temporarily stop a loop without removing it. Use "delete" to perm
       const deleted = getStore().delete(id);
       updateWidget();
       if (deleted) return Promise.resolve(textResult(`Loop #${id} deleted`));
+      const tombstone = getStore().getDeletionTombstone(id);
+      if (tombstone) return Promise.resolve(textResult(formatDeletionTombstone(id, tombstone)));
       return Promise.resolve(textResult(`Loop #${id} not found`));
     },
   });

package/src/tools/monitor-tools.ts

@@ -1,6 +1,7 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import type { LoopEntry, MonitorEntry, Trigger } from "../types.js";
+import { textResult } from "./tool-result.js";
 
 interface MonitorManagerLike {
   list(): MonitorEntry[];
@@ -26,10 +27,6 @@ export interface MonitorToolsOptions {
   handleMonitorDoneLoop: (doneLoop: LoopEntry, monitorId: string) => void;
 }
 
-function textResult(msg: string) {
-  return { content: [{ type: "text" as const, text: msg }], details: undefined as any };
-}
-
 function formatRemaining(ms: number): string {
   if (ms < 60000) return `${Math.round(ms / 1000)}s`;
   if (ms < 3600000) return `${Math.round(ms / 60000)}m`;

package/src/tools/native-task-tools.ts

@@ -1,12 +1,17 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
-import { emitNativeTaskEvent } from "../runtime/task-events.js";
+import {
+  createTask,
+  deleteTask,
+  type TaskBacklogResult,
+  type TaskMutationContext,
+  updateTask,
+} from "../runtime/task-mutations.js";
 import { TaskStore } from "../task-store.js";
+import type { TaskStatus } from "../task-types.js";
+import { textResult } from "./tool-result.js";
 
-export interface TaskBacklogResult {
-  created: boolean;
-  entry?: { id: string };
-}
+export type { TaskBacklogResult };
 
 export interface NativeTaskToolsOptions {
   pi: ExtensionAPI;
@@ -15,12 +20,15 @@ export interface NativeTaskToolsOptions {
   updateWidget: () => void;
 }
 
-function textResult(msg: string) {
-  return { content: [{ type: "text" as const, text: msg }], details: undefined as any };
+function backlogSuffix(backlog: TaskBacklogResult): string {
+  return backlog.created && backlog.entry
+    ? `\nBacklog worker loop #${backlog.entry.id} created`
+    : "";
 }
 
 export function registerNativeTaskTools(options: NativeTaskToolsOptions): void {
   const { pi, taskStore, evaluateTaskBacklog, updateWidget } = options;
+  const mutationCtx: TaskMutationContext = { pi, taskStore, evaluateTaskBacklog, updateWidget };
 
   pi.registerTool({
     name: "TaskCreate",
@@ -47,15 +55,11 @@ Fields:
       description: Type.String({ description: "Detailed description of what needs to be done" }),
     }),
     async execute(_toolCallId, params) {
-      const entry = taskStore.create(params.subject, params.description);
-      emitNativeTaskEvent(pi, "tasks:created", entry);
-      const backlog = await evaluateTaskBacklog(taskStore, taskStore.pendingCount());
-      updateWidget();
-
-      const autoLoopMsg = backlog.created && backlog.entry
-        ? `\nBacklog worker loop #${backlog.entry.id} created`
-        : "";
-      return Promise.resolve(textResult(`Task #${entry.id} created: ${entry.subject}${autoLoopMsg}`));
+      const { entry, backlog } = await createTask(mutationCtx, {
+        subject: params.subject,
+        description: params.description,
+      });
+      return textResult(`Task #${entry.id} created: ${entry.subject}${backlogSuffix(backlog)}`);
     },
   });
 
@@ -104,34 +108,15 @@ Parameters: id (required), status, subject, description`,
     }),
     async execute(_toolCallId, params) {
       const { id, status, subject, description } = params;
-      let entry = taskStore.get(id);
-      if (!entry) return Promise.resolve(textResult(`Task #${id} not found`));
-
-      const previousStatus = entry.status;
-      if (status === "in_progress") {
-        entry = taskStore.start(id);
-        if (entry) emitNativeTaskEvent(pi, "tasks:started", entry, previousStatus);
-      } else if (status === "completed") {
-        entry = taskStore.complete(id);
-        if (entry) emitNativeTaskEvent(pi, "tasks:completed", entry, previousStatus);
-      } else if (status === "pending") {
-        entry = taskStore.reopen(id);
-        if (entry) emitNativeTaskEvent(pi, "tasks:reopened", entry, previousStatus);
-      }
-
-      if (!entry) return Promise.resolve(textResult(`Task #${id} not found`));
-      if (subject !== undefined || description !== undefined) {
-        entry = taskStore.updateDetails(id, { subject, description });
-        if (entry) emitNativeTaskEvent(pi, "tasks:updated", entry, previousStatus);
-      }
-      if (!entry) return Promise.resolve(textResult(`Task #${id} not found`));
-      updateWidget();
-      const backlog = await evaluateTaskBacklog(taskStore, taskStore.pendingCount());
+      const result = await updateTask(mutationCtx, {
+        id,
+        status: status as TaskStatus | undefined,
+        subject,
+        description,
+      });
+      if (!result) return textResult(`Task #${id} not found`);
       const statusMsg = status ? ` → ${status}` : "";
-      const autoLoopMsg = backlog.created && backlog.entry
-        ? `\nBacklog worker loop #${backlog.entry.id} created`
-        : "";
-      return Promise.resolve(textResult(`Task #${id} updated${statusMsg}${autoLoopMsg}`));
+      return textResult(`Task #${id} updated${statusMsg}${backlogSuffix(result.backlog)}`);
     },
   });
 
@@ -143,15 +128,9 @@ Parameters: id (required), status, subject, description`,
       id: Type.String({ description: "Task ID to delete" }),
     }),
     async execute(_toolCallId, params) {
-      const existing = taskStore.get(params.id);
-      const deleted = taskStore.delete(params.id);
-      updateWidget();
-      if (deleted) {
-        if (existing) emitNativeTaskEvent(pi, "tasks:deleted", existing, existing.status);
-        await evaluateTaskBacklog(taskStore, taskStore.pendingCount());
-        return Promise.resolve(textResult(`Task #${params.id} deleted`));
-      }
-      return Promise.resolve(textResult(`Task #${params.id} not found`));
+      const result = await deleteTask(mutationCtx, params.id);
+      if (!result) return textResult(`Task #${params.id} not found`);
+      return textResult(`Task #${params.id} deleted`);
     },
   });
 }

package/src/tools/tool-result.ts

@@ -0,0 +1,4 @@
+/** Plain-text tool result in the shape pi's registerTool expects. */
+export function textResult(msg: string) {
+  return { content: [{ type: "text" as const, text: msg }], details: undefined };
+}

package/src/trigger-system.ts

@@ -31,7 +31,7 @@ export class TriggerSystem {
   }
 
   add(entry: LoopEntry): void {
-    if (entry.trigger.type === "cron" || entry.trigger.type === "hybrid") {
+    if (entry.trigger.type === "cron" || entry.trigger.type === "hybrid" || entry.trigger.type === "dynamic") {
       this.scheduler.add(entry);
     }
     if (entry.trigger.type === "event" || entry.trigger.type === "hybrid") {
@@ -58,7 +58,7 @@ export class TriggerSystem {
     }
     const subs = this.eventSubscriptions.get(source)!;
 
-    const unsub = this.pi.events.on(source as any, (data: any) => {
+    const unsub = this.pi.events.on(source, (data: unknown) => {
       if (entry.trigger.type === "hybrid") {
         this.handleHybridFire(entry, data);
       } else {
@@ -71,7 +71,7 @@ export class TriggerSystem {
     subs.set(entry.id, unsub);
   }
 
-  private handleHybridFire(entry: LoopEntry, _data: any): void {
+  private handleHybridFire(entry: LoopEntry, _data: unknown): void {
     const now = Date.now();
     const last = this.lastFireTime.get(entry.id) ?? 0;
     const debounceMs = entry.trigger.type === "hybrid" ? entry.trigger.debounceMs : 0;
@@ -123,7 +123,7 @@ export class TriggerSystem {
     }
   }
 
-  private matchesFilter(data: any, filter?: string): boolean {
+  private matchesFilter(data: unknown, filter?: string): boolean {
     if (!filter) return true;
 
     if (filter.startsWith("regex:")) {
@@ -138,7 +138,7 @@ export class TriggerSystem {
     try {
       const parsed = JSON.parse(filter);
       for (const [key, value] of Object.entries(parsed)) {
-        const dataValue = data?.[key];
+        const dataValue = (data as Record<string, unknown> | undefined)?.[key];
         if (dataValue === undefined) return false;
         if (typeof value === "object" && typeof dataValue === "object") {
           if (JSON.stringify(value) !== JSON.stringify(dataValue)) return false;

package/src/types.ts

@@ -1,3 +1,15 @@
+export type LoopDeletionReason = "task_backlog_empty";
+
+export interface LoopDeletionTombstone {
+  id: string;
+  reason: LoopDeletionReason;
+  deletedAt: number;
+  prompt: string;
+  pendingCount?: number;
+}
+
+export type LoopDeletionTombstoneInput = Omit<LoopDeletionTombstone, "id" | "deletedAt" | "prompt">;
+
 export type LoopStatus = "active" | "paused";
 
 export interface CronTrigger {
@@ -18,7 +30,22 @@ export interface HybridTrigger {
   debounceMs: number;
 }
 
-export type Trigger = CronTrigger | EventTrigger | HybridTrigger;
+export interface DynamicTrigger {
+  type: "dynamic";
+}
+
+export type Trigger = CronTrigger | EventTrigger | HybridTrigger | DynamicTrigger;
+
+export interface DynamicLoopState {
+  goal: string;
+  state?: string;
+  metrics?: string;
+  doneCriteria?: string;
+  iteration: number;
+  nextWakeAt?: number;
+  awaitingUpdate?: boolean;
+  lastUpdatedAt?: number;
+}
 
 export interface LoopEntry {
   id: string;
@@ -34,6 +61,7 @@ export interface LoopEntry {
   readOnly?: boolean;
   maxFires?: number;
   fireCount?: number;
+  dynamic?: DynamicLoopState;
 }
 
 export interface LoopStoreData {

package/.release-please-manifest.json

@@ -1,3 +0,0 @@
-{
-  ".": "0.5.8"
-}

package/AGENTS.md

@@ -1,83 +0,0 @@
-# pi-loop Development Guidelines
-
-## Overview
-`pi-loop` is a pi extension providing cron/event-based agent re-wake loops and background process monitoring. Modeled after Claude Code's `/loop`, `CronCreate`, and `MonitorCreate` tools.
-
-## Stack
-- TypeScript 6.x (strict, ES2022 target, bundler module resolution)
-- `typebox` for tool parameter validation
-- `vitest` for tests
-- `biome` for linting (linter: on, formatter: off)
-- npm packaging as `@trevonistrevon/pi-loop`
-
-## Architecture
-```
-src/
-├── index.ts              # Extension entry: 6 tools + /loop /loops commands + widget
-├── types.ts              # LoopKind, Trigger spec, LoopEntry, MonitorEntry, LoopConfig
-├── store.ts              # File-backed CRUD (.pi/loops/loops.json) with file locking
-├── scheduler.ts          # Timer-based cron scheduler with jitter + 7-day expiry
-├── trigger-system.ts     # Unified trigger engine: cron timers + pi event subscriptions + hybrid
-├── monitor-manager.ts    # ChildProcess tracking, output buffering, event emission, stop
-├── loop-parse.ts         # Human interval → cron expression, next-fire computation, jitter
-└── ui/
-    └── widget.ts         # Persistent widget: active loops + monitors
-```
-
-## Conventions (mirror pi-tasks)
-- No comments unless answering "why", never "what"
-- `debug(...)` helper gated on `PI_LOOP_DEBUG` env var, logs to stderr
-- `textResult(msg)` helper for uniform tool output
-- All tool params use `Type.Object()` with description strings
-- Tool descriptions follow Claude Code format: `## When to Use`, `## When NOT to Use`
-- Cross-extension communication via `pi.events` with `requestId` + reply channels
-- File-backed stores use atomic write (write tmp → rename) + pid-based file locking
-- Runtime tracker UI uses `UICtx.setStatus()` for compact single-line state
-- Tests co-located in `test/`, named `<module>.test.ts`
-
-## Tool Schema Discipline
-- Tool calls must use the exact schema field names from the tool definition. Do not invent aliases.
-- Example: `TaskUpdate` uses `id`, not `taskId`.
-- When a tool validation error clearly indicates an immediately recoverable schema mismatch, correct it silently and retry. Do not emit user-facing chatter like "retrying with the correct shape" unless the recovery itself changes the user's understanding.
-- When adding or revising tool prompt guidance, include concrete parameter-name reminders for commonly miscalled tools.
-
-## File Locking Pattern
-Copy TaskStore from pi-tasks: `O_EXCL` lockfile, stale PID detection, `LOCK_RETRY_MS`/`LOCK_MAX_RETRIES`
-
-## Trigger Types
-Three trigger types, all stored as `LoopEntry.trigger`:
-- `{ type: "cron", schedule: "*/5 * * * *" }` — timer-based
-- `{ type: "event", source: "tool_execution_start", filter?: "regex:..." | '{"key":"value"}' }` — eventbus-based
-- `{ type: "hybrid", cron: "...", event: { source, filter? }, debounceMs: 30000 }` — both with debounce
-
-All cron/hybrid loops are dynamic: they track their next fire time but only deliver on agent idle (`agent_end`/`turn_start`) rather than wall-clock timers.
-
-## Re-wake via In-Memory Pending Notifications
-When a loop fires, the scheduler calls `onLoopFire()` which emits `pi.events("loop:fire", ...)`. The extension buffers a pending notification in memory, re-checks whether the wake is still relevant, and only then injects a `pi.sendMessage()` custom message to wake the agent. Do not rely on early queued follow-up user messages for loop delivery; those are not extension-cancelable once handed to pi's queue.
-
-All loops are idle-driven. Cron and hybrid loops track their next fire time but only deliver when the agent becomes idle (via `agent_end`/`turn_start`), resetting their timer from the actual delivery point.
-
-## Monitor Streaming via PI Events
-Monitor stdout/stderr lines are emitted as `pi.events("monitor:output", { monitorId, line, timestamp })`. Tool consumers subscribe to these events. Completion emits `"monitor:done"` / `"monitor:error"`.
-
-## pi-tasks Integration
-When `@tintinweb/pi-tasks` is present, `LoopCreate` with `autoTask: true` fires an RPC to create a task. Communication via `pi.events`:
-- `tasks:rpc:ping` on init → detect pi-tasks presence
-- `tasks:ready` listener → late-binding detection
-- `tasks:rpc:create` → auto-create task when loop fires (if `autoTask: true`)
-
-## /loop Self-Paced Mode
-When no interval is specified in `/loop prompt`, the loop runs in self-paced mode. The agent receives the prompt, acts on it, and uses `LoopCreate`/`LoopUpdate` to schedule the next iteration. The loop fires once, then the agent decides the next interval dynamically (matching Claude Code's dynamic interval behavior).
-
-## Testing
-- `vitest` with `describe`/`it` blocks
-- In-memory stores for unit tests, `tmpdir` for file-backed tests
-- Fake timers (`vi.useFakeTimers`) for scheduler tests
-- Mock pi eventbus for monitor-manager tests
-- `vitest run` in CI, `vitest` for watch mode
-
-## Limits
-- Maximum 25 active loops
-- Maximum 25 running monitors
-- 7-day expiry on recurring loops
-- 5-minute default cron interval for self-paced mode

package/CONTRIBUTING.md

@@ -1,69 +0,0 @@
-# Contributing to @trevonistrevon/pi-loop
-
-Thanks for contributing! This document covers local dev setup, conventions, and workflow.
-
-## Getting Started
-
-```bash
-git clone https://github.com/trvon/pi-loop.git
-cd pi-loop
-npm install
-```
-
-## Scripts
-
-| Command | Description |
-|---|---|
-| `npm run typecheck` | TypeScript type checking (`tsc --noEmit`) |
-| `npm run lint` | Lint with Biome |
-| `npm run lint:fix` | Auto-fix lint issues |
-| `npm test` | Run tests (`vitest run`) |
-| `npm run test:watch` | Watch mode |
-| `npm run build` | Compile TypeScript |
-
-## Architecture
-
-See `AGENTS.md` for the full architecture overview. Key modules:
-
-- **`src/index.ts`** — Extension entry: registers 6 tools + `/loop` `/loops` commands + widget lifecycle
-- **`src/types.ts`** — Core types: `LoopEntry`, `MonitorEntry`, `Trigger` variants
-- **`src/store.ts`** — File-backed CRUD with pid-based file locking (atomic write → rename)
-- **`src/scheduler.ts`** — Timer-based cron scheduler with per-loop jitter and 7-day expiry
-- **`src/trigger-system.ts`** — Unified engine: cron timers + pi event subscriptions + hybrid debounce
-- **`src/monitor-manager.ts`** — `ChildProcess` wrapper: stdout/stderr streaming as pi events
-- **`src/loop-parse.ts`** — Human interval parsing (`5m` → cron), cron matching, next-fire computation
-- **`src/ui/widget.ts`** — TUI widget rendering active loops + monitors above the editor
-
-## Conventions
-
-- **TypeScript 6.x** strict mode, ES2022 target, bundler module resolution
-- **No comments unless answering "why"** — never "what"
-- **`debug(...)`** helper gated on `PI_LOOP_DEBUG` env var, logs to stderr
-- **`textResult(msg)`** helper for uniform tool output strings
-- **Tool params** use `Type.Object()` with description strings from `typebox`
-- **File-backed stores** use atomic write (write tmp → rename) + pid-based file locking
-
-## Testing
-
-Tests are co-located in `test/` as `<module>.test.ts`. The suite uses:
-
-- **vitest** with `describe`/`it`
-- In-memory stores for unit tests
-- `tmpdir` for file-backed store tests
-- `vi.useFakeTimers()` for scheduler tests
-- Mocked pi eventbus for monitor-manager tests
-
-```bash
-npm test            # Run once
-npm run test:watch  # Watch mode
-```
-
-## Pull Request Workflow
-
-1. Fork, branch, implement
-2. Ensure `npm run typecheck`, `npm run lint`, and `npm test` all pass
-3. Open PR against `main`
-
-## License
-
-By contributing, you agree that your contributions will be licensed under the MIT License.

package/Dockerfile

@@ -1,17 +0,0 @@
-FROM node:22-alpine AS base
-WORKDIR /app
-COPY package.json package-lock.json ./
-RUN npm ci
-COPY . .
-
-FROM node:20-alpine AS node20
-WORKDIR /app
-COPY package.json package-lock.json ./
-RUN npm ci
-COPY . .
-
-FROM node:22-alpine AS node22
-WORKDIR /app
-COPY package.json package-lock.json ./
-RUN npm ci
-COPY . .

package/benchmarks/experiment-sim.js

@@ -1,30 +0,0 @@
-#!/usr/bin/env node
-/**
- * Synthetic benchmark — mimics a research experiment with periodic progress output.
- * Prints "iteration N/M, metric=0.XX" every 200ms for 30 iterations.
- */
-
-const TOTAL = 30;
-const INTERVAL_MS = 200;
-
-let iteration = 0;
-
-const timer = setInterval(() => {
-  iteration++;
-  const metric = (Math.random() * 0.5 + 0.3).toFixed(4);
-  console.log(`iteration ${iteration}/${TOTAL}, loss=${metric}, timestamp=${Date.now()}`);
-
-  if (iteration >= TOTAL) {
-    console.log(`experiment complete: best loss=0.${Math.floor(Math.random() * 1000).toString().padStart(4, "0")}`);
-    clearInterval(timer);
-    process.exit(0);
-  }
-}, INTERVAL_MS);
-
-process.on("SIGTERM", () => {
-  console.log("experiment interrupted — saving checkpoint");
-  clearInterval(timer);
-  process.exit(0);
-});
-
-console.log("experiment starting: total_iterations=30, interval_ms=200");