@4pm/cli 1.18.0 → 1.19.0

package/dist/project-sample/.claude/AUTONOMOUS-CRON.md

@@ -1,39 +1,31 @@
-# Set up a 10-minute cron for `autonomous-tick.sh`
+# Set up the cron tick for autonomous mode
 
-How to install the **autonomous cycle** on **WSL (Ubuntu)**: cron calls
-[`autonomous-tick.sh`](autonomous-tick.sh) every **10 minutes**; each run does one **`4pm auto-run`**
-cycle (the running `4pm start` daemon executes it — ADR-0319) then exits. A file lock
-(`.claude/.autonomous.lock`) ensures **no two runs overlap** (a later tick that sees the lock skips).
+How to install the **autonomous cron tick** on **WSL (Ubuntu)**. Under **ADR-0321** the tick is a **dumb**
+one-liner (`exec 4pm auto-run`) — all logic lives in the cli/daemon, and all config lives in
+`~/.4pm/profiles/<name>/autonomous.config.json` (edited from the web **Autonomous → Settings** tab), so
+nothing about the loop is configured in this file or the repo.
 
-> All commands below run in a **WSL shell** (Ubuntu) unless noted as PowerShell/Windows. Call the project
-> root `$PROJECT` (e.g. `~/projects/<your-project>`).
+> Run in a **WSL shell** (Ubuntu). Call the project root `$PROJECT` (e.g. `~/projects/<your-project>`).
 
-## 0. Set a variable for convenience
-```bash
-PROJECT="$HOME/projects/<your-project>"   # fix to your path
-cd "$PROJECT"
-```
-
-## 1. Check the required tools
-Every line must print a path/version (not "not found"):
+## 1. Check the tools
 ```bash
 command -v cron   || echo "missing cron"
 command -v 4pm    || echo "missing 4pm cli (install natively in WSL; a '4pm start' daemon must be running)"
 command -v git    || echo "missing git"
-command -v python3 || echo "missing python3"
 command -v gh     || command -v glab || echo "missing gh/glab (needed for the PR step)"
 ```
 
-## 2. Make the tick executable + install the cron line
+## 2. Install the tick
 ```bash
 chmod +x "$PROJECT/.claude/hooks/autonomous-tick.sh"
 crontab -e
 # add (fix the path):
 */10 * * * * /home/<user>/projects/<your-project>/.claude/hooks/autonomous-tick.sh
 ```
-The schedule is also driven by `cron_schedule` in `.claude/.autonomous.settings.json`; once the crontab
-line exists, the tick keeps it in sync on later runs.
+After that, set the **schedule** and every other knob from the web **Autonomous → Settings** tab — the
+cli keeps this crontab line's schedule in sync with `cronSchedule`, and **Start/Pause** + **Install/
+Uninstall cron** are driven from the **Overview** tab.
 
-## 3. Enable / watch
-- Set `"paused": false` in `.claude/.autonomous.settings.json` to enable (or use the web Autonomous tab).
-- Watch: `tail -f .claude/logs/autonomous-tick-$(date +%F).log`
+## 3. Watch
+The daemon writes a per-day tick log; view it from the web **Autonomous → Logs** tab (or on the worker
+at `.claude/logs/autonomous-tick-$(date +%F).log`).

package/dist/project-sample/.claude/AUTONOMOUS.md

@@ -1,52 +1,47 @@
 # Autonomous mode — how it's assembled
 
-> **Sample project — defines the workflow only, does NOT run on its own.** The files below describe an
-> unattended work loop (ADR-0152 + **ADR-0319**), intended to run on **WSL** (an isolated environment
-> where the AI can be given full permissions). Under ADR-0319 the cycle runs **through the 4PM cli**,
-> not a raw `claude -p`.
+> **Sample project — describes the workflow only; it does NOT run on its own.** Intended for an isolated
+> environment (WSL / a per-project container) where the AI can be given full permissions.
+>
+> **ADR-0321: the autonomous LOGIC lives in the 4PM cli, not in this repo.** The project repo carries
+> only a **dumb** cron tick and the **data** books — never the algorithm — so the logic can't be read
+> from, or tampered with in, a checkout. The **config** is not in the repo either: it lives in the
+> **profile dir** (`~/.4pm/profiles/<name>/autonomous.config.json`) and is edited from the web
+> **Autonomous → Settings** tab.
 
 ## The pieces
-| File | Role |
-|------|------|
-| `.claude/hooks/autonomous-tick.sh` | Cron tick (every ~5–10 min): a run lock + the CHEAP local gates (pause / quiet-hours / max-ticks / **has-work**), then runs **`4pm auto-run`**. No token spend when there's no approved work. |
-| `4pm auto-run` (cli) | Asks the running **`4pm start`** daemon to run **one** cycle over the control socket; the cycle rides the daemon's live WS session (failover ADR-0182, metering ADR-0072, folder-scope ADR-0181, timeout ADR-0243). |
-| cli `buildAutonomousCyclePrompt` | The cli-owned cycle instructions (was `.claude/commands/auto-cycle.md`, now retired): sync branch → analyse **approved** USER_TODO → fold **approved** USER_QA → do ONE approved task → **PR** into the base branch. |
-| `.claude/.autonomous.approvals.json` | Approval source of truth (ADR-0152): `{ "<REQ/QA/TSK-id>": {approved, by, at} }` — the web AI-content grids write it; the cycle reads it. |
-| `USER_TODO.md` / `USER_QA.md` | User requests / the AI's questions back — each row approved before the cycle acts on it (ADR-0319). |
-| `AI_TODO.md` / `AI_PROGRESS.md` / `AI_DONE.md` | The task books: queue → in progress → done (ID `TSK-{group:0000}-{task:0000}`). |
-| `.claude/templates/<NAME>.{empty,sample}.md` | Canonical templates for the books. The has-work gate + the cycle **compare against `*.empty.md`** to tell empty/has-work and reset correctly. |
-| `.claude/settings.json` | The "bypass all" permission profile for autonomous mode (see the note below). |
+| Where | Role |
+|-------|------|
+| `.claude/hooks/autonomous-tick.sh` | **Dumb** cron tick — its only job is `exec 4pm auto-run`. No gates, no schedule sync, no lock, no settings. |
+| `4pm auto-run` (cli) | Asks the running **`4pm start`** daemon to run **one** cycle over the control socket (token-authenticated — ADR-0320/0321). |
+| cli daemon (`runAutonomousCycle`) | Owns **all** logic: reads `autonomous.config.json`; the gates (paused / quiet-hours / max-ticks / **has-work** / **quota**); cron schedule sync; run histories + auto-pause; serialize one cycle at a time; model; usage via the live snapshot (ADR-0072). Runs the cycle as a write-capable agent (bypass — ADR-0271: branch + PR). |
+| `~/.4pm/profiles/<name>/autonomous.config.json` | The config knobs (paused, cronSchedule, quietHours, maxTicksPerDay, stopOnConsecutiveFailures, logRetentionDays, model, **maxSessionPct**, **maxWeeklyPct**). Clean JSON — the web Settings Form labels + explains each field. **Outside the repo.** |
+| `USER_TODO.md` / `USER_QA.md` / `AI_TODO.md` / `AI_PROGRESS.md` / `AI_DONE.md` | The data books (content-only tables — ADR-0320). |
+| `.claude/.autonomous.approvals.json` · `.autonomous.authors.json` | Per-row approver / writer (ADR-0320) — project data. `.autonomous.histories.json` = runtime state (gitignored). |
 
 ## Lifecycle (1 tick)
 ```
-cron ~5–10min → autonomous-tick.sh
-  ├─ locked? / paused? / quiet-hours? / max-ticks? → log "skip", exit
-  ├─ has-work? (approved USER_TODO/USER_QA/AI_TODO, or AI_PROGRESS non-empty) — no → skip (daemon NOT woken)
-  └─ 4pm auto-run → the running daemon runs ONE cycle:
-       1. sync the primary repo's current branch (base branch — ADR-0292)
-       2. analyse APPROVED USER_TODO requests → AI_TODO tasks (unclear ⇒ ask via USER_QA)
-       3. fold APPROVED USER_QA answers back into AI_TODO
-       4. take ONE approved task (deps met) → AI_PROGRESS, commit
-       5. implement + test on task/TSK-… branch
-       6. rebase + push + open a PULL REQUEST into the base branch (no direct merge)
-       7. update the books (AI_DONE), commit + push the base branch
-  └─ record success/failure (N consecutive failures → pause); the EXIT trap releases the lock
+cron → autonomous-tick.sh → `4pm auto-run` → the running daemon:
+  ├─ paused / quiet-hours / max-ticks / has-work / quota over caps? → log "skip", done
+  └─ run ONE cycle (write-capable agent):
+       sync the primary repo's branch → analyse APPROVED USER_TODO → fold APPROVED USER_QA →
+       one approved task → implement + test → open a PULL REQUEST into the base branch → update books
+  └─ record history (N consecutive failures → auto-pause); serialized (one cycle at a time)
 ```
 
 ## Install on WSL
 ```bash
 chmod +x .claude/hooks/autonomous-tick.sh
 crontab -e
-# add the line (fix /path):
+# add (fix /path):
 */10 * * * * /path/to/project/.claude/hooks/autonomous-tick.sh
-# watch:
-tail -f .claude/logs/autonomous-tick-$(date +%F).log
 ```
-Requirements: the **`4pm`** cli on PATH with a **running `4pm start` daemon** serving this project (it
-holds the AI credentials + WS session), plus `git`, `python3`, and `gh`/`glab` for the PR step.
+Requirements: the **`4pm`** cli on PATH with a **running `4pm start` daemon** serving this project, plus
+`git` and `gh`/`glab` for the PR step. The **schedule** and every other knob are set from the web
+Autonomous → Settings tab; the cli keeps the crontab line in sync with `cronSchedule`.
 
-## Note on permissions (important)
-- The daemon runs the cycle as a **write-capable agent** (`--permission-mode bypassPermissions`,
-  ADR-0271) so file + git/`gh`/`glab` writes run headless. It stays bounded by the folder-scope guard
-  (ADR-0181) + the AI-run timeout (ADR-0243).
-- Only enable full permissions in an isolated environment (WSL/CI). Never on a machine with sensitive data.
+## Permissions
+The daemon runs the cycle as a write-capable agent (`--permission-mode bypassPermissions`, ADR-0271),
+bounded by the folder-scope guard (ADR-0181) + the AI-run timeout (ADR-0243). Only enable full
+permissions in an isolated environment (WSL / a per-project container). Never on a machine with
+sensitive data.

package/dist/project-sample/.claude/hooks/autonomous-tick.sh

@@ -1,239 +1,15 @@
 #!/usr/bin/env bash
-# Cron tick for the autonomous workflow (ADR-0152 + ADR-0319) — install on WSL. Control flags live in
-# .claude/.autonomous.settings.json (paused, cron_schedule, quiet_hours, max_ticks_per_day, …); read
-# EVERY tick, so changes take effect next tick (cron_schedule auto-syncs into the crontab).
+# Autonomous cron tick (ADR-0321). Its ONLY job is to invoke the 4PM cli — there is NO autonomous logic
+# here. All decisions (config, paused/quiet-hours/max-ticks/has-work/quota gates, cron schedule sync,
+# run histories, serialization, model, usage checks) live in the cli/daemon, so the logic can't be read
+# from or tampered with in the project repo. `4pm auto-run` asks the running `4pm start` daemon to run
+# one cycle through its live session.
 #
 #   Install once:  crontab -e   →   */10 * * * * /path/to/project/.claude/hooks/autonomous-tick.sh
-#
-# What changed with ADR-0319: the tick no longer runs `claude -p /auto-cycle` directly. It runs
-# `4pm auto-run`, which asks the ALREADY-RUNNING `4pm start` daemon to run one cycle through its live
-# WS session — so the cycle reuses the cli's profile/quota failover (ADR-0182), token metering
-# (ADR-0072), folder-scope (ADR-0181) and AI-run timeout (ADR-0243). Account selection + the token/quota
-# gate now live in the cli (they need the live usage snapshot), NOT in this shell.
-#
-# This tick keeps only the CHEAP local gates (no token spend): a run lock, pause, quiet-hours,
-# max-ticks/day, and a "has-work" check — so the daemon is only woken when there is approved work.
-#
-# "Busy ⇒ wait for the next tick" via the EXISTENCE of `.autonomous.lock` (not flock):
-#   - lock file exists → another tick is running → log "skip" and exit.
-#   - it doesn't       → create the lock → run one cycle via the daemon.
-# The EXIT trap removes the lock whether the cycle succeeds or dies.
+#   (the cli keeps this crontab line's schedule in sync with autonomous.config.json).
 set -euo pipefail
 
-# Project root = two levels above this file (.claude/hooks → .claude → root)
-PROJECT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
-LOCK="$PROJECT_DIR/.claude/.autonomous.lock"
-HIST="$PROJECT_DIR/.claude/.autonomous.histories.json"
-HIST_PY="$PROJECT_DIR/.claude/hooks/autonomous-history.py"
-LOG_DIR="$PROJECT_DIR/.claude/logs"
-mkdir -p "$LOG_DIR"
-LOG="$LOG_DIR/autonomous-tick-$(date +%F).log"   # per-DAY log (so log_retention_days is meaningful)
-ts() { date '+%F %T'; }
-
-# Create the lock atomically: `noclobber` makes `> file` FAIL if the file exists, closing the race
-# where two ticks both pass a separate "does it exist?" check.
-if ! ( set -o noclobber; : > "$LOCK" ) 2>/dev/null; then
-  echo "$(ts) [skip] busy (.autonomous.lock exists) — waiting for the next tick" >> "$LOG"
-  exit 0
-fi
-# The lock is released when this wrapper exits, whether the cycle succeeded, errored, or was skipped.
-trap 'rm -f "$LOCK"' EXIT
-
-cd "$PROJECT_DIR"
-
-# cron runs with a minimal PATH and does NOT load ~/.bashrc. Add common WSL install dirs so cron can
-# find the `4pm` binary (native install / npm global) + python3.
+# cron has a minimal PATH and does not load ~/.bashrc; add common WSL install dirs so `4pm` is found.
 export PATH="$HOME/.local/bin:$HOME/.npm-global/bin:/usr/local/bin:$PATH"
 
-# --- Python (needed for: reading settings + the has-work gate + history) -----------------------
-PY_BIN="$(command -v python3 || command -v python || true)"
-if [ -z "$PY_BIN" ]; then
-  echo "$(ts) [error] python/python3 not found — skipping this tick" >> "$LOG"
-  exit 0
-fi
-
-# 'hist' wrapper: every read/write of .autonomous.histories.json goes through the Python helper.
-hist() { "$PY_BIN" "$HIST_PY" "$HIST" "$@"; }
-
-# --- Read the autonomous config (.autonomous.settings.json) ------------------------------------
-# User-editable; read EVERY tick so changes take effect next tick. A missing/corrupt file -> defaults.
-SETTINGS="$PROJECT_DIR/.claude/.autonomous.settings.json"
-eval "$("$PY_BIN" - "$SETTINGS" <<'PY'
-import json, sys, shlex
-defaults = {"paused": False, "cron_schedule": "*/10 * * * *", "command": "auto-run", "profile": "",
-            "quiet_hours": "", "max_ticks_per_day": -1, "stop_on_consecutive_failures": 3,
-            "log_retention_days": 14, "notify_webhook": ""}
-try:
-    d = json.load(open(sys.argv[1], encoding="utf-8"))
-    if not isinstance(d, dict): d = {}
-except Exception:
-    d = {}
-def g(k): return d.get(k, defaults[k])
-print("CFG_PAUSED=" + ("1" if bool(g("paused")) else "0"))
-print("CFG_CRON_SCHEDULE=" + shlex.quote(str(g("cron_schedule"))))
-print("CFG_PROFILE=" + shlex.quote(str(g("profile"))))
-print("CFG_QUIET_HOURS=" + shlex.quote(str(g("quiet_hours"))))
-print("CFG_MAX_TICKS_PER_DAY=" + shlex.quote(str(g("max_ticks_per_day"))))
-print("CFG_STOP_ON_CONSEC_FAILURES=" + shlex.quote(str(g("stop_on_consecutive_failures"))))
-print("CFG_LOG_RETENTION_DAYS=" + shlex.quote(str(g("log_retention_days"))))
-print("CFG_NOTIFY_WEBHOOK=" + shlex.quote(str(g("notify_webhook"))))
-PY
-)"
-# Export CFG_* so the history helper ('record') can read the run config from env.
-export CFG_CRON_SCHEDULE CFG_QUIET_HOURS CFG_MAX_TICKS_PER_DAY CFG_STOP_ON_CONSEC_FAILURES CFG_PAUSED
-
-# --- Sync the crontab when cron_schedule changes ----------------------------------------------
-SELF="$PROJECT_DIR/.claude/hooks/autonomous-tick.sh"
-PREV_SCHED="$(hist get-cron 2>/dev/null || true)"
-if [ "$CFG_CRON_SCHEDULE" != "$PREV_SCHED" ]; then
-  if command -v crontab >/dev/null 2>&1; then
-    CUR="$(crontab -l 2>/dev/null || true)"
-    if printf '%s\n' "$CUR" | grep -qF "$SELF" || [ -n "$PREV_SCHED" ]; then
-      NEWTAB="$( { printf '%s\n' "$CUR" | grep -vF "$SELF" || true; echo "$CFG_CRON_SCHEDULE $SELF"; } )"
-      if printf '%s\n' "$NEWTAB" | crontab - 2>>"$LOG"; then
-        hist set-cron "$CFG_CRON_SCHEDULE" 2>>"$LOG" || true
-        echo "$(ts) [cron] synced schedule -> '$CFG_CRON_SCHEDULE'" >> "$LOG"
-      else
-        echo "$(ts) [warn] could not write crontab (keeping the old schedule)" >> "$LOG"
-      fi
-    else
-      echo "$(ts) [cron] crontab has no autonomous line — skipping auto-install (install it once manually first)" >> "$LOG"
-    fi
-  else
-    echo "$(ts) [cron] no 'crontab' on PATH — skipping schedule sync" >> "$LOG"
-  fi
-fi
-
-# --- Pause flag -------------------------------------------------------------------------------
-if [ "$CFG_PAUSED" = "1" ]; then
-  echo "$(ts) [skip] paused=true in .autonomous.settings.json — skipping this tick" >> "$LOG"
-  exit 0
-fi
-
-# --- Prune old logs by log_retention_days -----------------------------------------------------
-if [ "${CFG_LOG_RETENTION_DAYS:-0}" -gt 0 ] 2>/dev/null; then
-  find "$LOG_DIR" -maxdepth 1 -type f -name 'autonomous-tick-*.log' -mtime +"$CFG_LOG_RETENTION_DAYS" -delete 2>/dev/null || true
-fi
-
-# --- Quiet hours ------------------------------------------------------------------------------
-if [ -n "$CFG_QUIET_HOURS" ]; then
-  if printf '%s' "$CFG_QUIET_HOURS" | grep -Eq '^[0-9]{1,2}:[0-9]{2}-[0-9]{1,2}:[0-9]{2}$'; then
-    q_start="${CFG_QUIET_HOURS%%-*}"; q_end="${CFG_QUIET_HOURS##*-}"
-    _min() { echo $(( 10#${1%%:*} * 60 + 10#${1##*:} )); }
-    qs=$(_min "$q_start"); qe=$(_min "$q_end"); qn=$(_min "$(date +%H:%M)")
-    in_q=0
-    if [ "$qs" -le "$qe" ]; then
-      { [ "$qn" -ge "$qs" ] && [ "$qn" -lt "$qe" ]; } && in_q=1
-    else
-      { [ "$qn" -ge "$qs" ] || [ "$qn" -lt "$qe" ]; } && in_q=1   # window crossing midnight
-    fi
-    if [ "$in_q" = 1 ]; then
-      echo "$(ts) [skip] within quiet_hours ($CFG_QUIET_HOURS) — skipping this tick" >> "$LOG"
-      exit 0
-    fi
-  else
-    echo "$(ts) [warn] quiet_hours has a bad format ('$CFG_QUIET_HOURS') — ignoring the check" >> "$LOG"
-  fi
-fi
-
-# --- Max ticks/day ----------------------------------------------------------------------------
-TODAY="$(date +%F)"
-tick_count="$(hist get-ticks "$TODAY" 2>/dev/null || echo 0)"; [ -z "$tick_count" ] && tick_count=0
-if [ "${CFG_MAX_TICKS_PER_DAY:--1}" -gt 0 ] 2>/dev/null && [ "${tick_count:-0}" -ge "$CFG_MAX_TICKS_PER_DAY" ]; then
-  echo "$(ts) [skip] reached max_ticks_per_day=$CFG_MAX_TICKS_PER_DAY ($tick_count ticks today) — skipping" >> "$LOG"
-  exit 0
-fi
-
-# --- "Has work" gate --------------------------------------------------------------------------
-# Skip WITHOUT waking the daemon unless there is one of:
-#   1) an APPROVED USER_TODO request (REQ-… approved in .autonomous.approvals.json) — Step 2 analyses it;
-#   2) an APPROVED USER_QA answer   (QA-… approved)                                 — Step 3 folds it in;
-#   3) an APPROVED AI_TODO task     (TSK-… approved)                                — Step 4 can take it;
-#   4) AI_PROGRESS.md non-empty (leftover work from a previous tick).
-# Approval is the source of truth in .autonomous.approvals.json (ADR-0152/0319), keyed per row id.
-TPL="$PROJECT_DIR/.claude/templates"
-WORK="$(USER_TODO="$PROJECT_DIR/USER_TODO.md" USER_QA="$PROJECT_DIR/USER_QA.md" \
-        AI_TODO="$PROJECT_DIR/AI_TODO.md" AI_PROGRESS="$PROJECT_DIR/AI_PROGRESS.md" \
-        APPROVALS="$PROJECT_DIR/.claude/.autonomous.approvals.json" \
-        AI_PROGRESS_TPL="$TPL/AI_PROGRESS.empty.md" \
-        "$PY_BIN" - <<'PY'
-import os, json
-def read(p):
-    try: return open(p, encoding="utf-8").read()
-    except Exception: return ""
-def norm(t):
-    lines = [ln.rstrip() for ln in t.splitlines()]
-    while lines and not lines[0]: lines.pop(0)
-    while lines and not lines[-1]: lines.pop()
-    return "\n".join(lines)
-try:
-    ap = json.load(open(os.environ["APPROVALS"], encoding="utf-8"))
-    approved = {k for k, v in ap.items() if isinstance(v, dict) and v.get("approved") is True}
-except Exception:
-    approved = set()
-def approved_in(book_env, prefix):
-    text = read(os.environ[book_env])
-    return any(i.startswith(prefix) and i in text for i in approved)
-user  = approved_in("USER_TODO", "REQ-")
-qa    = approved_in("USER_QA",   "QA-")
-ai    = approved_in("AI_TODO",   "TSK-")
-prog  = norm(read(os.environ["AI_PROGRESS"])) != norm(read(os.environ["AI_PROGRESS_TPL"]))
-print("WORK" if (user or qa or ai or prog) else "EMPTY")
-PY
-)"
-if [ "$WORK" != "WORK" ]; then
-  echo "$(ts) [skip] no approved USER_TODO/USER_QA/AI_TODO work and AI_PROGRESS empty — skipping (daemon not woken)" >> "$LOG"
-  exit 0
-fi
-
-# --- Locate the `4pm` cli ---------------------------------------------------------------------
-FOURPM_BIN="${FOURPM_BIN:-$(command -v 4pm || true)}"
-if [ -z "$FOURPM_BIN" ]; then
-  echo "$(ts) [error] '4pm' not found on PATH — install the 4PM cli in WSL (e.g. ~/.local/bin/4pm)" >> "$LOG"
-  exit 0
-fi
-
-# Record 1 tick that ACTUALLY runs a cycle (for max_ticks_per_day).
-tick_count=$(( ${tick_count:-0} + 1 ))
-hist set-ticks "$TODAY" "$tick_count" 2>>"$LOG" || true
-
-# Optional profile pin (settings.profile) — else the cli resolves the single linked profile.
-PROFILE_ARGS=()
-[ -n "${CFG_PROFILE:-}" ] && PROFILE_ARGS=(--profile "$CFG_PROFILE")
-
-echo "$(ts) [run] 4pm auto-run (tick $tick_count/$TODAY)" >> "$LOG"
-set +e
-"$FOURPM_BIN" auto-run ${PROFILE_ARGS[@]+"${PROFILE_ARGS[@]}"} >> "$LOG" 2>&1
-RC=$?
-set -e
-
-# --- Record the run + count consecutive failures + auto-stop ----------------------------------
-# RC != 0 (no daemon / dispatch error) -> increment; reaching the threshold -> paused=true. RC == 0 -> reset.
-fails="$(hist get-fails 2>/dev/null || echo 0)"; [ -z "$fails" ] && fails=0
-if [ "$RC" -ne 0 ]; then
-  echo "$(ts) [warn] 4pm auto-run exited $RC" >> "$LOG"
-  fails=$(( ${fails:-0} + 1 )); hist set-fails "$fails" 2>>"$LOG" || true
-  hist record "$(ts)" failure "$RC" "" "consecutive failure #$fails" 2>>"$LOG" || true
-  if [ "${CFG_STOP_ON_CONSEC_FAILURES:-0}" -gt 0 ] 2>/dev/null && [ "$fails" -ge "$CFG_STOP_ON_CONSEC_FAILURES" ]; then
-    "$PY_BIN" - "$SETTINGS" <<'PY' 2>>"$LOG" || true
-import json, sys
-p = sys.argv[1]
-try:
-    d = json.load(open(p, encoding="utf-8"))
-    d["paused"] = True
-    with open(p, "w", encoding="utf-8") as f:
-        json.dump(d, f, ensure_ascii=False, indent=2); f.write("\n")
-except Exception:
-    pass
-PY
-    echo "$(ts) [stop] $fails consecutive failures >= $CFG_STOP_ON_CONSEC_FAILURES → set paused=true (resume manually)" >> "$LOG"
-  fi
-else
-  hist set-fails 0 2>>"$LOG" || true   # success → reset the consecutive-failure count
-  hist record "$(ts)" success "$RC" "" "cycle complete" 2>>"$LOG" || true
-fi
-
-# notify_webhook: TBD — a run summary would be POSTed here if CFG_NOTIFY_WEBHOOK is set.
-
-echo "$(ts) [done] tick finished" >> "$LOG"
-# The EXIT trap above removes `.autonomous.lock` → the lock is released for the next tick.
+exec 4pm auto-run

package/dist/project-sample/.claude/templates/AI_TODO.empty.md

@@ -6,9 +6,9 @@
 > **Tag** = optional catalog tag(s) (e.g. `UpdateSpecFromDB`) whose action runs from the server down to
 > the project when the task is approved (approval is committed on Save — ADR-0311).
 > **Approval** is NOT a table column — it lives in `.claude/.autonomous.approvals.json` (ADR-0152), set
-> from the web AI Todo grid; `/auto-cycle` reads that file, never the table.
+> from the web AI Todo grid; the autonomous cli reads that file, never the table.
 > **Depends** = the `TSK-…` ids that must be DONE (present in `AI_DONE.md`) first.
-> `/auto-cycle` only takes tasks that are approved AND have their dependencies met → moves them to
+> the autonomous cli only takes tasks that are approved AND have their dependencies met → moves them to
 > `AI_PROGRESS.md`; runs group by group, within a group High → Medium → Low.
 
 | ID | Priority | Tag | Depends | Group | Task description | Notes |

package/dist/project-sample/.claude/templates/README.md

@@ -2,7 +2,7 @@
 
 Canonical templates for the 5 "book" files used by the autonomous loop. Each book has two templates:
 
-- `<NAME>.empty.md` — the EMPTY state. The tick's "has work" gate + `/auto-cycle` compare a live book
+- `<NAME>.empty.md` — the EMPTY state. The cli's "has-work" gate + the autonomous cli compare a live book
   against this (equal ⇒ empty). When clearing/resetting a book, overwrite it with **exactly** this file
   (`cp .claude/templates/<NAME>.empty.md <NAME>`).
 - `<NAME>.sample.md` — an example WITH DATA, showing the expected format when adding entries.

package/dist/project-sample/AI_TODO.md

@@ -6,9 +6,9 @@
 > **Tag** = optional catalog tag(s) (e.g. `UpdateSpecFromDB`) whose action runs from the server down to
 > the project when the task is approved (approval is committed on Save — ADR-0311).
 > **Approval** is NOT a table column — it lives in `.claude/.autonomous.approvals.json` (ADR-0152), set
-> from the web AI Todo grid; `/auto-cycle` reads that file, never the table.
+> from the web AI Todo grid; the autonomous cli reads that file, never the table.
 > **Depends** = the `TSK-…` ids that must be DONE (present in `AI_DONE.md`) first.
-> `/auto-cycle` only takes tasks that are approved AND have their dependencies met → moves them to
+> the autonomous cli only takes tasks that are approved AND have their dependencies met → moves them to
 > `AI_PROGRESS.md`; runs group by group, within a group High → Medium → Low.
 
 | ID | Priority | Tag | Depends | Group | Task description | Notes |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@4pm/cli",
-  "version": "1.18.0",
+  "version": "1.19.0",
   "private": false,
   "description": "4PM CLI — drives Claude/Codex CLIs on AI worker machines (Node + TypeScript)",
   "license": "LicenseRef-4PM-Source-Available",

package/dist/project-sample/.claude/.autonomous.settings.json

@@ -1,22 +0,0 @@
-{
-  "_about": "Autonomous workflow config (ADR-0152 + ADR-0319). autonomous-tick.sh READS this file EVERY cron tick, so edits take effect from the next tick. Keys starting with '_' are comments and are ignored by the script.",
-  "paused": true,
-  "_paused": "true = PAUSED: the tick still runs but skips immediately, without waking the daemon. A quick brake without removing the crontab entry.",
-  "cron_schedule": "*/5 * * * *",
-  "_cron_schedule": "Standard 5-field cron. When you change this, the tick rewrites the crontab line pointing at autonomous-tick.sh on the next run (only if the crontab already has the autonomous line — install it once manually first).",
-  "command": "auto-run",
-  "_command": "The cli subcommand each tick runs. `4pm auto-run` asks the running `4pm start` daemon to run one cycle through its live session (ADR-0319).",
-  "profile": "",
-  "_profile": "Optional profile name for `4pm auto-run --profile <name>`. Empty = the cli resolves the single linked profile (set this only on a worker serving multiple projects).",
-  "_quota_moved": "The session/weekly token gate + account selection moved OUT of this shell into the cli (ADR-0319) — they need the daemon's live usage snapshot. Configure quota-based profile failover in the cli's own config, not here.",
-  "quiet_hours": "",
-  "_quiet_hours": "Empty = run ALL DAY. Or 'HH:MM-HH:MM' (e.g. '00:00-06:00') to SKIP within that window; a window crossing midnight is valid (e.g. '22:00-06:00').",
-  "max_ticks_per_day": -1,
-  "_max_ticks_per_day": "-1 = NO limit. >0 = cap on the number of ticks that actually wake the daemon in one (local) day. The count is stored under ticks{day,count} in .claude/.autonomous.histories.json.",
-  "stop_on_consecutive_failures": 3,
-  "_stop_on_consecutive_failures": "After N consecutive FAILED runs (no daemon / dispatch error) -> set paused=true to stop safely. 0 = off. The count is stored under consecutive_fails in .claude/.autonomous.histories.json (reset on success).",
-  "log_retention_days": 14,
-  "_log_retention_days": "Logs are written per DAY: .claude/logs/autonomous-tick-YYYY-MM-DD.log. Delete log files older than N days. 0 = keep forever.",
-  "notify_webhook": "",
-  "_notify_webhook": "TBD — a webhook URL (Slack/Discord) to notify on finish/error. NOT wired yet (read but unused)."
-}

package/dist/project-sample/.claude/commands/auto-cycle.md

@@ -1,23 +0,0 @@
----
-description: (Retired — ADR-0319) The autonomous cycle now runs through the 4PM cli, not `claude -p /auto-cycle`.
----
-
-# /auto-cycle — retired (ADR-0319)
-
-The autonomous work cycle is **no longer** a `claude -p /auto-cycle` slash command. Under **ADR-0319**
-it runs through the 4PM cli instead:
-
-- The cron tick (`.claude/hooks/autonomous-tick.sh`) runs **`4pm auto-run`**, which asks the already
-  running **`4pm start`** daemon to run **one** cycle through its live WS session — so the cycle reuses
-  the cli's profile/quota failover (ADR-0182), token metering (ADR-0072), folder-scope guard (ADR-0181)
-  and AI-run timeout (ADR-0243).
-- The cycle **instructions** now live in the cli (`21-apps/31-cli/src/core/autonomous-cycle.ts` →
-  `buildAutonomousCyclePrompt`), not in this file. In short: sync the primary repo's current branch →
-  analyse **approved** `USER_TODO` requests into `AI_TODO` tasks (unclear ⇒ ask via `USER_QA`) → fold
-  **approved** `USER_QA` answers back → take ONE approved task → implement + test on a `task/TSK-…`
-  branch → open a **pull request** into the base branch (no direct merge) → update the books.
-
-Approval is the source of truth in `.claude/.autonomous.approvals.json` (ADR-0152), keyed per row id
-(`REQ-…` / `QA-…` / `TSK-…`), set from the web AI-content grids.
-
-This file is kept only as a pointer; it is not executed.