@4pm/cli 1.14.0 → 1.18.0

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

@@ -1,22 +1,20 @@
 {
-  "_about": "Autonomous workflow config. 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.",
+  "_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 invoking Claude. A quick brake without removing the crontab entry.",
-  "max_session_pct": 80,
-  "max_weekly_pct": 90,
-  "_quota": "Only run when session_pct < max_session_pct AND weekly_pct < max_weekly_pct (read from the usage skill).",
+  "_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-cycle",
-  "_command": "The headless slash-command each tick invokes.",
-  "model": "",
-  "_model": "Empty = Claude Code's default model. Or set an id (e.g. 'claude-sonnet-4-6') to force a cheaper/faster model for the autonomous loop.",
+  "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 invoke Claude in one (local) day. The count is stored under ticks{day,count} in .claude/.autonomous.histories.json.",
+  "_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 command runs -> set paused=true to stop safely. 0 = off. The count is stored under consecutive_fails in .claude/.autonomous.histories.json (reset on success).",
+  "_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": "",

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

@@ -1,9 +1,9 @@
 # Set up a 10-minute cron for `autonomous-tick.sh`
 
 How to install the **autonomous cycle** on **WSL (Ubuntu)**: cron calls
-[`autonomous-tick.sh`](autonomous-tick.sh) every **10 minutes**; each run does one `claude -p /auto-cycle`
-cycle then exits. A file lock (`.claude/.autonomous.lock`) ensures **no two runs overlap** (a later tick
-that sees the lock skips).
+[`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).
 
 > All commands below run in a **WSL shell** (Ubuntu) unless noted as PowerShell/Windows. Call the project
 > root `$PROJECT` (e.g. `~/projects/<your-project>`).
@@ -18,9 +18,10 @@ cd "$PROJECT"
 Every line must print a path/version (not "not found"):
 ```bash
 command -v cron   || echo "missing cron"
-command -v claude || echo "missing claude (install natively in WSL)"
+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

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

@@ -1,34 +1,36 @@
 # 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, intended to run on **WSL** (an isolated environment where the AI can be given
-> full permissions).
+> 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`.
 
 ## The pieces
 | File | Role |
 |------|------|
-| `.claude/hooks/autonomous-tick.sh` | Cron tick (every ~10 min); a lock so **busy ⇒ skip, idle ⇒ run**; calls `claude -p /auto-cycle`. |
-| `.claude/commands/auto-cycle.md` | Defines **one cycle**: token gate → sync `${ai_dev_branch}$` → generate tasks → do one task → test → merge into `${ai_dev_branch}$`. |
-| `.claude/skills/check-usage/check_usage.py` | The `check-usage` skill: prints token % and writes `output/last-usage-check.json` (deleted + recreated each run) for the token gate to read. |
-| `.claude/.autonomous.approvals.json` | Approval source of truth (ADR-0152): `{ "<TSK-id>": {approved, by, at} }` — the web VERIFY tab writes it; `/auto-cycle` reads it. |
-| `USER_TODO.md` | The user writes requests here; the cycle reads then clears it. |
+| `.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 5 books. The "has work" gate + `/auto-cycle` **compare against `*.empty.md`** to tell empty/has-work and reset correctly (see `README.md` in that folder). |
+| `.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). |
 
 ## Lifecycle (1 tick)
 ```
-cron ~10min → autonomous-tick.sh
-  ├─ locked?  → log "skip", exit (wait for the next tick)
-  └─ idle → claude -p /auto-cycle
-       0. usage: session<80% & weekly<90%?  (no → stop)
-       1. checkout/fetch/pull the `${ai_dev_branch}$` branch
-       2. USER_TODO.md → generate tasks into AI_TODO.md (with IDs) → clear USER_TODO.md
-       3. pick one APPROVED task (approvals + dependencies) → AI_PROGRESS.md, remove from AI_TODO.md, commit
-       4. task/TSK-… branch → implement → commit → run the project's tests
-       5. back to `${ai_dev_branch}$` → merge task (resolve conflicts if any) → AI_DONE.md, remove from AI_PROGRESS.md, commit
-       6. report on the `conversation` branch (CONVERSATION.md, ≤50 entries) for later agents
-       7. recheck usage → stop
+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
 ```
 
 ## Install on WSL
@@ -40,13 +42,11 @@ crontab -e
 # watch:
 tail -f .claude/logs/autonomous-tick-$(date +%F).log
 ```
-Requirements: `claude` logged in (has `~/.claude/.credentials.json`), plus `git` and `python3`, and the
-project's test tooling (per `CLAUDE.md`).
+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.
 
 ## Note on permissions (important)
-- Claude Code only auto-loads `.claude/settings.json` and `.claude/settings.local.json`. To make a
-  full-permission profile take effect, one of:
-  1. The tick already passes `--permission-mode bypassPermissions --dangerously-skip-permissions` (in use).
-  2. Or copy the profile into `.claude/settings.local.json`.
-  3. Or point `CLAUDE_CONFIG_DIR` at the profile dir when running headless.
+- 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.

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

@@ -1,177 +1,23 @@
 ---
-description: Autonomous cycle — pull a request from USER_TODO, do ONE small approved task, test it, merge into ${ai_dev_branch}$. (The token gate is checked by autonomous-tick.sh BEFORE Claude is invoked.)
-allowed-tools: Bash(*), Read(*), Edit(*), Write(*), Glob(*), Grep(*)
+description: (Retired — ADR-0319) The autonomous cycle now runs through the 4PM cli, not `claude -p /auto-cycle`.
 ---
 
-# /auto-cycle — one autonomous work cycle
+# /auto-cycle — retired (ADR-0319)
 
-You are running **unattended** (headless, triggered by cron every ~10 min via
-`.claude/hooks/autonomous-tick.sh`). Do **exactly one full cycle** with the steps below, then **stop**.
-The integration branch is named **`${ai_dev_branch}$`** (the placeholder is resolved at runtime — see
-`AI_PLACEHOLDER.md`); a task branch is **merged straight into `${ai_dev_branch}$`** (no PR).
+The autonomous work cycle is **no longer** a `claude -p /auto-cycle` slash command. Under **ADR-0319**
+it runs through the 4PM cli instead:
 
-> Survival rule: **each cycle does exactly ONE small task** to avoid running out of tokens mid-way. If a
-> step fails, log it as a row in the **Incidents** table of `AI_DONE.md`, **clean the lock (Step 8)**, then stop — don't
-> push on.
->
-> **Lock (`.claude/.autonomous.lock`):** whether the cycle ends normally or on error, you MUST delete
-> the lock file before stopping so the next cron tick isn't blocked by a stale lock (Step 8) —
-> mandatory, even on an early error exit.
->
-> **Token gate:** the quota check (session/weekly) moved to the `autonomous-tick.sh` wrapper — it runs
-> first and only invokes Claude when quota is sufficient. So by the time `/auto-cycle` starts, the gate
-> has already passed; don't re-check at the top.
->
-> **Books & templates (MUST compare):** the 5 book files at the repo root — `USER_TODO.md`,
-> `AI_TODO.md`, `AI_PROGRESS.md`, `AI_DONE.md`, `USER_QA.md` — have canonical templates in
-> `.claude/templates/` (`<NAME>.empty.md` = EMPTY state, `<NAME>.sample.md` = example WITH DATA; see
-> `.claude/templates/README.md`). Rules:
-> - **Is a file empty / has work?** → compare against `<NAME>.empty.md` (empty ⇔ equal to the empty
->   template after trimming trailing whitespace + leading/trailing blank lines). Don't guess by skimming.
-> - **When clearing / resetting** a file → overwrite with the **exact** `<NAME>.empty.md`
->   (`cp .claude/templates/<NAME>.empty.md <NAME>`). The tick's "has work" gate relies on this match.
-> - **When adding data** → keep the header/blockquote, fill in per `<NAME>.sample.md`.
->
-> **Language:** write books/docs/code in the language the project's `CLAUDE.md` specifies (default
-> English). Don't switch languages on your own.
+- 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.
 
----
-
-## Step 1 — Sync the `${ai_dev_branch}$` branch
-1. If not on `${ai_dev_branch}$`:
-   - `git fetch origin`
-   - If it doesn't exist yet: `git checkout -b ${ai_dev_branch}$ origin/${ai_dev_branch}$` (if the remote
-     has it) or `git checkout -b ${ai_dev_branch}$ main` (create from main).
-   - Otherwise: `git checkout ${ai_dev_branch}$`.
-2. `git pull --ff-only origin ${ai_dev_branch}$` (skip if the remote has no such branch yet).
-
-## Step 2 — Intake user requests → generate tasks
-1. Read `USER_TODO.md` and **compare with `.claude/templates/USER_TODO.empty.md`**. If **equal** (only
-   the empty template remains) → **no** new request → skip task generation.
-2. **If anything is unclear / needs a user decision** (ambiguous, missing info, contradictory, or the
-   user said "ask if unclear, don't decide on your own"):
-   - **Do NOT guess** and generate tasks. Append a **row** to `USER_QA.md` per
-     `.claude/templates/USER_QA.sample.md` (columns `Date | Original request | Question / options | Answer`):
-     fill the date, the original request, and what's unclear + (if possible) options to choose from; leave
-     the **Answer** column blank for the user.
-   - **Clear `USER_TODO.md`** back to the empty template (Step 2.4) — do NOT generate tasks this cycle.
-     The user will read `USER_QA.md`, clarify, and re-post the request into `USER_TODO.md` for a later cycle.
-   - Append a row to the **Incidents** table in `AI_DONE.md` that this cycle stopped waiting for an answer, then go to
-     Step 8 (clean the lock) and **stop**.
-3. If the request is clear enough: split it into small tasks doable in ~1 cycle. Write them into
-   `AI_TODO.md` per `.claude/templates/AI_TODO.sample.md` (**7-column table:
-   `| ID | Priority | Approved | Depends | Group | Task description | Notes |`**), each with an
-   **ID `TSK-{groupid:0000}-{taskid:0000}`** (group = one request/batch, task = a sub-task).
-   - **`Priority` column**: judge it — `High` / `Medium` / `Low` (default `Medium`).
-   - **`Approved` column**: leave BLANK. This is a display-only mirror — the source of truth for approval
-     is `.claude/.autonomous.approvals.json` (the user ticks it in the web VERIFY tab — ADR-0152). Do NOT
-     fill it in yourself and do NOT read it to decide (see Step 3).
-   - **`Depends` column**: if a task must wait for another, list the `TSK-…` ids here (comma-separated);
-     leave empty otherwise. Step 3 skips a task whose dependencies aren't in `AI_DONE.md` yet.
-
-   **ID rules (MANDATORY):**
-   - **Each analysis of `USER_TODO.md` → one NEW `groupid`.** All sub-tasks split from that batch share
-     this `groupid`, differing only by `taskid`.
-   - **`groupid` must be UNIQUE and INCREASING** across all history (including groups already DONE and
-     cleared from `AI_TODO.md`). Since the books are cleared each cycle, **check git history** for the
-     largest `groupid` ever used, then take `max + 1`:
-     ```bash
-     MAXG=$( { git log -p -- AI_TODO.md AI_DONE.md AI_PROGRESS.md 2>/dev/null; \
-               cat AI_TODO.md AI_DONE.md AI_PROGRESS.md 2>/dev/null; } \
-             | grep -oE 'TSK-[0-9]{4}-[0-9]{4}' | sed -E 's/TSK-([0-9]{4}).*/\1/' \
-             | sort -rn | head -1 ); MAXG=${MAXG:-0}
-     NEWG=$(printf '%04d' $((10#$MAXG + 1)))
-     ```
-   - **`taskid` starts at `0001` and increases WITHIN the group**: `TSK-{NEWG}-0001`, `TSK-{NEWG}-0002`, …
-4. **Clear `USER_TODO.md`** by overwriting with the exact empty template
-   (`cp .claude/templates/USER_TODO.empty.md USER_TODO.md`) — so old tasks aren't recreated next cycle AND
-   the tick's "has work" gate correctly sees it as empty.
-
-## Step 3 — Pick ONE APPROVED task (with satisfied dependencies) and start it
-> **VERIFY gate (MANDATORY):** the source of truth for approval is `.claude/.autonomous.approvals.json`
-> (ADR-0152), NOT the `Approved` column in `AI_TODO.md`. A task is **approved** when approvals has
-> `"<TSK-id>": { "approved": true, … }`. A task not in approvals (or `approved:false`) = NOT permitted →
-> **skip it, leave it queued**.
-
-1. Read `.claude/.autonomous.approvals.json` (JSON `{ "<TSK-id>": {approved, by, at}, … }`; missing file
-   ⇒ nothing approved) and `AI_TODO.md`. **Filter tasks meeting BOTH**:
-   - **Approved**: `approved === true` in approvals.
-   - **Dependencies met**: every `TSK-…` in the `Depends` column is already in `AI_DONE.md` (done). If a
-     dependency isn't done yet → **skip** (wait for a later cycle), even if approved.
-   Pick the next task: **run group by group** (smallest group with an eligible task first), **within a
-   group prefer `Priority` High → Medium → Low**, then line order.
-   - **If NO eligible task** (empty, or all waiting for approval / dependencies — including tasks just
-     generated in Step 2): **take no task**. Append a row to the **Incidents** table in `AI_DONE.md`
-     (e.g. "this cycle only generated tasks / waiting for VERIFY approval / waiting for dependencies"),
-     then go to Step 8 (clean the lock) and **stop**.
-2. Move that task into `AI_PROGRESS.md` (with a start timestamp, per
-   `.claude/templates/AI_PROGRESS.sample.md`), **remove it from `AI_TODO.md`**. If `AI_TODO.md` is now
-   empty → `cp .claude/templates/AI_TODO.empty.md AI_TODO.md`.
-3. Commit on `${ai_dev_branch}$`: `git add -A && git commit -m "chore(auto): start TSK-xxxx-xxxx"`.
-
-## Step 4 — Implement the task on its own branch
-1. Create the branch: `git checkout -b task/TSK-xxxx-xxxx`.
-2. Implement the task **following the project's architecture + the conventions in `CLAUDE.md`**. Add or
-   update tests as appropriate for the change.
-3. **Test** by running the project's test command (see `CLAUDE.md` / the project's scripts — e.g.
-   `scripts/test.*`, `npm test`, `pnpm test`, `pytest`, …). If the project defines an integration-test /
-   evidence harness, use it and keep the produced report/evidence so it can be reviewed later.
-4. **Wait for the tests to finish** and check the result before continuing.
-5. Commit (include any produced report/evidence so the integration branch carries it):
-   `git add -A && git commit -m "feat(TSK-xxxx-xxxx): <short description>"`.
-
-## Step 5 — Merge into `${ai_dev_branch}$`, update the books
-1. `git checkout ${ai_dev_branch}$`
-2. `git merge --no-ff task/TSK-xxxx-xxxx`
-   - **On CONFLICT** (parallel agents may have moved the integration branch — MEMO #40): `git status`
-     shows `UU` files. **Resolve them yourself**: edit each conflicted file into a correct merged result
-     (remove every `<<<<<<< ======= >>>>>>>` marker), `git add <file>`, then `git commit --no-edit` to
-     finish the merge. If a conflict is too complex to be sure → `git merge --abort`, write a question
-     into `USER_QA.md`, go to Step 8 and stop (don't guess).
-3. Record the task by **appending a row to the Done table** in `AI_DONE.md` (Timestamp, ID, Task description, Files, Notes — per `.claude/templates/AI_DONE.sample.md`; keep the table header intact).
-   **Remove it from `AI_PROGRESS.md`**: if nothing is in progress after removal, reset with
-   `cp .claude/templates/AI_PROGRESS.empty.md AI_PROGRESS.md`. Likewise, if `AI_TODO.md` is now empty →
-   `cp .claude/templates/AI_TODO.empty.md AI_TODO.md`.
-4. Commit: `git add -A && git commit -m "chore(auto): finish TSK-xxxx-xxxx, merge into ${ai_dev_branch}$"`.
-5. (Optional) `git push origin ${ai_dev_branch}$`.
-
-## Step 6 — Recheck the token budget
-1. Re-run the **check-usage** skill: `python .claude/skills/check-usage/check_usage.py`, then **wait 3s**
-   (`sleep 3`) for the result file to be written.
-2. Print a summary: task done, tokens remaining.
-
-## Step 7 — Commit & push `${ai_dev_branch}$`
-1. `git checkout ${ai_dev_branch}$`
-2. `git add -A && git commit -m "chore(auto): update books after the autonomous cycle"` (skip if no change).
-3. `git push origin ${ai_dev_branch}$`.
-
-## Step 7.5 — Report on the `conversation` branch (share context with later agents — MEMO #40)
-> Multiple Claude instances take different tasks in parallel; a later agent needs to know what an earlier
-> one did. Use a dedicated branch named **`conversation`** holding **only** the file `CONVERSATION.md`
-> (no source or docs), keeping **at most the 50 most recent reports** (trim older ones when over).
-
-1. Save the context (task ID + summary + list of files changed this cycle).
-2. `git stash -u` if there are uncommitted changes (usually none — the books were committed in Step 7).
-3. Switch to the conversation branch (create it orphan if missing):
-   - `git fetch origin` → `git checkout conversation` (exists) or
-     `git checkout --orphan conversation && git rm -rf . 2>/dev/null` (create fresh, clean).
-   - `git pull --ff-only origin conversation` (skip if the remote has none).
-4. Append an entry to the **end** of `CONVERSATION.md`:
-   ```
-   ## <yyyy-MM-dd HH:mm> · TSK-xxxx-xxxx
-   - Did: <short summary>
-   - Files: <paths, comma-separated>
-   - Merged into: ${ai_dev_branch}$ (<conflict / no conflict>)
-   ```
-   If the number of `##` entries exceeds **50** → drop the oldest ones down to 50.
-5. `git add CONVERSATION.md && git commit -m "chore(conversation): TSK-xxxx-xxxx" && git push origin conversation`.
-6. Return to the integration branch: `git checkout ${ai_dev_branch}$` (and `git stash pop` if you stashed in 2).
+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.
 
-## Step 8 — Clean the lock (ALWAYS run, even on error/early exit)
-> This is the **final action of every cycle** — run it whether the cycle succeeded, hit an error, or was
-> blocked at the token gate. Goal: never let a stale lock block the next cron tick.
-1. Delete the lock file: `rm -f .claude/.autonomous.lock` (run in the project root).
-   - The lock IS the file `.autonomous.lock`: `autonomous-tick.sh` creates it at start and treats "the
-     file exists" = a run is in progress. Deleting it here releases the lock for the next tick.
-   - This is `/auto-cycle`'s responsibility; the wrapper only has a safety-net trap in case the cycle dies.
-2. **STOP** (the next cron tick will trigger the next cycle).
+This file is kept only as a pointer; it is not executed.