@gotgenes/pi-subagents 1.0.2 → 2.0.0

package/CHANGELOG.md

@@ -5,6 +5,27 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.0.0](https://github.com/gotgenes/pi-packages/compare/pi-subagents-v1.0.2...pi-subagents-v2.0.0) (2026-05-17)
+
+
+### ⚠ BREAKING CHANGES
+
+* the `schedule` parameter is removed from the Agent tool. The `subagents:scheduled` and `subagents:scheduler_ready` events are no longer emitted. The `/agents → Settings → Scheduling` toggle is removed.
+* the `schedule` parameter is removed from the Agent tool and the `subagents:scheduled` / `subagents:scheduler_ready` events are no longer emitted. System cron (or launchd) invoking `pi` directly is the recommended replacement for recurring/delayed agent tasks.
+
+### Features
+
+* remove scheduled subagents source and tests ([860a03f](https://github.com/gotgenes/pi-packages/commit/860a03f08a6dbd418b437a72c2fd05ea416abacb))
+* remove scheduler wiring, types, and settings ([d5184e8](https://github.com/gotgenes/pi-packages/commit/d5184e88b181e60809b7fecc6a0971a18723bb9d))
+
+
+### Documentation
+
+* correct Module-Level Changes table in plan [#52](https://github.com/gotgenes/pi-packages/issues/52) (AGENTS.md → SKILL.md) ([93337e2](https://github.com/gotgenes/pi-packages/commit/93337e2a6b0424dc64e0adaf7a5c6ae6913c5991))
+* plan remove in-process scheduled subagents ([#52](https://github.com/gotgenes/pi-packages/issues/52)) ([bc548a4](https://github.com/gotgenes/pi-packages/commit/bc548a4dc6be4c5f810e9e33abcc76bc0d84f0da))
+* remove scheduling from README, architecture doc, and skill ([b2f16f2](https://github.com/gotgenes/pi-packages/commit/b2f16f2a53674a6a2675024dfc038c4243edd299))
+* **retro:** add retro notes for issue [#51](https://github.com/gotgenes/pi-packages/issues/51) ([0f741de](https://github.com/gotgenes/pi-packages/commit/0f741dedbe4a8e26fd1e39098fb153e4511082b9))
+
 ## [1.0.2](https://github.com/gotgenes/pi-packages/compare/pi-subagents-v1.0.1...pi-subagents-v1.0.2) (2026-05-17)
 
 

package/README.md

@@ -34,7 +34,6 @@ https://github.com/user-attachments/assets/8685261b-9338-4fea-8dfe-1c590d5df543
 - **Styled completion notifications** — background agent results render as themed, compact notification boxes (icon, stats, result preview) instead of raw XML. Expandable to show full output. Group completions render each agent individually
 - **Event bus** — lifecycle events (`subagents:created`, `started`, `completed`, `failed`, `steered`, `compacted`) emitted via `pi.events`, enabling other extensions to react to sub-agent activity
 - **Cross-extension RPC** — other pi extensions can spawn and stop subagents via the `pi.events` event bus (`subagents:rpc:ping`, `subagents:rpc:spawn`, `subagents:rpc:stop`). Standardized reply envelopes with protocol versioning. Emits `subagents:ready` on load
-- **Schedule subagents** — pass `schedule` to the `Agent` tool to fire on cron / interval / one-shot. Session-scoped jobs with PID-locked persistence; results land via the same `subagent-notification` followUp path as manual background completions; manage via `/agents → Scheduled jobs`
 
 ## Install
 
@@ -63,38 +62,6 @@ Agent({
 
 Foreground agents block until complete and return results inline. Background agents return an ID immediately and notify you on completion.
 
-### Scheduling
-
-Add a `schedule` field to register the agent to fire later instead of running now:
-
-```
-Agent({
-  subagent_type: "Explore",
-  prompt: "Look at recent commits and summarize what changed since last week",
-  description: "Weekly commit review",
-  schedule: "0 0 9 * * 1",   // 9am every Monday (6-field cron)
-})
-```
-
-Schedule formats:
-
-- **Cron** — 6-field (`second minute hour day-of-month month day-of-week`), e.g. `"0 0 9 * * 1"` for 9am every Monday, `"0 */15 * * * *"` for every 15 minutes.
-- **Interval** — `"5m"`, `"1h"`, `"30s"`, `"2d"`. Fires repeatedly at that interval.
-- **One-shot relative** — `"+10m"`, `"+2h"`, `"+1d"`. Fires once at that future time.
-- **One-shot absolute** — full ISO timestamp, e.g. `"2026-12-25T09:00:00.000Z"`.
-
-When a schedule fires, the spawn runs in background and its completion notification arrives in the conversation through the same `subagent-notification` followUp path as a manually-spawned background agent — your parent agent reasons about the result the same way.
-
-Schedules are **session-scoped**: they reset on `/new` and restore on `/resume`. List and cancel via `/agents → Scheduled jobs` (creation is the `Agent` tool's job — there is no parallel manual-create wizard). Storage at `<cwd>/.pi/subagent-schedules/<sessionId>.json` with PID-based file locking for cross-instance safety.
-
-**Disable the feature entirely**: `/agents → Settings → Scheduling → disabled` removes `schedule` from the `Agent` tool spec (no LLM-context cost), hides the menu entry, and stops any active scheduler. The schema-level removal takes effect on the next pi session; the runtime kill is immediate. Re-enable from the same menu.
-
-Restrictions:
-- `schedule` cannot be combined with `inherit_context` (no parent conversation exists at fire time) or `resume` (schedules create fresh agents).
-- `run_in_background` is forced to `true`.
-- Scheduled fires bypass the `maxConcurrent` queue so a 5-minute interval cannot be deferred behind long-running manual agents.
-- **Headless `pi -p` doesn't wait for scheduled subagents.**
-
 ## UI
 
 The extension renders a persistent widget above the editor showing all active agents:
@@ -351,8 +318,6 @@ Agent lifecycle events are emitted via `pi.events.emit()` so other extensions ca
 | `subagents:failed` | Agent errored, stopped, or aborted | same as completed + `error`, `status` |
 | `subagents:steered` | Steering message sent | `id`, `message` |
 | `subagents:compacted` | Agent's session successfully compacted | `id`, `type`, `description`, `reason` (`"manual"` / `"threshold"` / `"overflow"`), `tokensBefore`, `compactionCount` |
-| `subagents:scheduled` | Schedule lifecycle change | `{ type: "added" \| "removed" \| "updated" \| "fired" \| "error", … }` (job/agentId/error fields per type) |
-| `subagents:scheduler_ready` | Scheduler bound to session, enabled jobs armed | `sessionId`, `jobCount` |
 | `subagents:ready` | Extension loaded and RPC handlers registered | — |
 | `subagents:settings_loaded` | Persisted settings applied at extension init | `settings` (merged global + project) |
 | `subagents:settings_changed` | `/agents` → Settings mutation was applied | `settings`, `persisted` (`boolean` — `false` on write failure) |

package/docs/architecture/architecture.md

@@ -48,14 +48,11 @@ invocation-config.ts  — merge tool params with agent config
 output-file.ts        — JSONL transcript streaming
 settings.ts           — persistent operational settings
 
-schedule.ts           — cron/interval/one-shot job dispatch  ← removing
-schedule-store.ts     — file-backed schedule persistence     ← removing
 cross-extension-rpc.ts — RPC over pi.events                  ← replacing
 group-join.ts         — batch completion notifications
 
 ui/agent-widget.ts       — above-editor live status widget
 ui/conversation-viewer.ts — scrollable session overlay
-ui/schedule-menu.ts      — /agents schedule submenu          ← removing
 ```
 
 ### Coupling today
@@ -63,8 +60,7 @@ ui/schedule-menu.ts      — /agents schedule submenu          ← removing
 The widget reads agent state by holding a direct reference to
 `AgentManager` and polling a shared mutable `Map<string, AgentActivity>`
 every 80 ms. The conversation viewer subscribes directly to `AgentSession`
-objects. The scheduler holds a direct `AgentManager` reference and calls
-`manager.spawn()`.
+objects.
 
 Cross-extension consumers use an ad-hoc RPC layer over `pi.events`
 (`subagents:rpc:spawn`, `subagents:rpc:stop`, `subagents:rpc:ping`) with
@@ -342,10 +338,10 @@ Add the `SubagentsAPI` interface, serializable types, and `Symbol.for()`
 accessor functions as public exports of this package. No behavioral
 changes to the core yet.
 
-### Phase 2: Remove scheduling
+### Phase 2: Remove scheduling ✓ (done — issue #52)
 
-Delete `schedule.ts`, `schedule-store.ts`, `ui/schedule-menu.ts`. Remove
-the `schedule` parameter from the `Agent` tool schema. Remove scheduler
+Deleted `schedule.ts`, `schedule-store.ts`, `ui/schedule-menu.ts`. Removed
+the `schedule` parameter from the `Agent` tool schema. Removed scheduler
 setup and lifecycle hooks from `index.ts`.
 
 ### Phase 3: Remove group-join, output-file, ad-hoc RPC

package/docs/plans/0052-remove-scheduled-subagents.md

@@ -0,0 +1,131 @@
+---
+issue: 52
+issue_title: "feat: remove in-process scheduled subagents"
+---
+
+# Remove in-process scheduled subagents
+
+## Problem Statement
+
+The scheduling subsystem reimplements OS-level cron inside a process that is not designed to be a long-lived daemon.
+System cron (or launchd) invoking `pi` directly is strictly superior: it survives crashes and reboots, is inspectable via `crontab -l`, and adds zero lines of code to this extension.
+The current implementation weighs ~610 source lines plus ~820 test lines, a `croner` dependency, PID-locked file persistence, and scheduler lifecycle wiring scattered across `index.ts`.
+
+## Goals
+
+- Delete the three scheduling source files (`schedule.ts`, `schedule-store.ts`, `ui/schedule-menu.ts`).
+- Delete the three scheduling test files (`schedule.test.ts`, `schedule-store.test.ts`, `schedule-e2e.test.ts`).
+- Remove all scheduler wiring from `index.ts` (~200 lines of imports, lifecycle hooks, tool-schema gates, and menu routing).
+- Remove `ScheduledSubagent` and `ScheduleStoreData` interfaces from `types.ts`.
+- Remove `schedulingEnabled` from `SubagentsSettings`, `SettingsAppliers`, and related sanitize/apply logic in `settings.ts`.
+- Remove the `croner` dependency from `package.json`.
+- Update `README.md` (remove "Scheduling" section and events-table rows) and package `AGENTS.md` (remove scheduling modules from architecture diagram and tables).
+- This is a **breaking change** (`feat!:`) — the `schedule` parameter is removed from the `Agent` tool, and the `subagents:scheduled` / `subagents:scheduler_ready` events are no longer emitted.
+
+## Non-Goals
+
+- Removing `bypassQueue` from `SpawnOptions` in `agent-manager.ts` — it remains useful for cross-extension RPC callers.
+- Removing other subsystems slated for removal in the architecture doc (output-file, cross-extension-rpc, group-join) — those are separate issues.
+- Providing a migration path or compatibility shim — no known consumers depend on the scheduling events.
+
+## Background
+
+The architecture doc (`docs/architecture/architecture.md`) already marks `schedule.ts`, `schedule-store.ts`, and `ui/schedule-menu.ts` as `← removing`.
+This issue executes that plan.
+
+The scheduling code touches `index.ts` in several distinct regions:
+
+1. Imports (lines 27–28, 46)
+2. Scheduler instance creation and `startScheduler()` helper (lines 445–462)
+3. Lifecycle hooks: `session_start`, `session_before_switch`, `session_shutdown` (lines 470–496)
+4. The `schedule` tool-schema param shape, conditional inclusion, and guideline string (lines 621–640, 666, 719)
+5. Schedule execution path in the Agent tool handler (lines 880–918)
+6. `/agents` menu: "Scheduled jobs" entry and routing (lines 1297–1327)
+7. `/agents → Settings → Scheduling` toggle (lines 1855–1867)
+
+The `settings.ts` module has `schedulingEnabled` woven into `SubagentsSettings`, `SettingsAppliers`, `sanitize()`, and `applySettings()`.
+
+`types.ts` carries `ScheduledSubagent` (30 lines) and `ScheduleStoreData` (5 lines) — both are only consumed by the scheduling subsystem.
+
+## Design Overview
+
+This is a pure deletion change with no new abstractions.
+The approach is inside-out: delete leaf modules first (no dependents), then remove references from the wiring layer (`index.ts`, `settings.ts`, `types.ts`), then clean up docs.
+
+The `bypassQueue` option on `SpawnOptions` stays — its JSDoc comment mentioning "scheduler" should be updated to a generic description since the scheduler is the only current user but the option is architecturally useful for any caller that needs to skip the concurrency queue.
+
+## Module-Level Changes
+
+### Delete
+
+| File                          | Lines |
+| ----------------------------- | ----- |
+| `src/schedule.ts`             | 365   |
+| `src/schedule-store.ts`       | 143   |
+| `src/ui/schedule-menu.ts`     | 104   |
+| `test/schedule.test.ts`       | 429   |
+| `test/schedule-store.test.ts` | 154   |
+| `test/schedule-e2e.test.ts`   | 237   |
+
+### Modify
+
+| File                                       | Change                                                                                                                                                                                                                                                                       |
+| ------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `src/index.ts`                             | Remove scheduler imports, instance creation, `startScheduler()`, lifecycle hooks, `scheduleParamShape`/`scheduleParam`/`scheduleGuideline`, schedule execution path in Agent handler, "Scheduled jobs" menu entry + routing, "Scheduling" settings toggle.                   |
+| `src/types.ts`                             | Remove `ScheduledSubagent` interface and `ScheduleStoreData` interface.                                                                                                                                                                                                      |
+| `src/settings.ts`                          | Remove `schedulingEnabled` from `SubagentsSettings` and `SettingsAppliers`. Remove sanitize clause and `applySettings` clause for `schedulingEnabled`.                                                                                                                       |
+| `src/agent-manager.ts`                     | Update `bypassQueue` JSDoc to remove scheduler-specific language.                                                                                                                                                                                                            |
+| `package.json`                             | Remove `"croner": "^10.0.1"` from dependencies.                                                                                                                                                                                                                              |
+| `README.md`                                | Remove "Scheduling" feature bullet, "Scheduling" subsection (lines 66–96), and `subagents:scheduled` / `subagents:scheduler_ready` rows from the events table.                                                                                                               |
+| `.pi/skills/package-pi-subagents/SKILL.md` | Remove `schedule.ts`, `schedule-store.ts`, `ui/schedule-menu.ts` from the architecture diagram and module tables. Update `index.ts` description to drop scheduler mention. (`packages/pi-subagents/AGENTS.md` is a stub — the architecture content lives in the skill file.) |
+
+## Test Impact Analysis
+
+1. No new unit tests are needed — this is pure deletion.
+2. All three scheduling test files (`schedule.test.ts`, `schedule-store.test.ts`, `schedule-e2e.test.ts`) become entirely redundant and are deleted.
+3. Existing tests for `agent-manager`, `agent-runner`, `settings`, and other modules stay as-is. The `settings.test.ts` file (if it exists) may need minor updates to remove `schedulingEnabled` from fixture data.
+
+## TDD Order
+
+Since this is a removal (not a feature), the order is deletion-first with a single validation pass.
+
+1. **Delete scheduling source files.**
+   Delete `src/schedule.ts`, `src/schedule-store.ts`, `src/ui/schedule-menu.ts`.
+   Delete `test/schedule.test.ts`, `test/schedule-store.test.ts`, `test/schedule-e2e.test.ts`.
+   Commit: `feat!: remove scheduled subagents source and tests`
+
+2. **Remove scheduler wiring from `index.ts`.**
+   Remove imports, scheduler instance, `startScheduler()`, lifecycle hooks, schedule-related tool schema params and guideline, schedule execution path in Agent handler, "Scheduled jobs" menu entry/routing, and "Scheduling" settings toggle.
+   Commit: `feat!: remove scheduler wiring from index.ts`
+
+3. **Clean up types and settings.**
+   Remove `ScheduledSubagent` and `ScheduleStoreData` from `types.ts`.
+   Remove `schedulingEnabled` from `SubagentsSettings`, `SettingsAppliers`, `sanitize()`, and `applySettings()` in `settings.ts`.
+   Update `bypassQueue` JSDoc in `agent-manager.ts`.
+   Commit: `feat!: remove scheduling types and settings`
+
+4. **Remove `croner` dependency.**
+   Remove from `package.json`, run `pnpm install` to update lockfile.
+   Commit: `build: remove croner dependency`
+
+5. **Verify all tests pass.**
+   Run `pnpm vitest run` in the package. Fix any test fixtures that reference `schedulingEnabled` or scheduling types.
+   Commit (if fixes needed): `test: remove scheduling references from test fixtures`
+
+6. **Update documentation.**
+   Update `README.md`: remove scheduling feature bullet, "Scheduling" subsection, and event-table rows.
+   Update package `AGENTS.md`: remove scheduling modules from architecture diagram and module tables, update `index.ts` description.
+   Commit: `docs: remove scheduling from README and AGENTS`
+
+## Risks and Mitigations
+
+| Risk                                             | Mitigation                                                                                                                         |
+| ------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------- |
+| Missed scheduling reference causes compile error | `grep -rn 'schedule\|Schedule\|croner' src/` after each step to catch stragglers. TypeScript `noEmit` check catches import errors. |
+| Test fixtures reference `schedulingEnabled`      | Step 5 explicitly scans for and fixes these.                                                                                       |
+| `bypassQueue` removal mistakenly included        | Explicitly excluded in Non-Goals; plan preserves the option and only updates its JSDoc.                                            |
+| Breaking change not communicated                 | `feat!:` commit prefix triggers a major version bump via release-please.                                                           |
+
+## Open Questions
+
+None — the issue scope is fully specified and the architecture doc already ratified this removal.

package/docs/retro/0051-update-adr-0001-hard-fork.md

@@ -0,0 +1,33 @@
+---
+issue: 51
+issue_title: "docs: update ADR 0001 to reflect hard-fork decision"
+---
+
+# Retro: #51 — docs: update ADR 0001 to reflect hard-fork decision
+
+## Final Retrospective (2026-05-16)
+
+### Session summary
+
+Updated ADR 0001 (`docs/decisions/0001-deferred-patches.md`) to reflect the hard-fork decision documented in `docs/architecture/architecture.md`.
+The change was planned, implemented, shipped, and released as `pi-subagents-v1.0.2` in a single clean pass with no rework.
+
+### Observations
+
+#### What went well
+
+- The entire plan→build→ship pipeline completed with zero corrections, zero CI failures, and zero user interventions.
+- Parallel context gathering (issue body, `AGENTS.md`, ADR file, architecture doc, two skill files) in one tool call made the planning phase efficient.
+- The 4-edit approach (`Edit` with a single call containing four `edits[]` entries) was well-matched to the task — each edit was small, unique, and non-overlapping.
+
+#### What caused friction (agent side)
+
+- No friction observed. The task was unambiguous and the tooling well-suited.
+
+#### What caused friction (user side)
+
+- No friction observed. The session required no user input beyond invoking the three slash commands.
+
+### Follow-ups identified
+
+- The `package-pi-subagents` skill (`.pi/skills/package-pi-subagents/SKILL.md`) still frames the fork as "a friendly fork… carrying a small number of patches" with priorities like "stays as close to upstream as possible." This framing is now stale given the hard-fork commitment. A separate issue should update the skill to reflect the architecture document's posture.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gotgenes/pi-subagents",
-  "version": "1.0.2",
+  "version": "2.0.0",
   "description": "A pi extension that brings Claude Code-style autonomous sub-agents to pi. Friendly fork of @tintinweb/pi-subagents.",
   "author": {
     "name": "Chris Lasher"
@@ -33,7 +33,6 @@
   },
   "dependencies": {
     "@sinclair/typebox": "^0.34.49",
-    "croner": "^10.0.1",
     "nanoid": "^5.0.0"
   },
   "engines": {

package/src/agent-manager.ts

@@ -40,8 +40,8 @@ interface SpawnOptions {
   isBackground?: boolean;
   /**
    * Skip the maxConcurrent queue check for this spawn — start immediately even
-   * if the configured concurrency limit would otherwise queue it. Used by the
-   * scheduler so a fired job can't be deferred past its trigger window.
+   * if the configured concurrency limit would otherwise queue it. Useful for
+   * callers (e.g. cross-extension RPC) that must not be deferred by the queue.
    */
   bypassQueue?: boolean;
   /** Isolation mode — "worktree" creates a temp git worktree for the agent. */

package/src/index.ts

@@ -24,8 +24,6 @@ import { GroupJoinManager } from "./group-join.js";
 import { resolveAgentInvocationConfig, resolveJoinMode } from "./invocation-config.js";
 import { type ModelRegistry, resolveModel } from "./model-resolver.js";
 import { createOutputFilePath, streamToOutputFile, writeInitialEntry } from "./output-file.js";
-import { SubagentScheduler } from "./schedule.js";
-import { resolveStorePath, ScheduleStore } from "./schedule-store.js";
 import { applyAndEmitLoaded, type SubagentsSettings, saveAndEmitChanged } from "./settings.js";
 import { type AgentConfig, type AgentInvocation, type AgentRecord, type JoinMode, type NotificationDetails, type SubagentType } from "./types.js";
 import {
@@ -43,7 +41,6 @@ import {
   SPINNER,
   type UICtx,
 } from "./ui/agent-widget.js";
-import { showSchedulesMenu } from "./ui/schedule-menu.js";
 import { addUsage, getLifetimeTotal, getSessionContextPercent, type LifetimeUsage } from "./usage.js";
 
 // ---- Shared helpers ----
@@ -442,37 +439,14 @@ export default function (pi: ExtensionAPI) {
   // --- Cross-extension RPC via pi.events ---
   let currentCtx: ExtensionContext | undefined;
 
-  // ---- Subagent scheduler ----
-  // Session-scoped: store is constructed inside session_start once sessionId
-  // is available. Mirrors pi-chonky-tasks's session-scoped task store —
-  // schedules reset on /new, restore on /resume.
-  const scheduler = new SubagentScheduler();
-
-  function startScheduler(ctx: ExtensionContext) {
-    try {
-      const sessionId = ctx.sessionManager?.getSessionId?.();
-      if (!sessionId) return;  // sessionId not yet available — try again on next event
-      const path = resolveStorePath(ctx.cwd, sessionId);
-      const store = new ScheduleStore(path);
-      scheduler.start(pi, ctx, manager, store);
-      pi.events.emit("subagents:scheduler_ready", { sessionId, jobCount: store.list().length });
-    } catch (err) {
-      // Scheduling is non-essential — log and move on so the rest of the
-      // extension keeps working if e.g. .pi/ is unwritable.
-      console.warn("[pi-subagents] Failed to start scheduler:", err);
-    }
-  }
-
-  // Capture ctx from session_start for RPC spawn handler + start the scheduler.
+  // Capture ctx from session_start for RPC spawn handler.
   pi.on("session_start", async (_event, ctx) => {
     currentCtx = ctx;
     manager.clearCompleted();
-    if (isSchedulingEnabled() && !scheduler.isActive()) startScheduler(ctx);
   });
 
   pi.on("session_before_switch", () => {
     manager.clearCompleted();
-    scheduler.stop();
   });
 
   const { unsubPing: unsubPingRpc, unsubSpawn: unsubSpawnRpc, unsubStop: unsubStopRpc } = registerRpcHandlers({
@@ -493,7 +467,6 @@ export default function (pi: ExtensionAPI) {
     unsubPingRpc();
     currentCtx = undefined;
     delete (globalThis as any)[MANAGER_KEY];
-    scheduler.stop();
     manager.abortAll();
     for (const timer of pendingNudges.values()) clearTimeout(timer);
     pendingNudges.clear();
@@ -508,15 +481,6 @@ export default function (pi: ExtensionAPI) {
   function getDefaultJoinMode(): JoinMode { return defaultJoinMode; }
   function setDefaultJoinMode(mode: JoinMode) { defaultJoinMode = mode; }
 
-  // Master switch for the schedule subagent feature. Defaults to enabled.
-  // Read once at extension init (before tool registration) so the Agent tool's
-  // param schema reflects the persisted setting. Runtime toggles via /agents
-  // → Settings short-circuit the menu entry + the execute-time addJob path
-  // immediately, but the schema-level removal only takes effect on next
-  // extension load (next pi session). Documented in CHANGELOG/README.
-  let schedulingEnabled = true;
-  function isSchedulingEnabled(): boolean { return schedulingEnabled; }
-  function setSchedulingEnabled(b: boolean) { schedulingEnabled = b; }
 
   // ---- Batch tracking for smart join mode ----
   // Collects background agent IDs spawned in the current turn for smart grouping.
@@ -611,35 +575,12 @@ export default function (pi: ExtensionAPI) {
       setDefaultMaxTurns,
       setGraceTurns,
       setDefaultJoinMode,
-      setSchedulingEnabled,
     },
     (event, payload) => pi.events.emit(event, payload),
   );
 
   // ---- Agent tool ----
 
-  // Schedule param + its guideline are gated on `schedulingEnabled` (read once
-  // at registration; flipping the setting later requires next pi session for
-  // the schema to update). Defining the shape once and spreading it via Partial
-  // preserves Type.Object's inference when present and produces a
-  // `schedule`-free schema when absent — zero LLM-context cost in disabled mode.
-  const scheduleParamShape = {
-    schedule: Type.Optional(
-      Type.String({
-        description:
-          'Opt-in only — fire later instead of now. Omit to run immediately (the default, almost always correct). ' +
-          'Formats: 6-field cron ("0 0 9 * * 1" = 9am Mon), interval ("5m"/"1h"), one-shot ("+10m" or ISO). ' +
-          'Forces run_in_background; incompatible with inherit_context and resume. Returns job ID.',
-      }),
-    ),
-  };
-  const scheduleParam: Partial<typeof scheduleParamShape> =
-    isSchedulingEnabled() ? scheduleParamShape : {};
-
-  const scheduleGuideline = isSchedulingEnabled()
-    ? `\n- Use \`schedule\` only when the user explicitly asked for scheduled / recurring / delayed execution (e.g. "every Monday", "in an hour"). Don't auto-schedule from vague intent like "monitor X" — run once now or ask.`
-    : "";
-
   pi.registerTool(defineTool({
     name: "Agent",
     label: "Agent",
@@ -663,7 +604,7 @@ Guidelines:
 - Use model to specify a different model (as "provider/modelId", or fuzzy e.g. "haiku", "sonnet").
 - Use thinking to control extended thinking level.
 - Use inherit_context if the agent needs the parent conversation history.
-- Use isolation: "worktree" to run the agent in an isolated git worktree (safe parallel file modifications).${scheduleGuideline}`,
+- Use isolation: "worktree" to run the agent in an isolated git worktree (safe parallel file modifications).`,
     parameters: Type.Object({
       prompt: Type.String({
         description: "The task for the agent to perform.",
@@ -716,7 +657,6 @@ Guidelines:
           description: 'Set to "worktree" to run the agent in a temporary git worktree (isolated copy of the repo). Changes are saved to a branch on completion.',
         }),
       ),
-      ...scheduleParam,
     }),
 
     // ---- Custom rendering: Claude Code style ----
@@ -877,47 +817,6 @@ Guidelines:
         tags: agentTags.length > 0 ? agentTags : undefined,
       };
 
-      // ---- Schedule: register a job, don't spawn now ----
-      if (params.schedule) {
-        if (!isSchedulingEnabled()) {
-          return textResult("Scheduling is disabled in this project. Enable via /agents → Settings → Scheduling.");
-        }
-        if (params.resume) {
-          return textResult("Cannot combine `schedule` with `resume` — schedules create fresh agents.");
-        }
-        if (params.inherit_context) {
-          return textResult("Cannot combine `schedule` with `inherit_context` — there is no parent conversation at fire time.");
-        }
-        if (params.run_in_background === false) {
-          return textResult("Cannot combine `schedule` with `run_in_background: false` — scheduled jobs always run in background.");
-        }
-        if (!scheduler.isActive()) {
-          return textResult("Scheduler is not active in this session yet. Try again after the session has fully started.");
-        }
-        try {
-          const job = scheduler.addJob({
-            name: params.description as string,
-            description: params.description as string,
-            schedule: params.schedule as string,
-            subagent_type: subagentType,
-            prompt: params.prompt as string,
-            model: params.model as string | undefined,
-            thinking: thinking,
-            max_turns: effectiveMaxTurns,
-            isolated: isolated,
-            isolation: isolation,
-          });
-          const next = scheduler.getNextRun(job.id);
-          return textResult(
-            `Scheduled "${job.name}" (id: ${job.id}, type: ${job.scheduleType}). ` +
-            `Next run: ${next ?? "(unknown)"}. ` +
-            `Manage via /agents → Scheduled jobs.`,
-          );
-        } catch (err) {
-          return textResult(err instanceof Error ? err.message : String(err));
-        }
-      }
-
       // Resume existing agent
       if (params.resume) {
         const existing = manager.getRecord(params.resume);
@@ -1294,12 +1193,6 @@ Guidelines:
       options.push(`Agent types (${allNames.length})`);
     }
 
-    // Scheduled jobs entry (always present when scheduler is active)
-    if (scheduler.isActive()) {
-      const jobCount = scheduler.list().length;
-      options.push(`Scheduled jobs (${jobCount})`);
-    }
-
     // Actions
     options.push("Create new agent");
     options.push("Settings");
@@ -1323,9 +1216,6 @@ Guidelines:
     } else if (choice.startsWith("Agent types (")) {
       await showAllAgentsList(ctx);
       await showAgentsMenu(ctx);
-    } else if (choice.startsWith("Scheduled jobs (")) {
-      await showSchedulesMenu(ctx, scheduler);
-      await showAgentsMenu(ctx);
     } else if (choice === "Create new agent") {
       await showCreateWizard(ctx);
     } else if (choice === "Settings") {
@@ -1789,7 +1679,6 @@ ${systemPrompt}
       defaultMaxTurns: getDefaultMaxTurns() ?? 0,
       graceTurns: getGraceTurns(),
       defaultJoinMode: getDefaultJoinMode(),
-      schedulingEnabled: isSchedulingEnabled(),
     };
   }
 
@@ -1799,7 +1688,6 @@ ${systemPrompt}
       `Default max turns (current: ${getDefaultMaxTurns() ?? "unlimited"})`,
       `Grace turns (current: ${getGraceTurns()})`,
       `Join mode (current: ${getDefaultJoinMode()})`,
-      `Scheduling (current: ${isSchedulingEnabled() ? "enabled" : "disabled"})`,
     ]);
     if (!choice) return;
 
@@ -1850,27 +1738,6 @@ ${systemPrompt}
         setDefaultJoinMode(mode);
         notifyApplied(ctx, `Default join mode set to ${mode}`);
       }
-    } else if (choice.startsWith("Scheduling")) {
-      const val = await ctx.ui.select(
-        "Schedule subagent feature",
-        [
-          "enabled — Agent tool accepts a `schedule` param; /agents → Scheduled jobs visible",
-          "disabled — `schedule` removed from Agent tool spec (no LLM-context cost); menu hidden",
-        ],
-      );
-      if (val) {
-        const enabled = val.startsWith("enabled");
-        if (enabled === isSchedulingEnabled()) {
-          ctx.ui.notify(`Scheduling already ${enabled ? "enabled" : "disabled"}.`, "info");
-        } else {
-          setSchedulingEnabled(enabled);
-          if (!enabled) scheduler.stop();  // immediate kill — outstanding fires stop ticking
-          notifyApplied(
-            ctx,
-            `Scheduling ${enabled ? "enabled" : "disabled"}. Tool spec change takes effect on next pi session.`,
-          );
-        }
-      }
     }
   }
 

package/src/settings.ts

@@ -17,15 +17,6 @@ export interface SubagentsSettings {
   defaultMaxTurns?: number;
   graceTurns?: number;
   defaultJoinMode?: JoinMode;
-  /**
-   * Master switch for the schedule subagent feature. Defaults to `true`.
-   * When `false`: the `Agent` tool's `schedule` param + its guideline are
-   * stripped from the tool spec at registration (zero LLM-context cost), the
-   * scheduler doesn't bind to the session, and the `/agents → Scheduled jobs`
-   * menu entry is hidden. Schema-level removal applies at extension load
-   * (next pi session); runtime menu/runtime-fire short-circuit is immediate.
-   */
-  schedulingEnabled?: boolean;
 }
 
 /** Setter hooks used by applySettings to wire persisted values into in-memory state. */
@@ -34,7 +25,6 @@ export interface SettingsAppliers {
   setDefaultMaxTurns: (n: number) => void;
   setGraceTurns: (n: number) => void;
   setDefaultJoinMode: (mode: JoinMode) => void;
-  setSchedulingEnabled: (b: boolean) => void;
 }
 
 /** Emit callback — a subset of `pi.events.emit` to keep helpers testable. */
@@ -78,9 +68,6 @@ function sanitize(raw: unknown): SubagentsSettings {
   if (typeof r.defaultJoinMode === "string" && VALID_JOIN_MODES.has(r.defaultJoinMode)) {
     out.defaultJoinMode = r.defaultJoinMode as JoinMode;
   }
-  if (typeof r.schedulingEnabled === "boolean") {
-    out.schedulingEnabled = r.schedulingEnabled;
-  }
   return out;
 }
 
@@ -135,7 +122,6 @@ export function applySettings(s: SubagentsSettings, appliers: SettingsAppliers):
   if (typeof s.defaultMaxTurns === "number") appliers.setDefaultMaxTurns(s.defaultMaxTurns);
   if (typeof s.graceTurns === "number") appliers.setGraceTurns(s.graceTurns);
   if (s.defaultJoinMode) appliers.setDefaultJoinMode(s.defaultJoinMode);
-  if (typeof s.schedulingEnabled === "boolean") appliers.setSchedulingEnabled(s.schedulingEnabled);
 }
 
 /**

package/src/types.ts

@@ -131,46 +131,3 @@ export interface EnvInfo {
   branch: string;
   platform: string;
 }
-
-/**
- * A subagent spawn registered to fire on a schedule.
- *
- * Stored at `<cwd>/.pi/subagent-schedules/<sessionId>.json`. Session-scoped:
- * survives `/resume` but resets on `/new`, mirroring pi-chonky-tasks.
- */
-export interface ScheduledSubagent {
-  id: string;
-  /** Unique within store. Defaults to `description`. */
-  name: string;
-  description: string;
-  /** Raw user input — cron expr | "+10m" | ISO | "5m". */
-  schedule: string;
-  scheduleType: "cron" | "once" | "interval";
-  /** Computed at create time for interval/once. */
-  intervalMs?: number;
-
-  // spawn params (subset of Agent tool params; no inherit_context, no resume)
-  subagent_type: SubagentType;
-  prompt: string;
-  model?: string;
-  thinking?: ThinkingLevel;
-  max_turns?: number;
-  isolated?: boolean;
-  isolation?: IsolationMode;
-
-  // state
-  enabled: boolean;
-  /** ISO timestamp. */
-  createdAt: string;
-  lastRun?: string;
-  lastStatus?: "success" | "error" | "running";
-  /** Refreshed on every fire and on store load. */
-  nextRun?: string;
-  runCount: number;
-}
-
-export interface ScheduleStoreData {
-  /** For future migrations. */
-  version: 1;
-  jobs: ScheduledSubagent[];
-}

package/src/schedule-store.ts

@@ -1,143 +0,0 @@
-/**
- * schedule-store.ts — File-backed store for scheduled subagents.
- *
- * Session-scoped: each pi session owns its own schedules at
- * `<cwd>/.pi/subagent-schedules/<sessionId>.json`. `/new` starts a fresh
- * empty store; `/resume` reloads.
- *
- * Concurrency model lifted from pi-chonky-tasks/src/task-store.ts: every
- * mutation acquires a PID-based exclusion lock, re-reads the latest state
- * from disk, applies the change, atomic-writes via temp+rename, releases.
- */
-
-import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import type { ScheduledSubagent, ScheduleStoreData } from "./types.js";
-
-const LOCK_RETRY_MS = 50;
-const LOCK_MAX_RETRIES = 100;
-
-function isProcessRunning(pid: number): boolean {
-  try { process.kill(pid, 0); return true; } catch { return false; }
-}
-
-function acquireLock(lockPath: string): void {
-  for (let i = 0; i < LOCK_MAX_RETRIES; i++) {
-    try {
-      writeFileSync(lockPath, `${process.pid}`, { flag: "wx" });
-      return;
-    } catch (e: any) {
-      if (e.code === "EEXIST") {
-        try {
-          const pid = parseInt(readFileSync(lockPath, "utf-8"), 10);
-          if (pid && !isProcessRunning(pid)) {
-            unlinkSync(lockPath);
-            continue;
-          }
-        } catch { /* ignore — try again */ }
-        const start = Date.now();
-        while (Date.now() - start < LOCK_RETRY_MS) { /* busy wait */ }
-        continue;
-      }
-      throw e;
-    }
-  }
-  throw new Error(`Failed to acquire schedule lock: ${lockPath}`);
-}
-
-function releaseLock(lockPath: string): void {
-  try { unlinkSync(lockPath); } catch { /* ignore */ }
-}
-
-/** Resolve the storage path for a session-scoped store. */
-export function resolveStorePath(cwd: string, sessionId: string): string {
-  return join(cwd, ".pi", "subagent-schedules", `${sessionId}.json`);
-}
-
-export class ScheduleStore {
-  private filePath: string;
-  private lockPath: string;
-  private jobs = new Map<string, ScheduledSubagent>();
-
-  constructor(filePath: string) {
-    this.filePath = filePath;
-    this.lockPath = filePath + ".lock";
-    mkdirSync(dirname(filePath), { recursive: true });
-    this.load();
-  }
-
-  /** Load from disk into the in-memory cache. Silent on parse errors. */
-  private load(): void {
-    if (!existsSync(this.filePath)) return;
-    try {
-      const data: ScheduleStoreData = JSON.parse(readFileSync(this.filePath, "utf-8"));
-      this.jobs.clear();
-      for (const j of data.jobs ?? []) this.jobs.set(j.id, j);
-    } catch { /* corrupt — start fresh, next save rewrites */ }
-  }
-
-  /** Atomic write via temp file + rename (POSIX-atomic). */
-  private save(): void {
-    const data: ScheduleStoreData = { version: 1, jobs: [...this.jobs.values()] };
-    const tmp = this.filePath + ".tmp";
-    writeFileSync(tmp, JSON.stringify(data, null, 2));
-    renameSync(tmp, this.filePath);
-  }
-
-  /** Acquire lock → reload → mutate → save → release. */
-  private withLock<T>(fn: () => T): T {
-    acquireLock(this.lockPath);
-    try {
-      this.load();
-      const result = fn();
-      this.save();
-      return result;
-    } finally {
-      releaseLock(this.lockPath);
-    }
-  }
-
-  /** Read-only — returns a snapshot of the in-memory cache. */
-  list(): ScheduledSubagent[] {
-    return [...this.jobs.values()];
-  }
-
-  /** Read-only check — uses the cache. */
-  hasName(name: string, exceptId?: string): boolean {
-    for (const j of this.jobs.values()) {
-      if (j.id !== exceptId && j.name === name) return true;
-    }
-    return false;
-  }
-
-  get(id: string): ScheduledSubagent | undefined {
-    return this.jobs.get(id);
-  }
-
-  add(job: ScheduledSubagent): void {
-    this.withLock(() => {
-      this.jobs.set(job.id, job);
-    });
-  }
-
-  update(id: string, patch: Partial<ScheduledSubagent>): ScheduledSubagent | undefined {
-    return this.withLock(() => {
-      const existing = this.jobs.get(id);
-      if (!existing) return undefined;
-      const updated = { ...existing, ...patch };
-      this.jobs.set(id, updated);
-      return updated;
-    });
-  }
-
-  remove(id: string): boolean {
-    return this.withLock(() => this.jobs.delete(id));
-  }
-
-  /** Delete the backing file (used when no jobs remain, optional cleanup). */
-  deleteFileIfEmpty(): void {
-    if (this.jobs.size === 0 && existsSync(this.filePath)) {
-      try { unlinkSync(this.filePath); } catch { /* ignore */ }
-    }
-  }
-}

package/src/schedule.ts

@@ -1,365 +0,0 @@
-/**
- * schedule.ts — `SubagentScheduler`: timer-driven dispatcher of scheduled subagents.
- *
- * Mirrors the engine shape of pi-cron-schedule/src/scheduler.ts:
- *   - two-Map split (jobs = croner Cron, intervals = setInterval/setTimeout)
- *   - addJob/removeJob/updateJob/scheduleJob/unscheduleJob/executeJob
- *   - static parsers for cron / "+10m" / "5m" / ISO formats
- *
- * Differences vs pi-cron-schedule:
- *   - Persistence is via ScheduleStore (PID-locked, session-scoped, atomic).
- *   - `executeJob` calls `manager.spawn(..., { bypassQueue: true })` instead
- *     of dispatching a user message — schedule fires bypass maxConcurrent so
- *     a 5-minute interval can't be deferred behind 4 long-running agents.
- *   - Result delivery is implicit: spawn → background completion → existing
- *     `subagent-notification` followUp path. No new delivery code.
- */
-
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { Cron } from "croner";
-import { nanoid } from "nanoid";
-import type { AgentManager } from "./agent-manager.js";
-import { resolveModel } from "./model-resolver.js";
-import type { ScheduleStore } from "./schedule-store.js";
-import type { IsolationMode, ScheduledSubagent, SubagentType, ThinkingLevel } from "./types.js";
-
-/** Event emitted on `pi.events` for cross-extension consumers. */
-export type ScheduleChangeEvent =
-  | { type: "added"; job: ScheduledSubagent }
-  | { type: "removed"; jobId: string }
-  | { type: "updated"; job: ScheduledSubagent }
-  | { type: "fired"; jobId: string; agentId: string; name: string }
-  | { type: "error"; jobId: string; error: string };
-
-/** Params accepted at job creation — ID, timestamps, and state are derived. */
-export interface NewJobInput {
-  name: string;
-  description: string;
-  schedule: string;
-  subagent_type: SubagentType;
-  prompt: string;
-  model?: string;
-  thinking?: ThinkingLevel;
-  max_turns?: number;
-  isolated?: boolean;
-  isolation?: IsolationMode;
-}
-
-export class SubagentScheduler {
-  private jobs = new Map<string, Cron>();
-  private intervals = new Map<string, NodeJS.Timeout>();
-  private store: ScheduleStore | undefined;
-  private pi: ExtensionAPI | undefined;
-  private ctx: ExtensionContext | undefined;
-  private manager: AgentManager | undefined;
-
-  /** Start the scheduler: bind to a session's store and arm enabled jobs. */
-  start(pi: ExtensionAPI, ctx: ExtensionContext, manager: AgentManager, store: ScheduleStore): void {
-    this.pi = pi;
-    this.ctx = ctx;
-    this.manager = manager;
-    this.store = store;
-
-    for (const job of store.list()) {
-      if (job.enabled) this.scheduleJob(job);
-    }
-  }
-
-  /** Stop all timers; drop refs. Safe to call repeatedly. */
-  stop(): void {
-    for (const cron of this.jobs.values()) cron.stop();
-    this.jobs.clear();
-    for (const t of this.intervals.values()) clearTimeout(t);
-    this.intervals.clear();
-    this.store = undefined;
-    this.pi = undefined;
-    this.ctx = undefined;
-    this.manager = undefined;
-  }
-
-  /** True if start() has bound a store and the scheduler is active. */
-  isActive(): boolean {
-    return this.store !== undefined;
-  }
-
-  list(): ScheduledSubagent[] {
-    return this.store?.list() ?? [];
-  }
-
-  /**
-   * Build a `ScheduledSubagent` from user input. Validates the schedule
-   * format and tags `scheduleType`. Throws on invalid input.
-   */
-  buildJob(input: NewJobInput): ScheduledSubagent {
-    const detected = SubagentScheduler.detectSchedule(input.schedule);
-    return {
-      id: nanoid(10),
-      name: input.name,
-      description: input.description,
-      schedule: detected.normalized,
-      scheduleType: detected.type,
-      intervalMs: detected.intervalMs,
-      subagent_type: input.subagent_type,
-      prompt: input.prompt,
-      model: input.model,
-      thinking: input.thinking,
-      max_turns: input.max_turns,
-      isolated: input.isolated,
-      isolation: input.isolation,
-      enabled: true,
-      createdAt: new Date().toISOString(),
-      runCount: 0,
-    };
-  }
-
-  /** Add a job, persist, and arm if enabled. Returns the stored job. */
-  addJob(input: NewJobInput): ScheduledSubagent {
-    const store = this.requireStore();
-    if (store.hasName(input.name)) {
-      throw new Error(`A scheduled job named "${input.name}" already exists.`);
-    }
-    const job = this.buildJob(input);
-    store.add(job);
-    if (job.enabled) this.scheduleJob(job);
-    this.emit({ type: "added", job });
-    return job;
-  }
-
-  removeJob(id: string): boolean {
-    const store = this.requireStore();
-    if (!store.get(id)) return false;
-    this.unscheduleJob(id);
-    const ok = store.remove(id);
-    if (ok) this.emit({ type: "removed", jobId: id });
-    return ok;
-  }
-
-  /** Toggle / mutate a job. Re-arms based on the new `enabled` state. */
-  updateJob(id: string, patch: Partial<ScheduledSubagent>): ScheduledSubagent | undefined {
-    const store = this.requireStore();
-    const updated = store.update(id, patch);
-    if (!updated) return undefined;
-    this.unscheduleJob(id);
-    if (updated.enabled) this.scheduleJob(updated);
-    this.emit({ type: "updated", job: updated });
-    return updated;
-  }
-
-  /** Next-run time as ISO, or undefined if not currently armed. */
-  getNextRun(jobId: string): string | undefined {
-    const cron = this.jobs.get(jobId);
-    if (cron) return cron.nextRun()?.toISOString();
-    const job = this.store?.get(jobId);
-    if (!job?.enabled) return undefined;
-    if (job.scheduleType === "once") return job.schedule;
-    if (job.scheduleType === "interval" && job.intervalMs) {
-      // Before the first fire there's no `lastRun`, so fall back to "now" —
-      // accurate at create time (setInterval was just armed) and within
-      // intervalMs of correct in any pre-first-fire view.
-      const base = job.lastRun ? new Date(job.lastRun).getTime() : Date.now();
-      return new Date(base + job.intervalMs).toISOString();
-    }
-    return undefined;
-  }
-
-  // ── Scheduling primitives ────────────────────────────────────────────
-
-  private scheduleJob(job: ScheduledSubagent): void {
-    const store = this.store;
-    if (!store) return;
-    try {
-      if (job.scheduleType === "interval" && job.intervalMs) {
-        const t = setInterval(() => this.executeJob(job.id), job.intervalMs);
-        this.intervals.set(job.id, t);
-      } else if (job.scheduleType === "once") {
-        const target = new Date(job.schedule).getTime();
-        const delay = target - Date.now();
-        if (delay > 0) {
-          const t = setTimeout(() => {
-            this.executeJob(job.id);
-            // Auto-disable one-shots after they fire (mirrors pi-cron-schedule)
-            store.update(job.id, { enabled: false });
-            const updated = store.get(job.id);
-            if (updated) this.emit({ type: "updated", job: updated });
-          }, delay);
-          this.intervals.set(job.id, t);
-        } else {
-          // Past timestamp — disable, mark error, never fire
-          store.update(job.id, { enabled: false, lastStatus: "error" });
-          this.emit({ type: "error", jobId: job.id, error: `Scheduled time ${job.schedule} is in the past` });
-        }
-      } else {
-        const cron = new Cron(job.schedule, () => this.executeJob(job.id));
-        this.jobs.set(job.id, cron);
-      }
-    } catch (err) {
-      this.emit({ type: "error", jobId: job.id, error: err instanceof Error ? err.message : String(err) });
-    }
-  }
-
-  private unscheduleJob(id: string): void {
-    const cron = this.jobs.get(id);
-    if (cron) {
-      cron.stop();
-      this.jobs.delete(id);
-    }
-    const t = this.intervals.get(id);
-    if (t) {
-      clearTimeout(t);
-      clearInterval(t);
-      this.intervals.delete(id);
-    }
-  }
-
-  /**
-   * Fire a job: persist running state, spawn (bypassing the concurrency
-   * queue), persist completion. Fire-and-forget: the timer tick returns
-   * immediately so other jobs keep firing.
-   */
-  private executeJob(id: string): void {
-    const store = this.store;
-    const pi = this.pi;
-    const ctx = this.ctx;
-    const manager = this.manager;
-    if (!store || !pi || !ctx || !manager) return;
-    const job = store.get(id);
-    if (!job?.enabled) return;
-
-    store.update(id, { lastStatus: "running" });
-
-    // Resolve model at fire time — registry contents may have changed since the
-    // job was created (auth added/removed). Fall back silently to spawn-default
-    // if resolution fails; the spawn path handles undefined model gracefully.
-    let resolvedModel: any | undefined;
-    if (job.model) {
-      const r = resolveModel(job.model, ctx.modelRegistry);
-      if (typeof r !== "string") resolvedModel = r;
-    }
-
-    let agentId: string;
-    try {
-      agentId = manager.spawn(pi, ctx, job.subagent_type, job.prompt, {
-        description: job.description,
-        isBackground: true,
-        bypassQueue: true,
-        model: resolvedModel,
-        maxTurns: job.max_turns,
-        isolated: job.isolated,
-        thinkingLevel: job.thinking,
-        isolation: job.isolation,
-      });
-    } catch (err) {
-      const error = err instanceof Error ? err.message : String(err);
-      store.update(id, { lastRun: new Date().toISOString(), lastStatus: "error" });
-      this.emit({ type: "error", jobId: id, error });
-      return;
-    }
-
-    this.emit({ type: "fired", jobId: id, agentId, name: job.name });
-
-    const record = manager.getRecord(agentId);
-    const finalize = (status: "success" | "error") => {
-      const next = this.getNextRun(id);
-      const current = store.get(id);
-      store.update(id, {
-        lastRun: new Date().toISOString(),
-        lastStatus: status,
-        runCount: (current?.runCount ?? 0) + 1,
-        nextRun: next,
-      });
-    };
-
-    // AgentManager's promise resolves either way (its .catch returns ""), so we
-    // can't infer success/failure from the promise — read record.status instead.
-    // Terminal states: completed/steered = success; error/aborted/stopped = error.
-    if (record?.promise) {
-      record.promise
-        .then(() => {
-          const r = manager.getRecord(agentId);
-          const failed = r?.status === "error" || r?.status === "aborted" || r?.status === "stopped";
-          finalize(failed ? "error" : "success");
-        })
-        .catch(() => finalize("error"));
-    } else {
-      // Spawn returned without a promise (defensive — bypassQueue path always sets one).
-      finalize("success");
-    }
-  }
-
-  private emit(event: ScheduleChangeEvent): void {
-    if (this.pi) this.pi.events.emit("subagents:scheduled", event);
-  }
-
-  private requireStore(): ScheduleStore {
-    if (!this.store) throw new Error("Scheduler not started — no active session.");
-    return this.store;
-  }
-
-  // ── Format detection / parsers (statics — pure) ──────────────────────
-
-  /**
-   * Sniff a schedule string and tag its type. Throws on invalid input.
-   * Order matters: relative ("+10m") and interval ("5m") both match digit+unit;
-   * relative requires the leading "+" to disambiguate.
-   */
-  static detectSchedule(s: string): { type: "cron" | "once" | "interval"; intervalMs?: number; normalized: string } {
-    const trimmed = s.trim();
-    // "+10m" — relative one-shot
-    const rel = SubagentScheduler.parseRelativeTime(trimmed);
-    if (rel !== null) return { type: "once", normalized: rel };
-    // "5m" — interval
-    const ivl = SubagentScheduler.parseInterval(trimmed);
-    if (ivl !== null) return { type: "interval", intervalMs: ivl, normalized: trimmed };
-    // ISO timestamp — one-shot. Reject past timestamps upfront so we never
-    // create a dead-on-arrival record (scheduleJob's safety net still catches
-    // micro-races from `+0s`-style relatives).
-    if (/^\d{4}-\d{2}-\d{2}T/.test(trimmed)) {
-      const d = new Date(trimmed);
-      if (!Number.isNaN(d.getTime())) {
-        if (d.getTime() <= Date.now()) {
-          throw new Error(`Scheduled time ${d.toISOString()} is in the past.`);
-        }
-        return { type: "once", normalized: d.toISOString() };
-      }
-    }
-    // Cron — 6-field
-    const cronCheck = SubagentScheduler.validateCronExpression(trimmed);
-    if (cronCheck.valid) return { type: "cron", normalized: trimmed };
-    throw new Error(
-      `Invalid schedule "${s}". Use 6-field cron (e.g. "0 0 9 * * 1" — 9am every Monday), interval ("5m"/"1h"), or one-shot ("+10m" / ISO).`
-    );
-  }
-
-  /** 6-field cron — 'second minute hour dom month dow'. */
-  static validateCronExpression(expr: string): { valid: boolean; error?: string } {
-    const fields = expr.trim().split(/\s+/);
-    if (fields.length !== 6) {
-      return {
-        valid: false,
-        error: `Cron must have 6 fields (second minute hour dom month dow), got ${fields.length}. Example: "0 0 9 * * 1" for 9am every Monday.`,
-      };
-    }
-    try {
-      // Croner validates by construction.
-      new Cron(expr, () => {});
-      return { valid: true };
-    } catch (e) {
-      return { valid: false, error: e instanceof Error ? e.message : "Invalid cron expression" };
-    }
-  }
-
-  /** "+10s"/"+5m"/"+1h"/"+2d" → ISO timestamp. */
-  static parseRelativeTime(s: string): string | null {
-    const m = s.match(/^\+(\d+)(s|m|h|d)$/);
-    if (!m) return null;
-    const ms = parseInt(m[1], 10) * { s: 1000, m: 60_000, h: 3_600_000, d: 86_400_000 }[m[2] as "s" | "m" | "h" | "d"];
-    return new Date(Date.now() + ms).toISOString();
-  }
-
-  /** "10s"/"5m"/"1h"/"2d" → milliseconds. */
-  static parseInterval(s: string): number | null {
-    const m = s.match(/^(\d+)(s|m|h|d)$/);
-    if (!m) return null;
-    return parseInt(m[1], 10) * { s: 1000, m: 60_000, h: 3_600_000, d: 86_400_000 }[m[2] as "s" | "m" | "h" | "d"];
-  }
-}

package/src/ui/schedule-menu.ts

@@ -1,104 +0,0 @@
-/**
- * schedule-menu.ts — `/agents → Scheduled jobs` submenu.
- *
- * Minimal v1 surface: list scheduled jobs, select one to inspect details +
- * confirm cancellation. No create wizard (the `Agent` tool's `schedule` param
- * is the canonical creation path), no toggle/cleanup (cancel is enough for
- * "I scheduled something dumb, get rid of it"). Add management surfaces here
- * if real demand emerges.
- */
-
-import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
-import type { SubagentScheduler } from "../schedule.js";
-import type { ScheduledSubagent } from "../types.js";
-
-/** Format an ISO timestamp as relative time ("in 4h", "2d ago", "—"). */
-function relTime(iso: string | undefined, now = Date.now()): string {
-  if (!iso) return "—";
-  const t = new Date(iso).getTime();
-  if (Number.isNaN(t)) return "—";
-  const diff = t - now;
-  const abs = Math.abs(diff);
-  const future = diff > 0;
-  if (abs < 60_000) return future ? "in <1m" : "<1m ago";
-  const m = Math.round(abs / 60_000);
-  if (m < 60) return future ? `in ${m}m` : `${m}m ago`;
-  const h = Math.round(abs / 3_600_000);
-  if (h < 24) return future ? `in ${h}h` : `${h}h ago`;
-  const d = Math.round(abs / 86_400_000);
-  return future ? `in ${d}d` : `${d}d ago`;
-}
-
-/** One-line status icon. */
-function statusIcon(j: ScheduledSubagent): string {
-  if (!j.enabled) return "✗";
-  if (j.lastStatus === "error") return "!";
-  if (j.lastStatus === "running") return "⋯";
-  return "✓";
-}
-
-/** Compact selectable row — name, schedule, agent type, next/last run, count. */
-function formatJob(j: ScheduledSubagent, scheduler: SubagentScheduler): string {
-  const next = scheduler.getNextRun(j.id);
-  return [
-    statusIcon(j),
-    j.name.padEnd(18).slice(0, 18),
-    j.schedule.padEnd(14).slice(0, 14),
-    `[${j.subagent_type}]`,
-    `next ${relTime(next)}`,
-    `last ${relTime(j.lastRun)}`,
-    `runs ${j.runCount}`,
-  ].join("  ");
-}
-
-/** Multi-line details block for the cancel confirm. */
-function formatDetails(j: ScheduledSubagent, scheduler: SubagentScheduler): string {
-  const next = scheduler.getNextRun(j.id) ?? "—";
-  return [
-    `name:      ${j.name}`,
-    `schedule:  ${j.schedule} (${j.scheduleType})`,
-    `agent:     ${j.subagent_type}`,
-    `prompt:    ${j.prompt.slice(0, 200)}${j.prompt.length > 200 ? "…" : ""}`,
-    `created:   ${j.createdAt}`,
-    `last run:  ${j.lastRun ?? "—"} (${j.lastStatus ?? "—"})`,
-    `next run:  ${next}`,
-    `runs:      ${j.runCount}`,
-  ].join("\n");
-}
-
-/**
- * List scheduled jobs; selecting one opens a cancel-confirm with details.
- * Returns when the user backs out or after a cancellation.
- */
-export async function showSchedulesMenu(
-  ctx: ExtensionCommandContext,
-  scheduler: SubagentScheduler,
-): Promise<void> {
-  if (!scheduler.isActive()) {
-    ctx.ui.notify("Scheduler is not active in this session.", "warning");
-    return;
-  }
-
-  const jobs = scheduler.list();
-  if (jobs.length === 0) {
-    ctx.ui.notify("No scheduled jobs.", "info");
-    return;
-  }
-
-  const labels = jobs.map(j => formatJob(j, scheduler));
-  const choice = await ctx.ui.select(
-    `Scheduled jobs (${jobs.length}) — select to cancel`,
-    labels,
-  );
-  if (!choice) return;
-
-  const idx = labels.indexOf(choice);
-  if (idx < 0) return;
-  const job = jobs[idx];
-
-  const ok = await ctx.ui.confirm(`Cancel "${job.name}"?`, formatDetails(job, scheduler));
-  if (!ok) return;
-
-  scheduler.removeJob(job.id);
-  ctx.ui.notify(`Cancelled "${job.name}".`, "info");
-}