@4pm/cli 1.17.0 → 1.19.0

package/dist/project-sample/.claude/templates/project.secrets.sample.json

@@ -1,5 +1,4 @@
 {
-  "ai_dev_branch": "main",
   "api_base_url": "https://api.example.com",
   "api_key": "sk-demo-0000…zzzz"
 }

package/dist/project-sample/AI_PLACEHOLDER.md

@@ -7,13 +7,13 @@
 > file holds only keys + explanations, so it is **safe to commit** and the AI can read it for context.
 >
 > **Why two files:**
-> - `AI_PLACEHOLDER.md` (this file) — keys + explanations. Safe to commit; not gitignored/denied.
-> - `project.secrets.json` — key → real value. **Gitignored** and **denied** in `.claude/settings.json`,
->   so secret values never reach git and the AI can't read them directly. Manage values from the web
->   (Placeholder tab) — they are write-only (never shown back).
+> - `AI_PLACEHOLDER.md` (this file) — keys + explanations. Safe to commit; not gitignored.
+> - `project.secrets.json` — key → real value. **Gitignored** (never committed / pushed), so secret
+>   values stay on the worker. The AI **can** read this file to use the values while running/testing a
+>   task — so enter **test values only**; do **not** put high-sensitivity secrets here. Manage values
+>   from the web (Placeholder tab) — they are write-only (never shown back).
 
 | Key | Explanation |
 |-----|-------------|
-| ai_dev_branch | The shared dev branch the AI merges tasks into before the main branch. |
 | api_base_url | Base URL of the internal API the AI calls during integration tests. |
 | api_key | Key for the internal API (real value in project.secrets.json, NOT committed). |

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/dist/project-sample/USER_QA.md

@@ -1,9 +1,16 @@
 # USER_QA — Questions & answers
 
-> When a request is unclear, the AI adds a **row** here (date, the original request, what's unclear +
-> options) instead of guessing. Fill the **Answer** column, then re-post the clarified request into
-> `USER_TODO.md` — per `.claude/templates/USER_QA.sample.md`.
+> When a request is unclear, the AI adds a **row** here (instead of guessing) with an
+> **ID `QA-{groupid:0000}-{qaid:0000}`**: the original request and what's unclear + options, leaving the
+> `Answer` blank. You fill the `Answer`; the autonomous cycle folds it back into a re-analysis **only after
+> the row is approved**. Approval + authorship (who answered / who approved, with dates) live in JSON
+> sidecars, not in this table (ADR-0320): `.claude/.autonomous.approvals.json` +
+> `.claude/.autonomous.authors.json` — the web USER_QA grid shows them and enforces four-eyes (the person
+> who answered can't approve their own answer, except ADMIN). See `.claude/templates/USER_QA.sample.md`.
+>
+> **Columns (content only):** `ID` · `Group` · `Depends` (comma-separated `QA-…`) · `Original request` ·
+> `Question / options` · `Answer`.
 
-| Date | Original request | Question / options | Answer |
-|------|------------------|--------------------|--------|
-| | | | |
+| ID | Group | Depends | Original request | Question / options | Answer |
+|----|-------|---------|------------------|--------------------|--------|
+| | | | | | |

package/dist/project-sample/USER_TODO.md

@@ -1,9 +1,16 @@
 # USER_TODO — User requests
 
-> Write what you want the AI to do (in the project's language — default English), **one request per row**
-> in the table below. The autonomous cycle reads this, generates tasks into `AI_TODO.md`, then clears this
-> file back to the empty template — per `.claude/templates/USER_TODO.sample.md`.
+> Write what you want the AI to do (in the project's language — default English), **one request per row**.
+> Each row has an **ID `REQ-{groupid:0000}-{reqid:0000}`** (group = one batch of related requests) used to
+> approve it and to reference it from `Depends`. The autonomous cycle analyses a request into tasks in
+> `AI_TODO.md` **only after the row is approved**. Approval + authorship are kept in JSON sidecars, not in
+> this table (ADR-0320): `.claude/.autonomous.approvals.json` (who/when approved) and
+> `.claude/.autonomous.authors.json` (who/when wrote the row) — the web USER_TODO grid shows them and
+> enforces four-eyes (the writer can't approve their own row, except ADMIN). See
+> `.claude/templates/USER_TODO.sample.md`.
+>
+> **Columns (content only):** `ID` · `Group` · `Depends` (comma-separated `REQ-…`) · `Request`.
 
-| # | Request | Notes |
-|---|---------|-------|
-| | | |
+| ID | Group | Depends | Request |
+|----|-------|---------|---------|
+| | | | |

package/dist/project-sample/project.secrets.json.sample

@@ -1,5 +1,4 @@
 {
-  "ai_dev_branch": "main",
   "api_base_url": "https://api.example.com",
   "api_key": "sk-demo-0000…zzzz"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@4pm/cli",
-  "version": "1.17.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,24 +0,0 @@
-{
-  "_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.",
-  "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).",
-  "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.",
-  "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.",
-  "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).",
-  "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,177 +0,0 @@
----
-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(*)
----
-
-# /auto-cycle — one autonomous work cycle
-
-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).
-
-> 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.
-
----
-
-## 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).
-
-## 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).

package/dist/project-sample/.claude/hooks/autonomous-history.py

@@ -1,193 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-Manage .claude/.autonomous.histories.json — the SINGLE file combining the autonomous workflow's state + history.
-
-Structure:
-{
-  "cron_applied": "*/10 * * * *",     # the cron schedule applied last time (to detect a schedule change)
-  "consecutive_fails": 0,              # number of CONSECUTIVE failed command runs (reset on success)
-  "ticks": {"day": "YYYY-MM-DD", "count": N},  # count of ticks that actually invoked Claude today
-  "records": [ {...}, ... ]            # cron run history, NEWEST LAST, at most 50 records
-}
-
-Each record:
-{
-  "ts": "YYYY-MM-DD HH:MM:SS",
-  "status": "success" | "failure" | "skip",
-  "rc": <int|null>,                    # the command's exit code (null if it didn't run)
-  "gate": "<token-gate string>",
-  "note": "<short note>",
-  "command": "/auto-cycle",
-  "tick": "YYYY-MM-DD #N",             # day + tick number within the day
-  "config": { cron_schedule, model, max_session_pct, max_weekly_pct, quiet_hours,
-              max_ticks_per_day, stop_on_consecutive_failures, paused }
-}
-
-Usage (the file path is the first arg):
-  history.py <file> migrate <cron-applied> <fails> <ticks>   # one-time load from 3 old files (paths)
-  history.py <file> get-cron
-  history.py <file> set-cron <schedule>
-  history.py <file> get-fails
-  history.py <file> set-fails <n>
-  history.py <file> get-ticks <today>         # print the count for 'today' (0 if a different day/missing)
-  history.py <file> set-ticks <day> <count>
-  history.py <file> record <ts> <status> <rc> <gate> <note>   # config is read from the CFG_* env vars
-
-Philosophy: NEVER break on a missing/corrupt file — always initialize the default skeleton.
-"""
-import json
-import os
-import sys
-
-MAX_RECORDS = 50
-
-SKELETON = {
-    "cron_applied": "",
-    "consecutive_fails": 0,
-    "ticks": {"day": "", "count": 0},
-    "records": [],
-}
-
-
-def load(path):
-    try:
-        with open(path, encoding="utf-8") as f:
-            d = json.load(f)
-        if not isinstance(d, dict):
-            raise ValueError("not an object")
-    except Exception:
-        d = {}
-    out = dict(SKELETON)
-    out.update({k: d[k] for k in SKELETON if k in d})
-    if not isinstance(out.get("ticks"), dict):
-        out["ticks"] = dict(SKELETON["ticks"])
-    if not isinstance(out.get("records"), list):
-        out["records"] = []
-    return out
-
-
-def save(path, d):
-    tmp = path + ".tmp"
-    with open(tmp, "w", encoding="utf-8") as f:
-        json.dump(d, f, ensure_ascii=False, indent=2)
-        f.write("\n")
-    os.replace(tmp, path)
-
-
-def cfg_from_env():
-    def g(k, default=""):
-        return os.environ.get(k, default)
-    return {
-        "cron_schedule": g("CFG_CRON_SCHEDULE"),
-        "model": g("CFG_MODEL"),
-        "max_session_pct": g("CFG_MAX_SESSION_PCT"),
-        "max_weekly_pct": g("CFG_MAX_WEEKLY_PCT"),
-        "quiet_hours": g("CFG_QUIET_HOURS"),
-        "max_ticks_per_day": g("CFG_MAX_TICKS_PER_DAY"),
-        "stop_on_consecutive_failures": g("CFG_STOP_ON_CONSEC_FAILURES"),
-        "paused": g("CFG_PAUSED"),
-    }
-
-
-def main():
-    if len(sys.argv) < 3:
-        sys.stderr.write("missing args: <file> <op> [...]\n")
-        return 2
-    path = sys.argv[1]
-    op = sys.argv[2]
-    args = sys.argv[3:]
-    d = load(path)
-
-    if op == "get-cron":
-        sys.stdout.write(str(d.get("cron_applied", "")))
-        return 0
-
-    if op == "set-cron":
-        d["cron_applied"] = args[0] if args else ""
-        save(path, d)
-        return 0
-
-    if op == "get-fails":
-        sys.stdout.write(str(int(d.get("consecutive_fails", 0) or 0)))
-        return 0
-
-    if op == "set-fails":
-        d["consecutive_fails"] = int(args[0]) if args else 0
-        save(path, d)
-        return 0
-
-    if op == "get-ticks":
-        today = args[0] if args else ""
-        t = d.get("ticks", {})
-        sys.stdout.write(str(int(t.get("count", 0) or 0) if t.get("day") == today else 0))
-        return 0
-
-    if op == "set-ticks":
-        day = args[0] if len(args) > 0 else ""
-        count = int(args[1]) if len(args) > 1 else 0
-        d["ticks"] = {"day": day, "count": count}
-        save(path, d)
-        return 0
-
-    if op == "record":
-        ts = args[0] if len(args) > 0 else ""
-        status = args[1] if len(args) > 1 else ""
-        rc_raw = args[2] if len(args) > 2 else ""
-        gate = args[3] if len(args) > 3 else ""
-        note = args[4] if len(args) > 4 else ""
-        try:
-            rc = int(rc_raw)
-        except (ValueError, TypeError):
-            rc = None
-        t = d.get("ticks", {})
-        rec = {
-            "ts": ts,
-            "status": status,
-            "rc": rc,
-            "gate": gate,
-            "note": note,
-            "command": os.environ.get("CFG_COMMAND", ""),
-            "tick": "%s #%s" % (t.get("day", ""), t.get("count", 0)),
-            "config": cfg_from_env(),
-        }
-        d["records"].append(rec)
-        if len(d["records"]) > MAX_RECORDS:
-            d["records"] = d["records"][-MAX_RECORDS:]
-        save(path, d)
-        return 0
-
-    if op == "migrate":
-        # Only load when histories.json has no real data yet (don't overwrite live data).
-        cron_p = args[0] if len(args) > 0 else ""
-        fails_p = args[1] if len(args) > 1 else ""
-        ticks_p = args[2] if len(args) > 2 else ""
-
-        def read_txt(p):
-            try:
-                with open(p, encoding="utf-8") as f:
-                    return f.read().strip()
-            except Exception:
-                return ""
-
-        if cron_p and not d.get("cron_applied"):
-            v = read_txt(cron_p)
-            if v:
-                d["cron_applied"] = v
-        if fails_p and not d.get("consecutive_fails"):
-            v = read_txt(fails_p)
-            if v.isdigit():
-                d["consecutive_fails"] = int(v)
-        if ticks_p and not d.get("ticks", {}).get("day"):
-            parts = read_txt(ticks_p).split()
-            if len(parts) == 2 and parts[1].isdigit():
-                d["ticks"] = {"day": parts[0], "count": int(parts[1])}
-        save(path, d)
-        return 0
-
-    sys.stderr.write("invalid op: %s\n" % op)
-    return 2
-
-
-if __name__ == "__main__":
-    sys.exit(main())

package/dist/project-sample/.claude/skills/check-usage/SKILL.md

@@ -1,40 +0,0 @@
----
-name: check-usage
-description: Show Claude Code plan usage limits — current session % and reset time, weekly % and reset time (same data as the built-in /usage screen). Use when the user asks "how much usage left", "khi nao reset", "check usage/quota/limit", or invokes /check-usage.
----
-
-# check-usage — Claude Code plan usage limits
-
-Fetches the same data the built-in `/usage` screen shows (session + weekly utilization and
-reset times), by calling the Anthropic OAuth usage endpoint with the local credentials.
-
-## How to run
-
-Run the bundled script with the Bash tool. It prints a compact bullet list to the console;
-relay that output to the user.
-
-```bash
-python .claude/skills/check-usage/check_usage.py
-```
-
-On Windows if `python` is missing, try `py .claude/skills/check-usage/check_usage.py`.
-
-Add `--json` to dump the raw API response instead of the formatted view:
-
-```bash
-python .claude/skills/check-usage/check_usage.py --json
-```
-
-## Output file
-Every run (the formatted view, not `--json`) rewrites `./output/last-usage-check.json` next to
-the script: it deletes the previous file then creates a fresh one with this run's result. The
-record has machine-readable fields the autonomous workflow reads back:
-`session_pct`, `weekly_pct`, `session_resets_at`, `weekly_resets_at`, `checked_at`, `plan`,
-plus the human `summary` and the full `raw` API payload.
-
-## Notes
-- Reads the OAuth access token from `~/.claude/.credentials.json` (Claude Code keeps it refreshed).
-- If the call returns HTTP 401, the token expired — tell the user to run the real `/usage` once
-  inside Claude Code (or re-login) to refresh credentials, then retry.
-- Reset times are printed in the machine's local timezone with a "con Xh Ym" countdown.
-- Do not print the access token.