pi-cc-loop 0.2.0 → 0.4.0

package/README.md

@@ -1,144 +1,171 @@
 # pi-cc-loop
 
-> 在 Pi 里复刻 Claude Code 的 `/loop`：固定间隔 cron、自选间隔、兜底心跳和可选状态条。
+> 在 Pi 里复刻 Claude Code 的 `/loop`：固定间隔、自选间隔、兜底心跳和底部状态摘要。
 
-## 快速开始
+## 安装
 
 ```bash
-# 本地开发：把仓库软链接到 Pi 扩展目录
-ln -sfn "$PWD" ~/.pi/agent/extensions/pi-cc-loop
-
-# 发布后
 pi install npm:pi-cc-loop
 ```
 
-安装后执行 `/reload`。
+安装后执行 `/reload`。本地开发时把仓库软链接到扩展目录即可：
+
+```bash
+ln -sfn "$PWD" ~/.pi/agent/extensions/pi-cc-loop
+```
 
-## 功能
+## 工作方式
+
+`/loop` 和 CC 一样是一个**技能**，不是用代码直接排任务：你输入的内容会作为一条普通 user 消息进入对话，
+模型自己解析间隔并调用工具完成。所以对话里始终能看到你要求了什么、模型做了什么。
+
+给模型的规则（怎么建任务、自定步调怎么续期）以一条隐藏消息附在这一轮后面，不改 system prompt：
+不支持对话中途 system 消息的 provider 会把 system prompt 整体重建，规则一来一去会让整段提示缓存失效。
+固定间隔的每次触发不附加任何东西，信封里一句"它会自己触发下一次，取消用 cron_delete"就够了。
 
 | 功能 | 说明 | 入口 |
 | --- | --- | --- |
-| 固定间隔 | 5 字段 cron；`30s`、`5m`、`2h`、`1d`；秒向上取整到分钟 | `/loop 5m <prompt>` |
-| 自选间隔 | 模型每轮用 `schedule_wakeup` 决定下次延迟（60–3600s） | `/loop <prompt>` |
-| 自然语言间隔 | 命令层认不出时交给模型解析（中英文均可） | `/loop 每30秒 ...` |
-| loop.md | 不带 prompt 时运行 `.pi/loop.md`（每次触发重读，改了下一轮生效），没有则跑内置维护 prompt | `/loop`、`/loop 15m` |
-| 立即执行 | 创建后马上跑一次，不等首个 cron | 自动 |
+| 固定间隔 | 模型用 `cron_create` 建一个 cron（`5m` → `*/5 * * * *`），然后立即执行一次；触发时按"定时任务"呈现。不带 `/loop`、直接说"每分钟打印一次hello"也一样 | `/loop 5m <prompt>`、`/loop 每分钟 ...` |
+| 自选间隔 | 运行一次后用 `schedule_wakeup` 决定下次延迟（60–3600s） | `/loop <prompt>` |
+| loop.md | 请求本身没有任务时（裸 `/loop` 或只给间隔）由 `.pi/loop.md`（或 `~/.pi/loop.md`）提供，每次触发重读；没有时用内置维护 prompt | `/loop`、`/loop 15m` |
+| 停止 / 查看 | 也走对话：模型用 `cron_list` / `cron_delete`（自选间隔用 `schedule_wakeup` + `stop: true`）；停掉后再输入同一个 `/loop` 会重新开始 | `/loop stop`、`/loop status` |
+| 回合中输入 | 模型正在回复时输入 `/loop ...`：底部提示"will start when the current turn ends"，当前回合结束后作为新的一轮开始（不会混进正在进行的回合） | 自动 |
 | 漏跑合并 | agent 忙时到点只记一次 pending，空闲后发一条 | 自动 |
 | 兜底心跳 | 模型忘记调度时 arm 一次 20 分钟心跳，预算 1 次 | 自动 |
 | Esc 取消 | 打断属于某个自定步调 loop 的回合（它的 tick、它的 Monitor 唤醒的回合）时取消该 loop；无关回合、空闲时不受影响；固定间隔不受影响 | Esc |
 | 错峰 | 周期任务按 id 固定延后最多半个周期（≤30 分钟），间隔本身不变；`:00`/`:30` 的一次性任务最多提前 90 秒 | 自动 |
 | 过期 | 周期任务 7 天后最后执行一次再删除；一次性任务不过期 | 自动 |
-| 次数上限 | `--max N`，到顶自动删除 | 标志 |
-| 持久化 | `--durable` 写入 `.pi/scheduled_tasks.json`；同一项目只由一个 Pi 会话执行 | 标志 |
-| 状态条 | 输入框上方状态行，默认关闭 | `/loop widget on\|off` |
+| 次数上限 | `maxFires`，到顶自动删除 | `--max N` |
+| 持久化 | `durable: true` 写入 `.pi/scheduled_tasks.json`，重启后继续；同一项目只由一个 Pi 会话执行 | `--durable` |
+| 底部摘要 | Pi 底部状态栏一行：`loop 2 · next 3m`，无任务时不占位 | `/loop footer on\|off` |
+| 界面设置 | 本地命令，不进对话 | `/loop settings ...` |
 
 ## 命令
 
 ```text
-/loop [间隔] <prompt>     按间隔重复跑
-/loop <prompt>            间隔交给模型判断
-/loop [间隔]              运行 .pi/loop.md 或内置维护 prompt（不带间隔则自定步调）
-/loop status              列出当前 loop
+/loop <间隔> <prompt>     固定间隔重复（模型用 cron_create）
+/loop <prompt>            自选间隔（模型用 schedule_wakeup）
+/loop [间隔]              跑 loop.md，没有就跑内置维护 prompt
+/loop status              列出当前任务
 /loop stop [id]           停止一个或全部
-/loop widget on|off       状态条
-/loop settings ...        界面设置
-/loop help                帮助
+/loop footer on|off       本地：底部摘要
+/loop settings ...        本地：界面设置
+/loop help                本地：帮助
 ```
 
-标志：`--durable` 写入 `.pi/scheduled_tasks.json`；`--max N` 触发 N 次后自动停止。
-
-agent 忙时输入 `/loop`，会等当前回合结束再开始。
+前五个会作为普通 user 消息进入对话（内容就是你输入的那行），模型再按技能说明调用工具；后三个只改界面，不进对话。
 
-间隔写法：
+间隔写法没有约束，模型自己解析：`30s`、`5m`、`2h`、`1d`、`check the deploy every 20m`、
+`每2分钟输出一次`、`每分钟打印一次hi` 都可以。小于一分钟会向上取整到每分钟。
 
-- `30s`、`5m`、`2h`、`1d`
-- `check the deploy every 20m`、`every 5 min`、`every 2 hrs`
-- 秒向上取整到分钟；不整除的间隔按 CC 规则取整并提示：`7m` → `*/6`，`30s` → 每分钟
-- 其他语言（如「每30秒」）交给模型解析
+可以在请求里加 `--durable`（写入 `.pi/scheduled_tasks.json`，重启后继续）和 `--max N`（触发 N 次后自动删除）。
 
 ## 工具
 
-| 工具 | 说明 |
-| --- | --- |
-| `cron_create` | 创建固定间隔任务；支持 `recurring`、`durable`、`maxFires` |
-| `cron_delete` | 按 id 取消 |
-| `cron_list` | 列出任务 |
-| `schedule_wakeup` | 自选间隔：安排下次唤醒，或 `stop: true` 结束 |
+| 工具 | 界面显示 | 说明 |
+| --- | --- | --- |
+| `cron_create` | `CronCreate` | 5 段 cron（本地时区）+ prompt；`recurring` 默认 `true`，`false` 为一次性；可选 `durable`、`maxFires` |
+| `cron_delete` | `CronDelete` | 按 id 取消；也能结束自定步调 loop |
+| `cron_list` | `CronList` | 列出任务和实际的下次运行时间（已含错峰） |
+| `schedule_wakeup` | `ScheduleWakeup` | 自定步调：`delaySeconds`（限制在 60–3600）、`reason`（必填，显示在触发块表头）、`prompt`；`stop: true` 结束 |
 
-`schedule_wakeup` 参数：
+## 渲染
 
-- `delaySeconds`：60–3600，越界自动钳制
-- `reason`：一句原因
-- `prompt`：原样传回 `/loop` 的 prompt；裸 `/loop` 传 `<<loop.md>>`
-- `stop`：结束当前自选间隔 loop
+定时触发只显示任务本身，给模型看的信封不上屏：
 
-`schedule_wakeup` 调用后本回合结束（工具批次里只有它时），所以模型会先写进度再调用；
-延迟按你给的值使用（四舍五入到整秒），只有超出 60–3600 秒才会被 clamp 并提示。CC 会把 `*/5` 任务提前 15 秒、把 286–300 秒的延迟压到 285 秒来保温 5 分钟的 prompt 缓存，我们没有跟：现在的缓存能活几十分钟到几小时，这样改只会让间隔变成 4 分 45 秒。
+```text
+✻ Running scheduled task · 9:52pm
+   print hi
 
-## 持久化与恢复
+✻ loop #3 · 9:53pm · watching CI run
+   check the deploy
+```
 
-- `--durable` / `durable: true` 的任务存在 `.pi/scheduled_tasks.json`，并自动加入 `.git/info/exclude`
-- 同一项目只有持有 `.pi/scheduled_tasks.lock` 的 Pi 会话执行它们；该会话退出（或 60 秒没有心跳）后由其他会话接管
-- Pi 没运行时错过的 durable 一次性任务会被移除，下一轮先问你要不要补跑
-- 从别的目录拷来的任务只列出、不执行；`.pi` 或任务文件是符号链接时拒绝写入
-- 恢复会话：会话内任务照常恢复，但过期的周期任务、已过时间的一次性任务除外，错过的运行不补跑；自定步调 loop 不恢复（需重新 `/loop`），`/reload` 时保留
+固定间隔按"定时任务"呈现；只有自选间隔叫 loop，表头带上模型给的 `reason`。折叠时正文最多 3 行，
+Ctrl+O 展开后多一行元信息（任务 id、节奏）。`compactMessages` 关闭时回到旧的带底色卡片。
 
 ## 设置
 
-两个 pi-cc 扩展共享 `~/.pi/agent/pi-cc.json`：
+两个 pi-cc 扩展共用 `~/.pi/agent/pi-cc.json`，文件不存在时用默认值：
 
 ```jsonc
 {
-  "compactMessages": true,          // 两行 marker / 旧的带底色卡片
-  "compactToolRows": true,          // 一行工具结果 / Pi 默认工具行
-  "managePiCcExtensions": true      // 自动维护 pi-cc-extensions 的 excludeRenderers
+  "compactMessages": true,   // 触发块和 Monitor 事件用上面的样式；false 为旧的带底色卡片
+  "footer": true             // 底部摘要：loop 的一行和 Monitor 的 `monitor N`
 }
 ```
 
-用命令切换：
+用 `/loop settings messages on|off`、`/loop settings footer on|off`（或 `/loop footer on|off`）切换，两个扩展同时生效。
 
-```text
-/loop settings
-/loop settings messages on|off
-/loop settings tools on|off
-```
+## 底部摘要
+
+`ctx.ui.setStatus("loop", …)` 是 Pi 核心 API，不依赖任何其他扩展：
 
-- 已画出的旧行需要 `/reload` 才会换样式
-- 环境变量覆盖：`PI_CC_COMPACT_MESSAGES=0`、`PI_CC_COMPACT_TOOL_ROWS=0`、`PI_CC_MANAGE_CCSTYLE=0`
+| 场景 | 显示 |
+| --- | --- |
+| 没有任务 | 不设置状态，footer 不会被多占一行 |
+| 有任务 | `loop 3 · next 4m`（数量 + 最近一次触发） |
+| 一分钟内 | `loop 1 · next <1m` |
+| 超过一小时 | `loop 1 · next 2h 15m` |
 
-> 如果装了 `pi-cc-extensions`，`tools on` 会把本扩展的工具名加入它的 `excludeRenderers`；
-> `tools off` 只移除自己加过的名字。它只在启动时读配置，切换后需要 `/reload`。
+- 倒计时取整到分钟，配合"文本相同就不调用"的去重，最多每分钟重绘一次（Pi 每次 `setStatus` 都会触发重绘）
+- 装了 `pi-cc-extensions`：这一行会作为它的一个 chip 出现在第 2 行，可在它的配置面板里移动或隐藏；它会把 ANSI 去掉，所以这里只用纯文本
+- 没装 `pi-cc-extensions`：Pi 内置 footer 会把它和其他扩展的状态拼成一行，加在用量行下面，只在有任务时出现
+- 装了 `pi-cc-monitor`：运行中的 monitor 另有一项 `monitor 2`，和这一行用同一个开关
 
 ## 环境变量
 
 | 变量 | 默认 | 说明 |
 | --- | --- | --- |
-| `PI_LOOP_MAX_AGE_DAYS` | `7` | 任务最长存活天数，`0` 不过期 |
+| `PI_LOOP_MAX_AGE_DAYS` | `7` | 周期任务最长存活天数，`0` 不过期 |
 | `PI_LOOP_KEEPALIVE_SECONDS` | `1200` | 兜底心跳；`0` 禁用 |
 | `PI_LOOP_JITTER` | `0.5` | 周期任务最多延后的周期比例；`0` 关闭错峰 |
 | `PI_LOOP_SCAN_MS` | `1000` | 调度扫描间隔 |
+| `PI_LOOP_DURABLE_SYNC_MS` | `5000` | 持久化任务文件的同步间隔 |
+| `PI_CC_FOOTER` | — | `0` / `1`，覆盖设置文件里的 `footer` |
+| `PI_CC_COMPACT_MESSAGES` | — | `0` / `1`，覆盖设置文件里的 `compactMessages` |
+| `PI_CC_CONFIG_FILE` | `~/.pi/agent/pi-cc.json` | 设置文件路径 |
 
 ## 兼容性
 
 - Node.js `>=22.19.0`
-- Pi `1.3.0`（开发环境）
-- 与 `pi-cc-extensions` 共存，见上面的设置说明
+- Pi 1.3.0、1.4.0（测试通过）
+- `pi-cc-monitor` 可选：自定步调 loop 需要等外部事件时会用它，loop 结束时连带停止；两者通过 `pi.events` 通信
+- 与 `pi-cc-extensions` 共存。本扩展不写其他插件的配置文件；旧版本在 `pi-cc-extensions.json` 里加过的
+  `cron_create`、`cron_delete`、`cron_list`、`schedule_wakeup` 这几条 `excludeRenderers` 可以删掉
 
 ## 本地开发
 
 ```bash
 node --test tests/*.test.mjs
 npx --yes typescript@5.9.3 tsc --noEmit -p tsconfig.json
+node scripts/cache-check.mjs    # 真实 provider 的缓存检查，默认用免费模型，发版前跑
 ```
 
-## 说明
+### 缓存约束
+
+提示缓存按前缀匹配（工具 → system prompt → 消息），扩展只能往对话末尾追加：
+
+- **不改 system prompt**：每轮需要的规则作为隐藏消息附在这一轮后面（`before_agent_start` 返回 `message`），不写 `promptGuidelines`，不返回 `systemPrompt`。
+- **不动工具集**：工具在加载时一次注册，描述是固定文本；不调用 `setActiveTools`，会话中途不改描述。
+- **不改历史**：不注册 `context` / `context_with_system` / `before_provider_request`。
+
+`tests/cache.test.mjs` 守住这三条。`scripts/cache-check.mjs` 用真实 provider 依次走一遍固定间隔 `/loop`、触发、普通对话、`/loop stop`、Monitor 事件、自定步调 `/loop` 和它的触发，逐个请求看缓存读取量：
+读到的明显少于上一个请求发出的内容就报 MISS（退出码 1）。provider 偶尔会自己丢缓存，同一步骤重跑仍然 MISS 才是扩展的问题。
+默认模型 `opencode-go/beam-free` 免费；`--model` 可换，脚本最后会打印本次花费。
+
+## 与 Claude Code 的差异
+
+行为对齐 Claude Code 2.1.308 的 `/loop`，用 Pi 扩展 API 实现。有意不同的地方：
 
-- 行为对齐 Claude Code v2.1.306 的 `/loop`，用 Pi 扩展 API 实现。
-- Esc 只取消被打断回合所属的自定步调 loop；CC 在任何时候按 Esc（包括空闲、打断无关回合）都会取消所有自定步调 loop。其他情况用 `/loop stop`。
-- 状态条默认关闭，和 CC 主会话一致。
-- `cron_create` 的 `maxFires` 是额外加固；CC 没有次数上限。
-- `/loop stop` 会连带静默停掉该 chain 绑定的 Monitor。
+- Esc 只取消被打断回合所属的自定步调 loop；CC 按 Esc（包括空闲时、打断无关回合时）会取消所有自定步调 loop。其他情况用 `/loop stop`。
+- 固定间隔的触发里调用 `schedule_wakeup` 会被当作空操作并返回说明，防止同一个任务又被自定步调重复调度；CC 没有这条硬规则。
+- 不带 `/loop` 的请求（比如"每分钟打印一次hello"）也会在建好任务后立即做一次。CC 靠模型自己调用 loop 技能做到（`CronCreate` 在 CC 里是延迟加载的工具，模型会先走技能）；Pi 没有延迟加载工具，这里改为在 `cron_create` 的结果里加一句提示，只在普通对话里建周期任务时出现。
+- 底部摘要和 `maxFires` 次数上限是额外加的；CC 主会话不显示 loop 状态，也没有次数上限。
+- 自定步调 loop 结束（stop、Esc、`cron_delete`、兜底心跳用完）时，绑定的 Monitor 会被静默停止；CC 靠模型自己调用 `TaskStop`。
 - Monitor 事件不会取消待触发的 wakeup，它始终是兜底心跳（与 CC 一致）。
+- 没有做 CC 的 `noop` 折叠、触发时"不是用户实时输入"的安全提示、间隔边界提示和云端调度。
+- 没有做 CC 针对 5 分钟提示缓存的两处调整（`*/5` 每次提前 15 秒、接近 300 秒的唤醒往回拉）。在 5 分钟缓存的 provider 上（比如 Anthropic 默认），`*/5` 的触发和 300 秒左右的唤醒可能刚好错过缓存。
 
 ## 许可证
 

package/config.ts

@@ -8,13 +8,13 @@
  *   ~/.pi/agent/pi-cc.json
  *   {
  *     "compactMessages": true,
- *     "compactToolRows": true
+ *     "footer": true
  *   }
  *
  * Environment overrides (useful for tests and quick experiments):
  *   PI_CC_CONFIG_FILE=/path/to/pi-cc.json
  *   PI_CC_COMPACT_MESSAGES=0|1
- *   PI_CC_COMPACT_TOOL_ROWS=0|1
+ *   PI_CC_FOOTER=0|1
  */
 
 import fs from "node:fs";
@@ -24,22 +24,16 @@ import path from "node:path";
 export interface PiCcConfig {
 	/** Two-line marker blocks instead of the padded card. */
 	compactMessages: boolean;
-	/** One-line tool results instead of Pi's "N lines returned" preview. */
-	compactToolRows: boolean;
 	/**
-	 * Keep pi-cc tools out of pi-cc-extensions' global tool styling so the
-	 * compact rows above are visible. Only names this extension added are
-	 * removed again when the setting is turned off.
+	 * Show a one-line summary in Pi's footer (loops armed, monitors running).
+	 * Shared so one switch silences both packages.
 	 */
-	managePiCcExtensions: boolean;
-	/** Internal: names this extension added to pi-cc-extensions.json. */
-	managedExcludes?: string[];
+	footer: boolean;
 }
 
 export const DEFAULT_CONFIG: PiCcConfig = {
 	compactMessages: true,
-	compactToolRows: true,
-	managePiCcExtensions: true,
+	footer: true,
 };
 
 function envBool(name: string): boolean | undefined {
@@ -69,17 +63,8 @@ function readConfig(): PiCcConfig {
 		compactMessages:
 			envBool("PI_CC_COMPACT_MESSAGES") ??
 			(typeof file.compactMessages === "boolean" ? file.compactMessages : DEFAULT_CONFIG.compactMessages),
-		compactToolRows:
-			envBool("PI_CC_COMPACT_TOOL_ROWS") ??
-			(typeof file.compactToolRows === "boolean" ? file.compactToolRows : DEFAULT_CONFIG.compactToolRows),
-		managePiCcExtensions:
-			envBool("PI_CC_MANAGE_CCSTYLE") ??
-			(typeof file.managePiCcExtensions === "boolean"
-				? file.managePiCcExtensions
-				: DEFAULT_CONFIG.managePiCcExtensions),
-		managedExcludes: Array.isArray(file.managedExcludes)
-			? file.managedExcludes.filter((name): name is string => typeof name === "string")
-			: [],
+		footer:
+			envBool("PI_CC_FOOTER") ?? (typeof file.footer === "boolean" ? file.footer : DEFAULT_CONFIG.footer),
 	};
 }
 
@@ -101,73 +86,17 @@ export function saveConfig(patch: Partial<PiCcConfig>): PiCcConfig {
 	const next = { ...loadConfig(), ...patch };
 	const file = configPath();
 	fs.mkdirSync(path.dirname(file), { recursive: true });
-	const temp = `${file}.tmp`;
-	fs.writeFileSync(temp, `${JSON.stringify(next, null, 2)}\n`, "utf8");
-	fs.renameSync(temp, file);
-	cached = next;
-	return next;
-}
-
-/**
- * pi-cc-extensions' config file. That extension loads its config once at load
- * time, so changes made here apply after `/reload`.
- */
-export function piCcExtensionsConfigPath(): string {
-	const agentDir =
-		process.env.PI_CODING_AGENT_DIR ?? process.env.PI_AGENT_DIR ?? path.join(os.homedir(), ".pi", "agent");
-	return process.env.PI_CC_EXTENSIONS_CONFIG_FILE ?? path.join(agentDir, "pi-cc-extensions.json");
-}
-
-/**
- * Add or remove our tool names in pi-cc-extensions' `excludeRenderers`.
- *
- * Returns true when the file changed (the caller can tell the user to reload).
- * Only names this extension added are removed again; a name the user put there
- * themselves is left alone.
- */
-export function syncPiCcExtensionsExcludes(toolNames: readonly string[], enabled: boolean): boolean {
-	// Another package may have written managedExcludes since our last read.
-	invalidateConfig();
-	const config = loadConfig();
-	if (!config.managePiCcExtensions) return false;
-	const file = piCcExtensionsConfigPath();
-	if (!fs.existsSync(file)) return false;
-
-	let raw: Record<string, unknown>;
+	// Keep keys this version does not know about: the file is the user's.
+	let raw: Record<string, unknown> = {};
 	try {
 		const parsed = JSON.parse(fs.readFileSync(file, "utf8")) as unknown;
-		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return false;
-		raw = parsed as Record<string, unknown>;
+		if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) raw = parsed as Record<string, unknown>;
 	} catch {
-		return false;
-	}
-
-	const current = Array.isArray(raw.excludeRenderers)
-		? raw.excludeRenderers.filter((name): name is string => typeof name === "string")
-		: [];
-	const managed = new Set(config.managedExcludes ?? []);
-	const next = new Set(current);
-	let changed = false;
-
-	for (const name of toolNames) {
-		if (enabled) {
-			if (!next.has(name)) {
-				next.add(name);
-				managed.add(name);
-				changed = true;
-			}
-		} else if (managed.has(name)) {
-			if (next.delete(name)) changed = true;
-			managed.delete(name);
-		}
+		// A missing or malformed file is rewritten from scratch.
 	}
-
-	if (!changed && managed.size === (config.managedExcludes ?? []).length) return false;
-
-	raw.excludeRenderers = [...next].sort((a, b) => a.localeCompare(b));
 	const temp = `${file}.tmp`;
-	fs.writeFileSync(temp, `${JSON.stringify(raw, null, 2)}\n`, "utf8");
+	fs.writeFileSync(temp, `${JSON.stringify({ ...raw, ...next }, null, 2)}\n`, "utf8");
 	fs.renameSync(temp, file);
-	saveConfig({ managedExcludes: [...managed].sort((a, b) => a.localeCompare(b)) });
-	return changed;
+	cached = next;
+	return next;
 }

package/cron.ts

@@ -154,36 +154,6 @@ export function isUnreachable(expression: string): boolean {
 	return nextFireAfter(fields, new Date(), 366) === null;
 }
 
-export interface IntervalSpec {
-	/** Number of seconds the schedule actually uses. */
-	seconds: number;
-	/** Cron expression that implements the interval. */
-	cron: string;
-	/** Human readable cadence, e.g. "every 5 minutes". */
-	human: string;
-	/** True when the requested interval had to be adjusted. */
-	adjusted: boolean;
-	/** What the user asked for, in seconds. */
-	requestedSeconds: number;
-	/** Human readable explanation of the adjustment, for the user. */
-	note?: string;
-}
-
-const UNIT_SECONDS: Record<string, number> = {
-	s: 1,
-	m: 60,
-	h: 3600,
-	d: 86400,
-};
-
-/** The unit words Claude Code's /loop accepts in a trailing "every N <unit>" clause. */
-const UNIT_WORDS: Record<string, string[]> = {
-	s: ["s", "sec", "secs", "second", "seconds"],
-	m: ["m", "min", "mins", "minute", "minutes"],
-	h: ["h", "hr", "hrs", "hour", "hours"],
-	d: ["d", "day", "days"],
-};
-
 /**
  * The divisor of `total` closest to `n`.
  *
@@ -205,100 +175,9 @@ function nearestDivisor(n: number, total: number): number {
 	return best;
 }
 
-/**
- * Convert a duration into a cron expression, following Claude Code's rule:
- *
- *   "Supported suffixes: `s` -> ceil to nearest minute, `m` (minutes),
- *    `h` (hours), `d` (days). Examples: `5m` -> a 5 minute step, `1h` -> `0 * * * *`,
- *    `1d` -> `0 0 * * *`. If the interval doesn't cleanly divide its unit, round to the
- *    nearest clean interval and tell the user what you rounded to."
- */
-export function intervalToCron(seconds: number): IntervalSpec | null {
-	if (!Number.isFinite(seconds) || seconds <= 0) return null;
-
-	// Sub-minute: the scheduler's granularity is one minute, so round up.
-	if (seconds < 60) {
-		return {
-			seconds: 60,
-			cron: "* * * * *",
-			human: "every minute",
-			adjusted: true,
-			requestedSeconds: seconds,
-			note: `${seconds}s rounded up to 1 minute (the scheduler's minimum granularity is 1 minute)`,
-		};
-	}
-
-	// "Seconds are rounded up to the nearest minute since cron has one-minute
-	// granularity."
-	if (seconds < 3600 && Math.ceil(seconds / 60) < 60) {
-		const requested = Math.ceil(seconds / 60);
-		const minutes = nearestDivisor(requested, 60);
-		return {
-			seconds: minutes * 60,
-			cron: `*/${minutes} * * * *`,
-			human: `every ${minutes} minute${minutes === 1 ? "" : "s"}`,
-			adjusted: minutes !== requested,
-			requestedSeconds: seconds,
-			...(minutes !== requested
-				? { note: `${requested}m rounded to ${minutes}m, the nearest clean interval` }
-				: {}),
-		};
-	}
-
-	if (seconds < 86400) {
-		const requested = Math.max(1, Math.round(seconds / 3600));
-		const hours = nearestDivisor(requested, 24);
-		return {
-			seconds: hours * 3600,
-			cron: hours === 1 ? "0 * * * *" : `0 */${hours} * * *`,
-			human: `every ${hours} hour${hours === 1 ? "" : "s"}`,
-			adjusted: hours !== requested,
-			requestedSeconds: seconds,
-			...(hours !== requested
-				? { note: `${requested}h rounded to ${hours}h, the nearest clean interval` }
-				: {}),
-		};
-	}
-
-	const days = Math.max(1, Math.round(seconds / 86400));
-	return {
-		seconds: days * 86400,
-		cron: days === 1 ? "0 0 * * *" : `0 0 */${days} * *`,
-		human: days === 1 ? "every day" : `every ${days} days`,
-		adjusted: days * 86400 !== seconds,
-		requestedSeconds: seconds,
-	};
-}
-
-/** Parse a duration token such as `5m`, `30s`, `2h`, `1d`. */
-export function parseIntervalToken(token: string): number | null {
-	const m = /^(\d+)\s*([smhd])$/i.exec(token.trim());
-	if (!m) return null;
-	const unit = m[2].toLowerCase();
-	const amount = Number(m[1]);
-	if (!Number.isFinite(amount) || amount <= 0) return null;
-	return amount * UNIT_SECONDS[unit];
-}
-
-/**
- * Parse a trailing `every 20m` / `every 5 min` / `every 2 hours` clause, with
- * the unit words Claude Code accepts.
- */
-export function parseEveryClause(input: string): { interval: number; prompt: string } | null {
-	const m = /\bevery\s+(\d+)\s*([a-z]+)\s*$/i.exec(input.trim());
-	if (!m) return null;
-	const amount = Number(m[1]);
-	if (!(amount > 0)) return null;
-	const word = m[2].toLowerCase();
-	const unit = Object.keys(UNIT_WORDS).find((key) => UNIT_WORDS[key].includes(word));
-	if (!unit) return null;
-	const unitSeconds = UNIT_SECONDS[unit];
-	const prompt = input.trim().slice(0, m.index).trim();
-	return { interval: amount * unitSeconds, prompt };
-}
-
 const DAY_NAMES = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
 
+
 /**
  * A human readable cadence for a cron expression, with Claude Code's labels:
  * "Every minute", "Every 5 minutes", "Every hour at :07", "Every 2 hours",