minimal-agent 0.8.2 → 0.9.0

package/workflows/ralph-loop.yaml

@@ -0,0 +1,169 @@
+name: ralph-loop
+description: |
+  Ralph Wiggum 迭代开发循环——通过重复执行同一目标直到完成。
+
+  等价于原 ralph-wiggum 插件的 /ralph-loop 命令，完全用声明式工作流实现。
+  核心机制：while 循环 + fresh context（每轮重置 history）+ 哨兵协议 + 验证门。
+
+  用法：/workflow ralph-loop "你的目标" --max-iterations 50 --verify "shell:bun test"
+inputs:
+  - name: goal
+    type: string
+    required: true
+    description: "不可变目标描述（如'实现用户认证模块并确保测试通过'）"
+  - name: max_iterations
+    type: number
+    default: 50
+    description: "最大迭代次数（安全阀，默认 50，硬上限 200）"
+  - name: verify_checks
+    type: string
+    default: ""
+    description: "验证门检查项（逗号分隔，如 'shell:bun test,file_exists:src/index.ts'）。空则跳过验证门。"
+
+steps:
+  # === 初始化阶段变量 ===
+  - id: init_phase
+    llm: "PLAN"
+    capture:
+      result: phase
+
+  # === 初始化教训记录文件（fresh context 下跨轮存活） ===
+  - id: init_learnings
+    tool: "Write(file_path='.minimal-agent-workflow/learnings.md', content='')"
+    onError: continue
+
+  # ============================================================
+  #  主迭代循环（while 模式 + fresh_context）
+  #  每轮：构造 prompt → agent 工作 → 哨兵检测 → 阶段推进
+  # ============================================================
+  - type: loop
+    id: main_loop
+    max_iterations: "${max_iterations}"
+    fresh_context: true
+    do:
+      # --- 1. 读取上轮教训 ---
+      - id: read_learnings
+        tool: "Read(file_path='.minimal-agent-workflow/learnings.md')"
+        capture:
+          text: learnings_text
+        onError: continue
+
+      # --- 2. 构造本轮 prompt（含目标、阶段、通信协议、教训） ---
+      - id: build_prompt
+        llm: |
+          # 不可变目标 (IMMUTABLE GOAL)
+          ${goal}
+          ⚠️ 你不能修改或扩大上述目标。
+
+          # 当前阶段: ${phase.toUpperCase()}
+          ${phase == 'PLAN' ? '分析任务、拆解步骤、识别风险与未知项；先想清楚再动手。' :
+            phase == 'BUILD' ? '按计划实现，一次只聚焦一个子任务，落到具体文件改动。' :
+            phase == 'VERIFY' ? '运行测试/检查输出/核对验收标准，用证据确认，别凭感觉。' :
+            phase == 'HEAL' ? '已多次验证失败：停止猜测，定位根因再修，避免回归。' :
+            '目标已达成。'}
+
+          # 与循环驱动的通信协议（务必遵守）
+          - 任务**真正完成**时输出 `<promise>DONE</promise>`（驱动会运行验证门）
+          - 当前方案走不通、要换打法时输出 `<PROMISE>NEED_REPLAN</PROMISE>`（回 PLAN）
+          - **目标本身**有问题时输出 `<PROMISE>NEED_GOAL_REVISION</PROMISE>`（干净终止）
+          - 踩到的坑用 `<learning>一句话</learning>` 标记（驱动自动存档供后续参考）
+          ⚠️ 切勿为逃出循环而谎报完成——只有陈述完全为真时才输出完成哨兵。
+
+          ${learnings_text && learnings_text != '' ? '# 关键教训（必须遵守，避免重复踩坑）\n' + learnings_text : ''}
+
+          ---
+          本轮任务 (迭代 ${_iter})
+        capture:
+          result: prompt_text
+
+      # --- 3. 执行 agent 工作（TAOR 引擎，有工具能力） ---
+      - id: work
+        agent: "${prompt_text}"
+        maxTurns: 15
+        capture:
+          text: output
+
+      # --- 4. 提取 learning 并持久化 ---
+      - id: extract_learning
+        llm: |
+          从以下文本中提取所有 <learning>...</learning> 内容，每行一条原样输出。
+          如果没有 learning 标签，输出空字符串。
+          
+          文本：
+          ${output}
+        capture:
+          text: extracted_learning
+
+      - id: save_learning
+        tool: "Bash(command='cat >> .minimal-agent-workflow/learnings.md << EOF\n${extracted_learning}\nEOF')"
+        when: "extracted_learning != ''"
+        onError: continue
+
+      # --- 5. 哵兵检测与分支处理 ---
+
+      # 5a. 是否包含任何哨兵标签？
+      - id: has_sentinel
+        type: branch
+        condition: "includes(output, '<promise>') || includes(output, '<PROMISE>') || includes(output, '<learning>')"
+        then:
+          # 有哨兵标签 → 判断具体类型
+
+          # 5a-i. 完成哨兵？
+          - id: check_complete
+            type: branch
+            condition: |
+              includes(lower(output), '<promise>') &&
+              (includes(lower(output), 'done') ||
+               includes(lower(output), 'complete') ||
+               includes(lower(output), 'goal_complete'))
+            then:
+              # === DONE 哨兵 → 验证门 ===
+              - id: run_verify
+                type: verify
+                checks: "${verify_checks}"
+                when: "verify_checks != ''"
+                onFail: "验证未通过，回到 BUILD 继续"
+                onError: continue
+              # 验证通过或无验证门 → 设置完成阶段并跳出循环
+              - id: set_done
+                llm: "DONE"
+                capture:
+                  result: phase
+              - id: exit_success
+                type: break
+            else:
+            # 非 DONE 哨兵 → NEED_REPLAN 或 NEED_GOAL_REVISION
+            - id: check_replan
+              type: branch
+              condition: "includes(output, 'NEED_REPLAN')"
+              then:
+                # 回到 PLAN
+                - id: replan
+                  llm: "PLAN"
+                  capture:
+                    result: phase
+              else:
+                # NEED_GOAL_REVISION → 终止循环
+                - id: goal_revision_exit
+                  llm: "DONE"
+                  capture:
+                    result: phase
+                - id: exit_goal_revision
+                  type: break
+
+      # 5b. 无哨兵 → 自动阶段推进
+      - id: auto_advance
+        type: branch
+        condition: "phase == 'PLAN' && _iter >= 1"
+        then:
+          - id: to_build
+            llm: "BUILD"
+            capture:
+              result: phase
+
+  # === 循环结束后的收尾 ===
+  - id: final_summary
+    llm: |
+      总结本轮 ralph-loop 的执行结果。如果目标是完成的，列出关键产出物。
+      如果是因达到迭代上限而退出，说明当前进度和下一步建议。
+    maxTurns: 1

package/workflows/youtube-shorts.yaml

@@ -69,8 +69,10 @@ steps:
       content: parse_log
 
   - id: assert_script_parsed
-    type: assert
-    condition: 'fileExists("./assets/prompts.txt") && fileExists("./assets/narrations.txt")'
+    type: verify
+    checks:
+      - 'file_exists:./assets/prompts.txt'
+      - 'file_exists:./assets/narrations.txt'
     onFail: "脚本解析失败：./assets/prompts.txt 或 ./assets/narrations.txt 不存在"
 
   # ---------- 4. 生成 5 张配图（loop 静态数组 + 每轮先读对应一行 prompt） ----------
@@ -149,10 +151,11 @@ steps:
     skill: video-compose
     input: 'images_glob=./assets/img_*.png audio=./assets/audio.mp3 srt=./assets/subs.srt output=./out/shorts.mp4 width=${inputs.width} height=${inputs.height}'
 
-  # ---------- 11. 守门 assert ----------
+  # ---------- 11. 守门 verify（升级自 assert） ----------
   - id: verify_output
-    type: assert
-    condition: 'fileExists("./out/shorts.mp4")'
+    type: verify
+    checks:
+      - 'file_exists:./out/shorts.mp4'
     onFail: "最终视频 ./out/shorts.mp4 未生成，请检查 video-compose 日志"
 
 __meta:

package/plugins/HOW-TO-WRITE-A-PLUGIN.md

@@ -1,186 +0,0 @@
-# How to Write a minimal-agent Plugin
-
-minimal-agent 的插件系统遵循 **drop-in** 原则：把目录扔进 `plugins/`，命令立即可用，**`src/` 一行不改**。
-
-## 两种契约
-
-### 1. 纯声明式（Anthropic 兼容，零 TS）
-
-最小可用插件 = 一个 frontmatter 模板。框架替你拼 prompt 喂给 LLM。
-
-```
-plugins/hello-bot/
-├── .claude-plugin/
-│   └── plugin.json
-└── commands/
-    └── hi.md
-```
-
-**`.claude-plugin/plugin.json`**
-
-```json
-{
-  "name": "hello-bot",
-  "version": "0.1.0",
-  "description": "Greets the user"
-}
-```
-
-**`commands/hi.md`**
-
-```markdown
----
-description: "Greet the user"
-argument-hint: "<name>"
----
-
-你好 $ARGUMENTS！欢迎使用 minimal-agent。
-```
-
-**效果**：用户输入 `/hi 世界` → LLM 收到 `你好 世界！欢迎使用 minimal-agent。\n\n用户参数: 世界`。
-
-支持的占位符：
-- `$ARGUMENTS` / `${ARGUMENTS}` —— 用户在命令名后的全部文本
-- `${CLAUDE_PLUGIN_ROOT}` —— 该插件目录的绝对路径（用于引用插件资源）
-
-### 2. 声明式 + `plugin.ts`（富插件）
-
-当模板不够（要跑循环 / 做 TS 校验 / 启动子进程 / 状态机），加一个 `plugin.ts`：
-
-```
-plugins/echo-bot/
-├── .claude-plugin/plugin.json
-├── commands/echo.md         # 仍要存在！frontmatter 用于 listAvailableCommands
-└── plugin.ts                # PluginApi default export
-```
-
-**`plugin.ts`**
-
-```typescript
-import {
-  runQuery,
-  type PluginApi,
-  type LoopEvent,
-} from '../../src/plugin-sdk.ts';
-
-const api: PluginApi = {
-  async *runCommand(commandName, args, ctx): AsyncGenerator<LoopEvent> {
-    if (commandName === 'echo') {
-      // 直接 yield 自定义事件
-      yield { type: 'text', delta: `你输入了：${args}` };
-      yield { type: 'turn_done' };
-      return;
-    }
-
-    // 或者改写 prompt 后丢给 LLM
-    yield* runQuery(`请把以下内容重复 3 遍：${args}`, {
-      provider: ctx.provider,
-      history: ctx.history,
-      signal: ctx.signal,
-    });
-  },
-};
-
-export default api;
-```
-
-**框架行为**：命中 `/echo abc` 时，`pluginRunner` 优先调用 `runCommand('echo', 'abc', ctx)`，不再走声明式 fallback。你完全接管事件流。
-
-## `plugin-sdk.ts` 暴露的全部 API
-
-**唯一稳定 import 路径**：`from '../../src/plugin-sdk.ts'`（相对你的 `plugin.ts`）。
-
-| 名称 | 类型 | 用途 |
-|------|------|------|
-| `runQuery(input, opts)` | function | 标准 T-A-O-R 循环，AsyncGenerator |
-| `chat(messages, provider, opts)` | function | 单次非流式 LLM 调用 |
-| `executeTool(name, argsJson, ctx)` | function | 框架级工具调用入口 |
-| `getToolByName(name)` | function | 取 Tool 定义 |
-| `ALL_TOOLS` | const | 所有内置工具数组 |
-| `getWorkingDir()` | function | 当前锁定的工作目录 |
-| `getResourceSearchPaths(name, importMetaUrl)` | function | 双源资源路径（cwd + packageRoot） |
-| `triggerHook(event, payload)` | function | 触发框架级 hook |
-| `createSessionState()` | function | 新建 SessionState |
-| `Message` / `Provider` / `LoopEvent` / `LlmStreamEvent` | type | 协议类型 |
-| `Tool` / `ToolCall` / `ToolResult` | type | 工具协议类型 |
-| `PluginApi` / `PluginContext` | type | 你的 plugin.ts 契约 |
-| `ResourceName` / `HookEventName` / `HookDecision` / `SessionState` | type | 杂项 |
-
-**不要**绕开 `plugin-sdk.ts` 直接 import `src/loop.ts` / `src/llm/client.ts` 等内部路径 —— 那些路径不是稳定 API，框架重构时会破坏你的插件。
-
-## `PluginContext`
-
-`runCommand` 收到的 ctx：
-
-```typescript
-interface PluginContext {
-  provider: Provider;          // 当前 LLM provider 配置
-  history: Message[];          // 对话历史（你可以读 / 修改 / 替换）
-  signal?: AbortSignal;        // 用户 ESC / Ctrl+C 时触发
-  sessionState?: SessionState; // 可选共享 session 状态
-  maxTurns?: number;           // 工具循环最大轮数（runQuery 透传用）
-}
-```
-
-## 事件 (`LoopEvent`)
-
-你的 `runCommand` 必须 yield `LoopEvent`，UI 据此渲染。常用的有：
-
-| type | 字段 | 用途 |
-|------|------|------|
-| `text` | `delta: string` | 流式文本片段 |
-| `assistant_message` | (无) | 一次完整 assistant 消息已 push 进 history |
-| `tool_start` | `toolName`, `argsPreview` | 工具开始执行 |
-| `tool_end` | (无) | 工具结束 |
-| `turn_done` | (无) | 整轮交互结束 |
-| `interrupted` | (无) | 用户中断 |
-| `error` | `error: string` | 红色错误提示 |
-| `plugin_progress` | `pluginId`, `current`, `max?`, `message?` | 循环进度条（替代旧的 plugin_start / plugin_iteration） |
-
-通常做法：复杂插件直接 `yield* runQuery(...)` 透传所有事件，自己额外 yield `plugin_progress` 做进度展示。
-
-## 工作目录与持久化
-
-- 状态写到 `getWorkingDir()/.minimal-agent-<your-plugin-id>/` 下，避免污染主 context 目录
-- `/new` 命令会自动清这些 `.minimal-agent*` 目录，你不用管 cleanup
-- 跨平台：Windows 没 bash，hooks/*.sh 静默跳过；其它 .ts 代码完全平台无关
-
-## 命令默认值
-
-框架**不再**注入命令默认参数（旧版 `COMMAND_DEFAULTS` 已删除）。如果你的命令需要默认值（如 `--max-iterations 50`），自己在 `plugin.ts` 里解析 args 时兜底。这样默认值的语义属于插件契约，不属于框架。
-
-## 测试
-
-- 把测试放在 `plugins/<id>/test/*.test.ts`
-- `bunfig.toml` 的 `[test].root = ["./test", "./plugins"]` 让 `bun test` 自动发现
-- 测试里 mock LLM / 工具时，用 `mock.module('../../../src/loop.ts', ...)` 等绝对到 src 的相对路径
-
-## 参考实现
-
-- **声明式 + plugin.ts 简单例**：`plugins/workflow-runner/plugin.ts`（~25 行接管 `/workflow` 与 `/workflows`）
-- **重型循环例**：`plugins/ralph-wiggum/plugin.ts`（~270 行 do-while loop + FSM + sentinel + verification + stop-hook）
-
-## Transcript 与 Hook：当前状态
-
-框架提供了两套基础设施 —— 都**就绪、有测试、可独立调用**，但**主循环 `src/loop.ts` 不自动触发**：
-
-| 模块 | 暴露 | 当前主循环触发？ |
-|------|------|------|
-| `src/plugins/transcript.ts` | `initTranscript / appendUserMessage / appendAssistantMessage / appendToolResult` | 否 |
-| `src/plugins/hookEngine.ts` | `loadHooks / triggerHook('UserPromptSubmit' \| 'PreToolUse' \| 'PostToolUse' \| 'SessionStart' \| 'SessionEnd', payload)` | 否 |
-
-**插件如何使用**：
-- 想写自己的 JSONL transcript → 在 `runCommand` 内 `import { initTranscript, appendUserMessage } from '../../src/plugin-sdk.ts'` 自己调
-- 想响应 hook 事件 → 在 `runCommand` 内 `triggerHook('PreToolUse', { tool_name, ... })` 自己调；ralph-wiggum 走的就是这条路（vendored stop-hook 执行器在 `plugins/ralph-wiggum/src/stopHookRunner.ts`）
-
-**为什么不在主循环自动触发**：当前没有 Anthropic 风格 `hooks/*.sh` 的真实用例驱动；自动触发会改主循环热路径但不解决实际问题。等真有跨插件的全局 hook 需求时再接也不迟。届时只需在 `src/loop.ts` 的 user/assistant/tool 三处 push 点加 `appendXxx` 与 `triggerHook` 调用即可，**不影响插件契约**。
-
-## 不支持的 Anthropic 字段
-
-minimal-agent 的插件契约是 Anthropic 上游的**子集**。当前未实现的字段：
-
-- `mcp-servers/` —— MCP 服务器配置
-- `agents/` —— 子 agent 定义
-- `skills/` 在插件目录下 —— minimal-agent 的 skill 系统是独立顶层目录
-
-未实现字段在 plugin.json 中存在不会报错，但被忽略。

package/plugins/ralph-wiggum/.claude-plugin/plugin.json

@@ -1,9 +0,0 @@
-{
-  "name": "ralph-wiggum",
-  "version": "1.0.0",
-  "description": "Implementation of the Ralph Wiggum technique - continuous self-referential AI loops for interactive iterative development. Run Claude in a while-true loop with the same prompt until task completion.",
-  "author": {
-    "name": "Daisy Hollman",
-    "email": "daisy@anthropic.com"
-  }
-}

package/plugins/ralph-wiggum/README.md

@@ -1,197 +0,0 @@
-# Ralph Wiggum Plugin
-
-Implementation of the Ralph Wiggum technique for iterative, self-referential AI development loops in Minimal Agent.
-
-## What is Ralph?
-
-Ralph is a development methodology based on continuous AI agent loops. As Geoffrey Huntley describes it: **"Ralph is a Bash loop"** - a simple `while true` that repeatedly feeds an AI agent a prompt file, allowing it to iteratively improve its work until completion.
-
-The technique is named after Ralph Wiggum from The Simpsons, embodying the philosophy of persistent iteration despite setbacks.
-
-### Core Concept
-
-This plugin implements Ralph using a **Stop hook** that intercepts Minimal Agent's exit attempts:
-
-```bash
-# You run ONCE:
-/ralph-loop "Your task description" --completion-promise "DONE"
-
-# Then Claude Code automatically:
-# 1. Works on the task
-# 2. Tries to exit
-# 3. Stop hook blocks exit
-# 4. Stop hook feeds the SAME prompt back
-# 5. Repeat until completion
-```
-
-The loop happens **inside your current session** - you don't need external bash loops. The Stop hook in `hooks/stop-hook.sh` creates the self-referential feedback loop by blocking normal session exit.
-
-This creates a **self-referential feedback loop** where:
-- The prompt never changes between iterations
-- Claude's previous work persists in files
-- Each iteration sees modified files and git history
-- Claude autonomously improves by reading its own past work in files
-
-## Quick Start
-
-```bash
-/ralph-loop "Build a REST API for todos. Requirements: CRUD operations, input validation, tests. Output <promise>COMPLETE</promise> when done." --completion-promise "COMPLETE" --max-iterations 50
-```
-
-Claude will:
-- Implement the API iteratively
-- Run tests and see failures
-- Fix bugs based on test output
-- Iterate until all requirements met
-- Output the completion promise when done
-
-## Commands
-
-### /ralph-loop
-
-Start a Ralph loop in your current session.
-
-**Usage:**
-```bash
-/ralph-loop "<prompt>" --max-iterations <n> --completion-promise "<text>"
-```
-
-**Options:**
-- `--max-iterations <n>` - Stop after N iterations (default: 50, hard cap: 200)
-- `--completion-promise <text>` - Phrase that signals completion (natively active; default: DONE / COMPLETE / GOAL_COMPLETE)
-- `--verify "<CHECK>"` - Completion gate run after the promise tag. All checks must pass before the loop exits. Repeatable.
-  - `shell:<cmd>` — exit code 0 = pass (Windows: `cmd /c`, others: `bash -c`)
-  - `file_exists:<path>` — file must exist
-  - `file_contains:<file>:<regex>` — file content matches regex
-  - `test_count:<min>` — `bun test` pass count ≥ min
-
-  Example:
-  ```bash
-  /ralph-loop "Implement and test cache layer" \
-    --verify "shell:bun test" \
-    --verify "file_exists:dist/index.js"
-  ```
-
-### /cancel-ralph
-
-Cancel the active Ralph loop.
-
-**Usage:**
-```bash
-/cancel-ralph
-```
-
-## Prompt Writing Best Practices
-
-### 1. Clear Completion Criteria
-
-❌ Bad: "Build a todo API and make it good."
-
-✅ Good:
-```markdown
-Build a REST API for todos.
-
-When complete:
-- All CRUD endpoints working
-- Input validation in place
-- Tests passing (coverage > 80%)
-- README with API docs
-- Output: <promise>COMPLETE</promise>
-```
-
-### 2. Incremental Goals
-
-❌ Bad: "Create a complete e-commerce platform."
-
-✅ Good:
-```markdown
-Phase 1: User authentication (JWT, tests)
-Phase 2: Product catalog (list/search, tests)
-Phase 3: Shopping cart (add/remove, tests)
-
-Output <promise>COMPLETE</promise> when all phases done.
-```
-
-### 3. Self-Correction
-
-❌ Bad: "Write code for feature X."
-
-✅ Good:
-```markdown
-Implement feature X following TDD:
-1. Write failing tests
-2. Implement feature
-3. Run tests
-4. If any fail, debug and fix
-5. Refactor if needed
-6. Repeat until all green
-7. Output: <promise>COMPLETE</promise>
-```
-
-Tag lessons inline with `<learning>…</learning>` — the driver archives them to `learnings.md` automatically, so subsequent iterations inherit the hard-won knowledge without repeating mistakes.
-
-### 4. Escape Hatches
-
-Always use `--max-iterations` as a safety net to prevent infinite loops on impossible tasks:
-
-```bash
-# Recommended: Always set a reasonable iteration limit
-/ralph-loop "Try to implement feature X" --max-iterations 20
-
-# In your prompt, include what to do if stuck:
-# "After 15 iterations, if not complete:
-#  - Document what's blocking progress
-#  - List what was attempted
-#  - Suggest alternative approaches"
-```
-
-Claude can also signal early exit using two distinct tags:
-- `<PROMISE>NEED_REPLAN</PROMISE>` — current approach is unworkable; loop returns to PLAN with the same goal
-- `<PROMISE>NEED_GOAL_REVISION</PROMISE>` — the goal itself is unreachable; loop stops cleanly for human review. Use this when no approach can work, not just the current one.
-
-**Note**: The `--completion-promise` uses exact string matching and is natively active (no external stop-hook required). It signals Claude's intent to complete; use `--verify` checks for objective verification of that intent.
-
-## Philosophy
-
-Ralph embodies several key principles:
-
-### 1. Iteration > Perfection
-Don't aim for perfect on first try. Let the loop refine the work.
-
-### 2. Failures Are Data
-"Deterministically bad" means failures are predictable and informative. Use them to tune prompts.
-
-### 3. Operator Skill Matters
-Success depends on writing good prompts, not just having a good model.
-
-### 4. Persistence Wins
-Keep trying until success. The loop handles retry logic automatically.
-
-## When to Use Ralph
-
-**Good for:**
-- Well-defined tasks with clear success criteria
-- Tasks requiring iteration and refinement (e.g., getting tests to pass)
-- Greenfield projects where you can walk away
-- Tasks with automatic verification (tests, linters)
-
-**Not good for:**
-- Tasks requiring human judgment or design decisions
-- One-shot operations
-- Tasks with unclear success criteria
-- Production debugging (use targeted debugging instead)
-
-## Real-World Results
-
-- Successfully generated 6 repositories overnight in Y Combinator hackathon testing
-- One $50k contract completed for $297 in API costs
-- Created entire programming language ("cursed") over 3 months using this approach
-
-## Learn More
-
-- Original technique: https://ghuntley.com/ralph/
-- Ralph Orchestrator: https://github.com/mikeyobrien/ralph-orchestrator
-
-## For Help
-
-Run `/help` in Claude Code for detailed command reference and examples.

package/plugins/ralph-wiggum/commands/cancel-ralph.md

@@ -1,18 +0,0 @@
----
-description: "Cancel active Ralph Wiggum loop"
-allowed-tools: ["Bash(test -f .minimal-agent/ralph-loop.local.md:*)", "Bash(rm .minimal-agent/ralph-loop.local.md)", "Read(.minimal-agent/ralph-loop.local.md)"]
-hide-from-slash-command-tool: "true"
----
-
-# Cancel Ralph
-
-To cancel the Ralph loop:
-
-1. Check if `.minimal-agent/ralph-loop.local.md` exists using Bash: `test -f .minimal-agent/ralph-loop.local.md && echo "EXISTS" || echo "NOT_FOUND"`
-
-2. **If NOT_FOUND**: Say "No active Ralph loop found."
-
-3. **If EXISTS**:
-   - Read `.minimal-agent/ralph-loop.local.md` to get the current iteration number from the `iteration:` field
-   - Remove the file using Bash: `rm .minimal-agent/ralph-loop.local.md`
-   - Report: "Cancelled Ralph loop (was at iteration N)" where N is the iteration value