## Shared Repeat Protocol Adds `--repeat --wait ` and `--tillend --wait ` inter-session looping to any command. Uses `ScheduleWakeup` to pause between runs and `.monomind/loops/.json` for dashboard tracking. --- ## REPEAT PREAMBLE Apply immediately after flag extraction, before any other command logic. ### 1. Extract repeat flags Extract and remove these flags from `$ARGUMENTS` before passing the remainder to the command's own parser: | Flag | Variable | Default | Notes | |---|---|---|---| | `--repeat ` | `repeat_count` | `0` | N ≥ 2 activates repeat; N < 2 = disabled | | `--tillend` | `tillend_mode` | `false` | Run until empty round (no findings, no actions). Overrides --repeat. | | `--maxruns ` | `tillend_maxruns` | `50` | Safety cap for --tillend; stops after N runs even if AI hasn't signaled done | | `--wait ` | `wait_seconds` | `60` | Minimum 60 (enforced by ScheduleWakeup) | | `--rep ` | `current_rep` | absent | Internal; injected by ScheduleWakeup on continuation runs | | `--loop ` | `loop_id` | absent | Internal; preserves loop identity across runs | If both `--tillend` and `--repeat ` are present, `--tillend` takes precedence. ### 2. If `--rep N` is present (continuation run) - Set `current_rep` = N, `loop_id` from `--loop ` - Set `is_continuation = true` - The calling command MUST skip its empty-prompt check and intake when `is_continuation = true` **First — staleness guard (run before anything else):** Check whether the loop file exists and whether this wakeup is stale: ```bash LOOP_FILE=".monomind/loops/${LOOP_ID}.json" if [ ! -f "$LOOP_FILE" ]; then echo "[repeat] Stale wakeup: loop ${LOOP_ID} is already complete (state file gone). Skipping." # STOP — do not execute the command else LOOP_CURRENT_REP=$(python3 -c "import json; print(json.load(open('${LOOP_FILE}'))['currentRep'])" 2>/dev/null \ || jq -r '.currentRep // 0' "${LOOP_FILE}" 2>/dev/null || echo "0") if [ "${current_rep}" -lt "${LOOP_CURRENT_REP}" ]; then echo "[repeat] Stale wakeup: got --rep ${current_rep} but loop is already at rep ${LOOP_CURRENT_REP}. Skipping." # STOP — do not execute the command fi fi ``` If the stale guard fires (either branch): **STOP immediately. Do not proceed to HIL check or command execution.** **Before proceeding, check for a pending HIL file:** ```bash HIL_FILE=".monomind/loops/${LOOP_ID}-hil.md" LOOP_HIL_PENDING=false LOOP_HIL_ANSWERED=false if [ -f "$HIL_FILE" ]; then RESPONSES=$(grep -cE "^[[:space:]]*>[[:space:]]+[^[:space:]]" "$HIL_FILE" 2>/dev/null) RESPONSES=${RESPONSES:-0} if [ "$RESPONSES" -eq 0 ]; then LOOP_HIL_PENDING=true else LOOP_HIL_ANSWERED=true fi fi ``` **If `LOOP_HIL_PENDING=true` (HIL file exists but unanswered):** - Output (tillend mode): `[tillend] Loop paused before run : waiting for human responses in ${HIL_FILE}.` - Output (fixed-count mode): `[repeat] Loop paused before run /: waiting for human responses in ${HIL_FILE}.` - Update state file: ```bash python3 -c "import json; f='.monomind/loops/${LOOP_ID}.json'; d=json.load(open(f)); d['status']='hil:pending'; open(f,'w').write(json.dumps(d,indent=2))" 2>/dev/null \ || jq '.status="hil:pending"' ".monomind/loops/${LOOP_ID}.json" > ".monomind/loops/${LOOP_ID}.json.tmp" && mv ".monomind/loops/${LOOP_ID}.json.tmp" ".monomind/loops/${LOOP_ID}.json" 2>/dev/null || true ``` - Emit `loop:hil:waiting`: ```bash REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd) CTRL_URL=$(jq -r '.url // "http://localhost:4242"' "$REPO_ROOT/.monomind/control.json" 2>/dev/null || echo "http://localhost:4242") curl -s -X POST "${CTRL_URL}/api/mastermind/event" -H "x-monomind-token: $(cat "${REPO_ROOT:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}/.monomind/dashboard-token" 2>/dev/null || true)" \ -H "Content-Type: application/json" \ -d "{\"type\":\"loop:hil:waiting\",\"loopId\":\"${LOOP_ID}\",\"hilFile\":\"${HIL_FILE}\",\"rep\":,\"ts\":$(date +%s)000}" || true ``` - Re-schedule a check (not a full run) using ScheduleWakeup: - `delaySeconds`: `min(wait_seconds, 300)` — check at most every 5 minutes - `prompt`: same full continuation prompt (same `--rep `) - `reason`: tillend mode: `"HIL pending for / tillend run — re-checking"` / fixed-count: `"HIL pending for / run / — re-checking"` - STOP. Do not execute the command yet. **If `LOOP_HIL_ANSWERED=true` (human responded):** - Output: `[repeat] Human response received. Archiving HIL file and resuming.` - Archive: `mv "$HIL_FILE" ".monomind/loops/${LOOP_ID}-hil-resolved-$(date +%s).md"` - Emit `loop:hil:resolved`: ```bash REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd) CTRL_URL=$(jq -r '.url // "http://localhost:4242"' "$REPO_ROOT/.monomind/control.json" 2>/dev/null || echo "http://localhost:4242") curl -s -X POST "${CTRL_URL}/api/mastermind/event" -H "x-monomind-token: $(cat "${REPO_ROOT:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}/.monomind/dashboard-token" 2>/dev/null || true)" \ -H "Content-Type: application/json" \ -d "{\"type\":\"loop:hil:resolved\",\"loopId\":\"${LOOP_ID}\",\"rep\":,\"ts\":$(date +%s)000}" || true ``` - Update state file: ```bash python3 -c "import json; f='.monomind/loops/${LOOP_ID}.json'; d=json.load(open(f)); d['status']='running'; open(f,'w').write(json.dumps(d,indent=2))" 2>/dev/null \ || jq '.status="running"' ".monomind/loops/${LOOP_ID}.json" > ".monomind/loops/${LOOP_ID}.json.tmp" && mv ".monomind/loops/${LOOP_ID}.json.tmp" ".monomind/loops/${LOOP_ID}.json" 2>/dev/null || true ``` - Proceed to execute the command: - Tillend mode: `[tillend] Run of / starting...` - Fixed-count: `[repeat] Run / of / starting...` **If no HIL file:** - Tillend mode: `[tillend] Run of / starting...` - Fixed-count: `[repeat] Run / of / starting...` Proceed to the command's core logic. ### 3. If `--rep` is absent — first run **Branch A: `tillend_mode = true`** OR **Branch B: `repeat_count ≥ 2`** If neither condition is true, skip to Section 4. 1. Generate loop ID and write state file: ```bash mkdir -p .monomind/loops # Portable millisecond timestamp (BSD date has no %N; GNU date has %3N) NOW_MS=$(python3 -c 'import time;print(int(time.time()*1000))' 2>/dev/null || echo "$(date +%s)000") LOOP_ID="-${NOW_MS}" # Dashboard expects interval in MINUTES (rounded) INTERVAL_MIN=$(( ( + 30) / 60 )) PROMPT_JSON=$(printf '%s' "" | python3 -c "import sys,json; print(json.dumps(sys.stdin.read()))" 2>/dev/null \ || printf '%s' "" | node -e "process.stdout.write(JSON.stringify(require('fs').readFileSync('/dev/stdin','utf8')))" 2>/dev/null \ || printf '"%s"' "$(printf '%s' "" | sed 's/\\/\\\\/g; s/"/\\"/g; s/$/\\n/g' | tr -d '\n' | sed 's/\\n$//')") ``` **If `tillend_mode = true`:** ```bash cat > ".monomind/loops/${LOOP_ID}.json" << EOF { "id": "${LOOP_ID}", "sessionId": "${LOOP_ID}", "type": "tillend", "command": "/", "prompt": ${PROMPT_JSON}, "maxReps": , "interval": ${INTERVAL_MIN}, "wait": , "currentRep": 1, "startedAt": ${NOW_MS}, "lastRunAt": ${NOW_MS}, "nextRunAt": ${NOW_MS}, "status": "running", "source": "mastermind-repeat/SKILL.md" } EOF ``` **If `repeat_count ≥ 2` (fixed-count mode):** ```bash cat > ".monomind/loops/${LOOP_ID}.json" << EOF { "id": "${LOOP_ID}", "sessionId": "${LOOP_ID}", "type": "repeat", "command": "/", "prompt": ${PROMPT_JSON}, "maxReps": , "interval": ${INTERVAL_MIN}, "wait": , "currentRep": 1, "startedAt": ${NOW_MS}, "lastRunAt": ${NOW_MS}, "nextRunAt": ${NOW_MS}, "status": "running", "source": "mastermind-repeat/SKILL.md" } EOF ``` 2. Emit `loop:start` to dashboard (failure is non-fatal): ```bash REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd) CTRL_URL=$(jq -r '.url // "http://localhost:4242"' "$REPO_ROOT/.monomind/control.json" 2>/dev/null || echo "http://localhost:4242") # For tillend mode, repeat field is the safety cap REPEAT_VAL=$( [ "" = "true" ] && echo "(cap)" || echo "" ) curl -s -X POST "${CTRL_URL}/api/mastermind/event" -H "x-monomind-token: $(cat "${REPO_ROOT:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}/.monomind/dashboard-token" 2>/dev/null || true)" \ -H "Content-Type: application/json" \ -d "{\"type\":\"loop:start\",\"loopId\":\"${LOOP_ID}\",\"command\":\"/\",\"mode\":\"$( [ '' = 'true' ] && echo 'tillend' || echo 'repeat' )\",\"repeat\":\"${REPEAT_VAL}\",\"wait\":,\"ts\":$(date +%s)000}" || true ``` 3. Set `current_rep` = 1, `is_continuation` = false 4. Output: - **tillend mode**: `[tillend] Starting tillend loop for / (runs until empty round, safety cap: , s between runs). Run 1...` - **fixed-count mode**: `[repeat] Starting runs of / (s between each). Run 1/...` ### 4. If neither `tillend_mode` nor `repeat_count ≥ 2` No repeat behavior. Proceed normally. The REPEAT POSTAMBLE is a no-op. --- ## REPEAT POSTAMBLE Apply after the command's core logic fully completes (after skill returns, after final step, etc.). **If neither `tillend_mode` nor `repeat_count ≥ 2`:** skip this section entirely. **Otherwise:** ### 1. Check for stop request ```bash [ -f ".monomind/loops/${LOOP_ID}.stop" ] && REPEAT_STOP=true ``` If `REPEAT_STOP=true`: - Output: `[repeat] Stop requested. Halting after run /.` - `rm -f ".monomind/loops/${LOOP_ID}.json" ".monomind/loops/${LOOP_ID}.stop"` - STOP. ### 2. Report this run complete Output: - Tillend mode: `[tillend] Run complete.` - Fixed-count: `[repeat] Run / complete.` ### 3. Detect HIL items from this run Check for files written since this run started that signal human decisions are needed: ```bash # Collect any humaninloop*.md files created or modified in the last 600 seconds RECENT_HIL=$(find . -maxdepth 3 \( -name "humaninloop*.md" -o -name "humaninloopreview*.md" \) \ -newer ".monomind/loops/${LOOP_ID}.json" 2>/dev/null | head -10) ``` **If `RECENT_HIL` is non-empty (HIL items were written by this run):** 1. Write a loop HIL file aggregating all items: ```bash HIL_FILE=".monomind/loops/${LOOP_ID}-hil.md" # Use run label appropriate to mode RUN_LABEL=$( [ "" = "true" ] && echo "run (tillend)" || echo "run /" ) cat > "$HIL_FILE" << EOF # Human-in-Loop — / ${RUN_LABEL} Loop: ${LOOP_ID} Created: $(date -u +"%Y-%m-%d %H:%M UTC") Status: pending The following files contain items requiring human decisions before the loop continues: $(echo "$RECENT_HIL" | while IFS= read -r f; do [ -n "$f" ] && echo "- \`$f\`"; done) ## Instructions 1. Open each file listed above and fill in **Your response** for each item. 2. Any non-empty response after a \`> \` line is treated as "answered". 3. Once you have filled in at least one response, the loop will auto-resume on the next check. **Your answer (fill in to resume):** > EOF ``` 2. Update state file: ```bash python3 -c "import json; f='.monomind/loops/${LOOP_ID}.json'; d=json.load(open(f)); d['status']='hil:pending'; open(f,'w').write(json.dumps(d,indent=2))" 2>/dev/null \ || jq '.status="hil:pending"' ".monomind/loops/${LOOP_ID}.json" > ".monomind/loops/${LOOP_ID}.json.tmp" && mv ".monomind/loops/${LOOP_ID}.json.tmp" ".monomind/loops/${LOOP_ID}.json" 2>/dev/null || true ``` 3. Emit `loop:hil` to dashboard: ```bash REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd) CTRL_URL=$(jq -r '.url // "http://localhost:4242"' "$REPO_ROOT/.monomind/control.json" 2>/dev/null || echo "http://localhost:4242") curl -s -X POST "${CTRL_URL}/api/mastermind/event" -H "x-monomind-token: $(cat "${REPO_ROOT:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}/.monomind/dashboard-token" 2>/dev/null || true)" \ -H "Content-Type: application/json" \ -d "{\"type\":\"loop:hil\",\"loopId\":\"${LOOP_ID}\",\"command\":\"/\",\"hilFile\":\"${HIL_FILE}\",\"rep\":,\"files\":$(echo "$RECENT_HIL" | grep -v '^$' | jq -R . | jq -cs .),\"ts\":$(date +%s)000}" || true ``` 4. Output: ``` [repeat] Human-in-loop items detected from run . Action required: open the files listed in ${HIL_FILE} and fill in responses. ``` 5. Compute `next_rep = current_rep + 1`. Build the HIL poll continuation prompt: **If `tillend_mode = true`:** - HIL continuation prompt: `/ --tillend --maxruns --wait --rep --loop ${LOOP_ID} ` - Output: `Loop will resume automatically once responses are provided.` - `delaySeconds`: `min(wait_seconds, 300)` - `reason`: `"HIL pending for / tillend run — waiting for human response"` - Schedule via `ScheduleWakeup` and STOP. **If `current_rep >= repeat_count`** (HIL detected on the final fixed-count run): - Output: `[repeat] All runs of / complete (HIL items pending in ${HIL_FILE}).` - Emit `loop:complete`: ```bash REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd) CTRL_URL=$(jq -r '.url // "http://localhost:4242"' "$REPO_ROOT/.monomind/control.json" 2>/dev/null || echo "http://localhost:4242") curl -s -X POST "${CTRL_URL}/api/mastermind/event" -H "x-monomind-token: $(cat "${REPO_ROOT:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}/.monomind/dashboard-token" 2>/dev/null || true)" \ -H "Content-Type: application/json" \ -d "{\"type\":\"loop:complete\",\"loopId\":\"${LOOP_ID}\",\"command\":\"/\",\"ranReps\":,\"hilPending\":true,\"ts\":$(date +%s)000}" || true ``` - `rm -f ".monomind/loops/${LOOP_ID}.json"` - STOP. (HIL file remains for human review; loop is done.) **Otherwise** (HIL on an intermediate fixed-count run): - Output: `Loop will resume automatically at run / once responses are provided.` - `delaySeconds`: `min(wait_seconds, 300)` - `prompt`: `/ --repeat --wait --rep --loop ${LOOP_ID} ` - `reason`: `"HIL pending for / run / — waiting for human response"` - Schedule via `ScheduleWakeup` and STOP. **If `RECENT_HIL` is empty:** proceed to section 4. --- ### 4. Tillend completion check (tillend mode only) **Skip this section if `tillend_mode` is not true.** Proceed to section 5. **`LOOP_ASYNC_PENDING` escape hatch:** If the calling skill set `LOOP_ASYNC_PENDING=true` before invoking the postamble (because it spawned background agents whose results have not yet arrived in this turn), skip the empty-round check entirely — treat this round as non-empty and go directly to section 6 to schedule the next run. The next scheduled run will evaluate results from the agents that are currently in-flight. Output: `[tillend] Async work in flight — deferring empty-round check to run .` After each run in tillend mode, evaluate whether this run produced **zero findings and zero actions**. The loop stops only when a complete round finds nothing new and makes no changes — not when the AI predicts there is nothing left. **Anti-premature-stop rules:** - "I think the work is done" is NOT a reason to stop. Only the checks below decide. - "There's nothing more to find" is a PREDICTION, not an observation. Predictions do not stop loops. - You MUST run the git verification command below. If git shows changes, the round is non-empty. Period. - Only a round where git shows NO changes AND you confirm zero findings AND zero actions qualifies as empty. **Step 4a — Machine verification (REQUIRED — run this command before any self-assessment):** ```bash GIT_CHANGES=$(git diff --stat HEAD 2>/dev/null; git diff --cached --stat 2>/dev/null; git status --porcelain 2>/dev/null | grep -v '^\?\?' | head -20) echo "GIT_CHANGES_DURING_RUN: ${GIT_CHANGES:-NONE}" ``` If `GIT_CHANGES` is non-empty, files were modified — `TILLEND_EMPTY=false` regardless of self-assessment. Skip directly to "Otherwise" below. **Step 4b — Self-assessment (only if git shows no changes):** Only if `GIT_CHANGES` was empty, answer these two questions about this run: 1. **Were any findings produced?** — issues found, problems detected, items identified, things flagged, errors reported, tasks discovered, security vulnerabilities found, etc. 2. **Were any actions taken?** — tasks created, content written, configs changed — anything not captured by git diff. **Set `TILLEND_EMPTY=true` only if git shows no changes AND BOTH answers are "no".** **Important:** If this round found things AND fixed them all, `TILLEND_EMPTY=false`. The loop must run once more to verify the fixes didn't introduce new issues. A "clean" prediction after a productive round is not enough — only an actually empty round stops the loop. **If `TILLEND_EMPTY=true` (round produced nothing):** - Output: ``` [tillend] Empty round — nothing found, nothing changed in run . / tillend loop complete (ran run(s)). ``` - Emit `loop:complete`: ```bash REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd) CTRL_URL=$(jq -r '.url // "http://localhost:4242"' "$REPO_ROOT/.monomind/control.json" 2>/dev/null || echo "http://localhost:4242") curl -s -X POST "${CTRL_URL}/api/mastermind/event" -H "x-monomind-token: $(cat "${REPO_ROOT:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}/.monomind/dashboard-token" 2>/dev/null || true)" \ -H "Content-Type: application/json" \ -d "{\"type\":\"loop:complete\",\"loopId\":\"${LOOP_ID}\",\"command\":\"/\",\"mode\":\"tillend\",\"ranReps\":,\"reason\":\"empty-round\",\"ts\":$(date +%s)000}" || true ``` - `rm -f ".monomind/loops/${LOOP_ID}.json"` - STOP. **If `current_rep >= tillend_maxruns` (safety cap reached):** - Output: ``` [tillend] Safety cap reached ( runs). Stopping loop. If work is still incomplete, re-run: / --tillend --maxruns --wait ``` - Emit `loop:complete`: ```bash REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd) CTRL_URL=$(jq -r '.url // "http://localhost:4242"' "$REPO_ROOT/.monomind/control.json" 2>/dev/null || echo "http://localhost:4242") curl -s -X POST "${CTRL_URL}/api/mastermind/event" -H "x-monomind-token: $(cat "${REPO_ROOT:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}/.monomind/dashboard-token" 2>/dev/null || true)" \ -H "Content-Type: application/json" \ -d "{\"type\":\"loop:complete\",\"loopId\":\"${LOOP_ID}\",\"command\":\"/\",\"mode\":\"tillend\",\"ranReps\":,\"reason\":\"safety-cap\",\"ts\":$(date +%s)000}" || true ``` - `rm -f ".monomind/loops/${LOOP_ID}.json"` - STOP. **Otherwise (`TILLEND_EMPTY=false` and cap not reached):** - Output: `[tillend] Run produced work (findings or actions). Continuing...` - Proceed to section 5 to schedule the next run. --- ### 5. Fixed-count: check if all runs done (`current_rep ≥ repeat_count`) **Skip this section if `tillend_mode = true`** (tillend has no fixed count; section 4 handles its termination). - Output: `[repeat] All runs of / complete.` - `rm -f ".monomind/loops/${LOOP_ID}.json"` - Emit `loop:complete`: ```bash REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd) CTRL_URL=$(jq -r '.url // "http://localhost:4242"' "$REPO_ROOT/.monomind/control.json" 2>/dev/null || echo "http://localhost:4242") curl -s -X POST "${CTRL_URL}/api/mastermind/event" -H "x-monomind-token: $(cat "${REPO_ROOT:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}/.monomind/dashboard-token" 2>/dev/null || true)" \ -H "Content-Type: application/json" \ -d "{\"type\":\"loop:complete\",\"loopId\":\"${LOOP_ID}\",\"command\":\"/\",\"ranReps\":,\"ts\":$(date +%s)000}" || true ``` - STOP (do not schedule another run). ### 6. Schedule next run Set `next_rep` = current_rep + 1. Update state file (read `prompt` and `startedAt` from the existing file to preserve them): ```bash # Portable millisecond timestamp (BSD date has no %N; GNU date has %3N) NOW_MS=$(python3 -c 'import time;print(int(time.time()*1000))' 2>/dev/null || echo "$(date +%s)000") NEXT_AT=$(( NOW_MS + * 1000 )) INTERVAL_MIN=$(( ( + 30) / 60 )) LOOP_TYPE=$( [ "" = "true" ] && echo "tillend" || echo "repeat" ) MAX_REPS=$( [ "" = "true" ] && echo "" || echo "" ) PROMPT_JSON=$(jq '.prompt' ".monomind/loops/${LOOP_ID}.json" 2>/dev/null \ || python3 -c "import json,sys; json.dump(json.load(open('.monomind/loops/${LOOP_ID}.json'))['prompt'], sys.stdout)" 2>/dev/null \ || echo '""') STARTED_AT=$(jq '.startedAt' ".monomind/loops/${LOOP_ID}.json" 2>/dev/null \ || python3 -c "import json; print(json.load(open('.monomind/loops/${LOOP_ID}.json'))['startedAt'])" 2>/dev/null \ || echo "${NOW_MS}") cat > ".monomind/loops/${LOOP_ID}.json" << EOF { "id": "${LOOP_ID}", "sessionId": "${LOOP_ID}", "type": "${LOOP_TYPE}", "command": "/", "prompt": ${PROMPT_JSON}, "maxReps": ${MAX_REPS}, "interval": ${INTERVAL_MIN}, "wait": , "currentRep": , "startedAt": ${STARTED_AT}, "lastRunAt": ${NOW_MS}, "nextRunAt": ${NEXT_AT}, "status": "running", "source": "mastermind-repeat/SKILL.md" } EOF ``` Emit `loop:tick`: ```bash REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd) CTRL_URL=$(jq -r '.url // "http://localhost:4242"' "$REPO_ROOT/.monomind/control.json" 2>/dev/null || echo "http://localhost:4242") curl -s -X POST "${CTRL_URL}/api/mastermind/event" -H "x-monomind-token: $(cat "${REPO_ROOT:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}/.monomind/dashboard-token" 2>/dev/null || true)" \ -H "Content-Type: application/json" \ -d "{\"type\":\"loop:tick\",\"loopId\":\"${LOOP_ID}\",\"command\":\"/\",\"mode\":\"${LOOP_TYPE}\",\"completedRep\":,\"nextRep\":,\"nextAt\":${NEXT_AT},\"ts\":$(date +%s)000}" || true ``` **Output and ScheduleWakeup:** **If `tillend_mode = true`:** - Output: `[tillend] Work remains. Next run in s (run , cap: )...` - `ScheduleWakeup`: - `delaySeconds`: `` - `prompt`: `/ --tillend --maxruns --wait --rep --loop ${LOOP_ID} ` - `reason`: `"tillend run of / (cap: )"` **If fixed-count mode:** - Output: `[repeat] Next run in s (run /)...` - `ScheduleWakeup`: - `delaySeconds`: `` - `prompt`: `/ --repeat --wait --rep --loop ${LOOP_ID} ` - `reason`: `"repeat run / of /"` --- ## Notes for Calling Commands - **Async agents in loop mode**: In `--repeat` or `--tillend` mode, all subagents MUST be synchronous (`run_in_background: false` or omitted). The postamble's empty-round check runs in the same turn as the command — background agents complete in a later turn and their output is invisible to the check. If a skill must go async (e.g. it needs to spawn a long-running agent), set `LOOP_ASYNC_PENDING=true` before invoking the postamble; section 4 will skip the empty-round check and schedule the next run unconditionally. The next run will then evaluate the results. - **Loop state is durable across turns**: The counter and all loop parameters survive across `ScheduleWakeup` fires via two mechanisms: (1) `--rep --loop ` is re-encoded in every ScheduleWakeup prompt, and (2) the `.monomind/loops/.json` file stores current state persistently. There is no in-memory counter — the counter is always re-read from the prompt flags or the file. - **``**: lowercase command name without namespace (`build` for `/mastermind:build`, `mastermind-idea` for `/mastermind:idea`) - **Dashboard**: the monomind panel reads `.monomind/loops/*.json`; `type` field is `"repeat"` or `"tillend"`; HIL status shows as `"hil:pending"` - **Stopping a loop**: create `.monomind/loops/${LOOP_ID}.stop` or delete the `.json` file; the next wake-up detects it - **`wait_seconds` < 60**: ScheduleWakeup clamps to 60; the state file may reflect the user's requested value - **Continuation runs skip intake**: calling commands check `is_continuation` and bypass empty-prompt checks and vague-prompt intake - **HIL file naming**: commands write `humaninloop*.md` or `humaninloopreview*.md`; the repeat protocol detects these automatically via `find` — no changes needed in individual commands - **HIL resume**: the human fills in any `> ` answer line in the HIL files; the next check detects this via `grep -cE "^[[:space:]]*>[[:space:]]+[^[:space:]]"` and resumes the loop - **HIL check interval**: while HIL is pending, ScheduleWakeup fires every `min(wait_seconds, 300)` seconds to poll; this is transparent to the user - **`--tillend` termination**: the loop stops only when a complete round produces ZERO findings AND ZERO actions. If the round found+fixed things, it continues — even if the AI predicts "all done". Only a genuinely empty verification round stops the loop. `reason: "empty-round"` in the `loop:complete` event. - **`--tillend` safety cap**: default 50 runs. Override with `--maxruns `. Always emit a warning when stopping on cap so user knows to re-run if needed - **Combining flags**: `--tillend` overrides `--repeat N` if both are present. `--maxruns` only applies to `--tillend`