@event4u/agent-config 1.19.0 → 1.20.0

package/.agent-src/commands/agent-handoff.md

@@ -66,17 +66,21 @@ Show the handoff prompt in a fenced code block and say:
 - **Decisions are important** — prevents the new chat from re-asking settled questions.
 - **File list is optional** — only include if the new chat will need to edit specific files.
 
-## When to use this vs. `/chat-history-resume`
+## When to use this vs. `agents/.agent-chat-history`
 
 - `/agent-handoff` is **push-based**: you copy a short summary into the
   new chat. Works across tools (Augment → Claude Code), across machines,
   and without any persistent file.
-- [`/chat-history-resume`](chat-history-resume.md) is **pull-based**: the
-  new chat reads `.agent-chat-history` from disk (written by the
-  [`chat-history`](../rules/chat-history-ownership.md) rule). Works only on the
-  same machine and same repo, but captures more detail (every phase /
-  tool call / decision the prior session logged).
-
-Prefer `/agent-handoff` for planned context switches; prefer
-`/chat-history-resume` after a crash or after switching tools within the
-same workspace.
+- `agents/.agent-chat-history` is **pull-based** and **multi-session**: every
+  session writes its own entries tagged with a 16-char session
+  fingerprint derived from the platform `session_id` (schema v4, see
+  [`chat-history-platform-hooks`](../../agents/contexts/chat-history-platform-hooks.md)).
+  Works only on the same machine and same repo, but captures every
+  phase / decision any session logged. Inspect with `/chat-history show`;
+  pull prior-session context into the current chat verbatim with
+  `/chat-history import`; mine a prior session for project-improving
+  learnings with `/chat-history learn`.
+
+Prefer `/agent-handoff` for planned context switches across tools or
+machines; use `/chat-history import` after a crash or fresh-chat reopen
+on the same workspace to surface prior-session context verbatim.

package/.agent-src/commands/chat-history/import.md

@@ -0,0 +1,170 @@
+---
+name: chat-history:import
+cluster: chat-history
+sub: import
+description: Surface prior chat-history sessions as numbered options, let the user pick exactly one, then render its entries verbatim into the current chat — selective, user-driven cross-session import
+disable-model-invocation: true
+suggestion:
+  eligible: true
+  trigger_description: "import a past session into the current chat, pull a prior session into context, pick a session to read"
+  trigger_context: "user wants to selectively pull verbatim context from one earlier session into the current one"
+---
+<!-- cloud_safe: noop -->
+
+# /chat-history import
+
+Read-only, **user-driven** cross-session import. Surfaces prior
+sessions logged in `agents/.agent-chat-history` as numbered options, the
+user picks **one**, the agent reads that session's entries
+**verbatim** and renders them in the chat. Any subsequent
+extraction or summarisation happens in dialogue, user-directed —
+the agent does **not** auto-summarise, auto-import, or rewrite the
+user's context (Council Round 2 / R2-2 — verbatim is the honest v1
+contract).
+
+This is the opt-in counterpart to the read-path filter (Phase 3 of
+`road-to-chat-history-session-isolation`): default reads stay
+session-scoped; `import` is the explicit surface for crossing the
+session boundary verbatim. For project-improving learnings derived
+from a prior session, see [`/chat-history learn`](learn.md).
+
+## When NOT to use
+
+- Inspect the current session — that is the default of
+  `/chat-history show` plus `scripts/chat_history.py read`.
+- Generate a learning proposal from a prior session — use
+  [`/chat-history learn`](learn.md), which orchestrates
+  `learning-to-rule-or-skill` on the picked session.
+- Bulk-import all sessions — out of scope for v1. One session per
+  invocation; multi-pick is v2.
+- Search prior sessions by content — out of scope for v1; no fuzzy
+  search, no full-text grep. The user picks by `last_ts` and
+  `summary` from the listing.
+
+## Steps
+
+### 1. Check if enabled
+
+Read `chat_history.enabled` from `.agent-settings.yml`. If `false`
+or the section is missing, say so and stop:
+
+```
+> 📒 chat-history is disabled (chat_history.enabled = false).
+> Set it to true in .agent-settings.yml to start logging.
+```
+
+### 2. List sessions
+
+Run `scripts/chat_history.py sessions --json --limit 20 --summary`.
+The helper returns an array of
+`{id, count, first_ts, last_ts, preview, summary}` sorted by
+`last_ts` desc. The `summary` field is built **inside the helper**
+from at most 10 sampled entries per session (5 oldest + 5 newest) —
+token-cheap, no need to ever read the full body for the picker.
+Default excludes empty buckets — only sessions with at least one
+body entry are surfaced.
+
+If the array is empty, stop:
+
+```
+> 📒 No prior sessions found in agents/.agent-chat-history.
+```
+
+### 3. Surface as numbered options
+
+Render each session as a numbered option (per the `user-interaction`
+rule — Iron Law: numbered options for any picker). Lead with the
+helper's `summary` field — that is the rough arc the user picks by
+(`<first user msg> → <last user msg>` for normal sessions, or
+`(N entries — no user prompts; t-mix: …)` for tool-only sessions).
+The session `id` is noise to humans; keep it **internal** for step
+5's `read --session <id>` call and never render it in the listing.
+Format:
+
+```
+> Pick a session to import verbatim:
+>
+> 1. {summary}
+>    {YYYY-MM-DD HH:MM}  ·  {count} entries
+> 2. ...
+> ...
+> N. abort — do not read any session
+```
+
+Format the timestamp as `YYYY-MM-DD HH:MM` (drop seconds and
+timezone — the listing is for orientation, not forensics). Do
+**not** truncate or rewrite `summary` — the helper already shapes
+it. Always include an explicit abort option as the last numbered
+choice. Track option-number → `id` internally so step 5 can call
+`scripts/chat_history.py read --session <id>` with the right id.
+
+### 4. Wait for the pick
+
+**One question per turn** (per `ask-when-uncertain`). Do not chain
+the listing with anything else; do not auto-pick; do not surface a
+default. Wait for the user's response.
+
+If the user picks the abort option, stop without reading.
+
+### 5. Read the picked session verbatim
+
+Run `scripts/chat_history.py read --session <id>` with the picked
+`id`. The helper returns the entries as JSON.
+
+Render them **verbatim** in the chat — do not summarise, do not
+re-format, do not drop fields. One entry per line is acceptable;
+preserve `t`, `text`, `name`, `ts`, and any other fields the helper
+emits. Use a fenced block so timestamps and JSON survive markdown
+rendering:
+
+````
+> 📒 Session {id} — {count} entries
+
+```json
+{...entry 1...}
+{...entry 2...}
+...
+```
+````
+
+If the session is large (>50 entries), still render verbatim — but
+prepend a one-line note that the listing is long, so the user can
+scroll. Do not silently truncate.
+
+### 6. Hand back
+
+After rendering, **do not** auto-act on the content. Hand back to
+the user with a short prompt:
+
+```
+> Picked session is rendered above. What would you like to extract?
+```
+
+Any follow-up (extract decisions, copy specific entries into the
+current session, etc.) is user-directed in subsequent turns. The
+agent does not write to the current session's log on the user's
+behalf without an explicit instruction.
+
+## Gotchas
+
+- **Verbatim, not structured.** Council Round 2 (R2-2) resolved an
+  earlier contradiction in favour of verbatim. Do not "helpfully"
+  pre-summarise — the user reads the source, then directs the
+  extraction.
+- **One pick per invocation.** Multi-pick is v2. If the user wants
+  a second session, run `/chat-history import` again.
+- **Read-only.** This command never writes to `agents/.agent-chat-history`
+  and never rotates.
+- **`<legacy>` and `<unknown>` buckets** show up like any other
+  session id when they have body entries — the user can pick them
+  too. The helper aggregates body entries with no `s` field into
+  `<legacy>` and entries with `s == "<unknown>"` into `<unknown>`.
+
+## See also
+
+- [`/chat-history learn`](learn.md) — pick a prior session and turn it into a project-improving proposal via `learning-to-rule-or-skill`
+- [`/chat-history show`](show.md) — current-session inspector
+- [`chat-history-platform-hooks`](../../../agents/contexts/chat-history-platform-hooks.md) — read contract, isolation default, opt-in cross-session path
+- [`scripts/chat_history.py`](../../../scripts/chat_history.py) — `sessions` and `read --session` CLI surface
+- [`user-interaction`](../../rules/user-interaction.md) — numbered-options Iron Law
+- [`ask-when-uncertain`](../../rules/ask-when-uncertain.md) — one-question-per-turn Iron Law

package/.agent-src/commands/chat-history/learn.md

@@ -0,0 +1,178 @@
+---
+name: chat-history:learn
+cluster: chat-history
+sub: learn
+skills: [learning-to-rule-or-skill]
+description: Pick a prior chat-history session and mine it for project-improving learnings — runs learning-to-rule-or-skill on the picked session, drafts proposal(s) under agents/proposals/
+disable-model-invocation: true
+suggestion:
+  eligible: true
+  trigger_description: "extract a learning from a past session, mine chat-history for proposals, what did we learn last session, codify a pattern from a prior session"
+  trigger_context: "user wants to derive a rule/skill/guideline proposal from the content of one prior session"
+---
+<!-- cloud_safe: noop -->
+
+# /chat-history learn
+
+User-driven **learning extraction** from a prior session. Surfaces
+prior sessions logged in `agents/.agent-chat-history` as numbered options,
+the user picks **one**, the agent reads that session's entries and
+runs the [`learning-to-rule-or-skill`](../../skills/learning-to-rule-or-skill/SKILL.md)
+workflow on the content — surfacing repeated mistakes, successful
+patterns, or constraints worth codifying as a rule, skill, or
+guideline proposal.
+
+This is the **project-improvement** counterpart to
+[`/chat-history import`](import.md): `import` renders a session
+verbatim into the current chat for the user to act on; `learn`
+mines a session for proposals that improve the agent or the
+project itself.
+
+## When NOT to use
+
+- Pull a prior session into the current chat verbatim — use
+  [`/chat-history import`](import.md).
+- Capture a learning that originated **in the current** session —
+  invoke the [`learning-to-rule-or-skill`](../../skills/learning-to-rule-or-skill/SKILL.md)
+  skill directly. `learn` is for prior-session mining only.
+- Bulk-mine all sessions — out of scope for v1. One session per
+  invocation; multi-pick is v2.
+
+## Steps
+
+### 1. Check if enabled
+
+Read `chat_history.enabled` from `.agent-settings.yml`. If `false`
+or the section is missing, say so and stop:
+
+```
+> 📒 chat-history is disabled (chat_history.enabled = false).
+> Set it to true in .agent-settings.yml to start logging.
+```
+
+### 2. List sessions
+
+Run `scripts/chat_history.py sessions --json --limit 20 --summary`.
+The helper returns an array of
+`{id, count, first_ts, last_ts, preview, summary}` sorted by
+`last_ts` desc. The `summary` field is built inside the helper
+from ≤10 sampled entries per session (5 oldest + 5 newest) —
+token-cheap, no full-body read needed for the picker. Empty
+buckets are excluded by default.
+
+If the array is empty, stop:
+
+```
+> 📒 No prior sessions found in agents/.agent-chat-history.
+```
+
+### 3. Surface as numbered options
+
+Render each session as a numbered option (per the `user-interaction`
+rule — Iron Law: numbered options for any picker). Lead with the
+helper's `summary` field — the rough arc the user picks by
+(`<first user msg> → <last user msg>`, or
+`(N entries — no user prompts; t-mix: …)` for tool-only sessions).
+Keep the session `id` **internal** for step 5's `read --session <id>`
+call; never render it in the listing. Format:
+
+```
+> Pick a session to mine for learnings:
+>
+> 1. {summary}
+>    {YYYY-MM-DD HH:MM}  ·  {count} entries
+> 2. ...
+> ...
+> N. abort — do not extract any learning
+```
+
+Format the timestamp as `YYYY-MM-DD HH:MM` (drop seconds + timezone
+— orientation, not forensics). Do not truncate or rewrite `summary`
+— the helper already shapes it. Always include an explicit abort
+option last. Track option-number → `id` internally so step 5 calls
+`scripts/chat_history.py read --session <id>` with the right id.
+
+### 4. Wait for the pick
+
+**One question per turn** (per `ask-when-uncertain`). Do not chain
+the listing with anything else; do not auto-pick; do not surface a
+default. Wait for the user's response.
+
+If the user picks the abort option, stop without reading.
+
+### 5. Read the picked session
+
+Run `scripts/chat_history.py read --session <id>` with the picked
+`id`. Hold the entries in working memory — do **not** render them
+verbatim into the chat. The verbatim path is `import`'s job; here
+the entries are input to step 6.
+
+### 6. Run `learning-to-rule-or-skill`
+
+Apply the [`learning-to-rule-or-skill`](../../skills/learning-to-rule-or-skill/SKILL.md)
+procedure on the session content:
+
+1. **Scan** the entries for candidate learnings — repeated
+   mistakes, successful patterns, friction points, or constraints
+   stated by the user.
+2. **Pass each candidate through the Promotion Gate** (§ 0 of the
+   skill): repetition, impact, failure pattern, non-duplication,
+   scope fit, minimal. Drop candidates that fail any gate.
+3. **For each surviving candidate**, run § 4 (search protocol — all
+   four steps), then decide rule / skill / guideline / update / no
+   action per § 3 of the skill.
+4. **Draft a proposal** for every candidate that warrants one,
+   following § 8 of the skill (proposal template under
+   `agents/proposals/<id>.md`).
+
+If multiple candidates survive, draft them as **separate**
+proposals — do not merge unrelated learnings into one.
+
+### 7. Surface the result
+
+Hand back to the user with a structured summary per surviving
+candidate:
+
+```
+> 📒 Mined session {id} — {N} candidate(s) surfaced
+
+> 1. {learning title}
+>    Decision: {rule|skill|guideline|update|no action}
+>    Proposal: agents/proposals/{proposal_id}.md
+>    Gate: {pass|fail — reason}
+> 2. ...
+```
+
+If no candidate cleared the Promotion Gate, say so explicitly:
+
+```
+> 📒 Mined session {id} — no candidate cleared the Promotion Gate.
+```
+
+Do **not** open a PR, do **not** commit the proposals — proposal
+files land in `agents/proposals/` (gitignored or curated per
+project policy) for the user to review and route via
+`upstream-contribute` or merge into `agents/overrides/`.
+
+## Gotchas
+
+- **Promotion Gate is hard.** A grep miss is not proof of
+  non-duplication — § 4 of the skill mandates the four-step search
+  protocol. Do not skip it.
+- **One pick per invocation.** Multi-pick is v2. If the user wants
+  to mine a second session, run `/chat-history learn` again.
+- **Read-only on the log.** This command never writes to
+  `agents/.agent-chat-history`. It writes proposal drafts under
+  `agents/proposals/` only.
+- **No auto-promotion.** Drafted proposals stay in `proposals/`
+  until the user routes them. `learn` never invokes
+  `upstream-contribute` itself.
+
+## See also
+
+- [`/chat-history import`](import.md) — verbatim render of a prior session
+- [`learning-to-rule-or-skill`](../../skills/learning-to-rule-or-skill/SKILL.md) — the workflow this command orchestrates
+- [`upstream-contribute`](../../skills/upstream-contribute/SKILL.md) — promote a project-scoped proposal upstream
+- [`scripts/chat_history.py`](../../../scripts/chat_history.py) — `sessions` and `read --session` CLI surface
+- [`user-interaction`](../../rules/user-interaction.md) — numbered-options Iron Law
+- [`ask-when-uncertain`](../../rules/ask-when-uncertain.md) — one-question-per-turn Iron Law

package/.agent-src/commands/chat-history/show.md

@@ -11,14 +11,15 @@ suggestion:
 <!-- cloud_safe: noop -->
 
 # /chat-history show
-Inspect `.agent-chat-history` — the JSONL log maintained by the
-[`chat-history`](../rules/chat-history-ownership.md) rule for crash recovery.
+Inspect `agents/.agent-chat-history` — the JSONL log appended by the
+structural chat-history hooks (`ChatHistoryAppendHook`,
+`ChatHistoryHaltAppendHook`) for crash recovery.
 
 Shows:
 
 - Whether the file exists and whether logging is currently enabled
 - File size vs `max_size_kb`
-- Header metadata: fingerprint preview, created-at, `frequency`
+- Header metadata: schema version, `started`, `frequency`
 - Entry count and age of the oldest/newest entry
 - A peek at the last 3–5 entries so the user can see what was captured
 
@@ -26,9 +27,8 @@ Read-only — this command never writes to the file.
 
 ## When NOT to use
 
-- Load the log back into the conversation for context →
-  [`/chat-history resume`](chat-history-resume.md).
-- Wipe the file → [`/chat-history clear`](chat-history-clear.md).
+- Wipe the file → delete `agents/.agent-chat-history` manually; it is
+  git-ignored and will be recreated on the next hook fire.
 - Configure logging behavior → edit `.agent-settings.yml` directly
   (`chat_history.*`); see
   [`layered-settings`](../../docs/guidelines/agent-infra/layered-settings.md#section-aware-merge-rules).
@@ -66,10 +66,10 @@ Render a concise report:
 ```
 > 📒 chat-history status
 >
-> File:       .agent-chat-history  ({size_kb} KB / {max_size_kb} KB)
+> File:       agents/.agent-chat-history  ({size_kb} KB / {max_size_kb} KB)
 > Entries:    {entries}
-> Fingerprint:{short_fp}  (session started {created_at_relative})
-> Frequency:  {frequency}
+> Schema:     v{header.v}  (started {header.started})
+> Frequency:  {header.freq}
 > Overflow:   {on_overflow}
 >
 > Last entries:
@@ -84,15 +84,16 @@ data, see [`token-efficiency`](../rules/token-efficiency.md)).
 
 ### 5. Offer follow-ups (optional)
 
-If the file exists and the fingerprint does **not** match the current
-session, suggest `/chat-history resume` to adopt it.
-
 If the file is close to `max_size_kb` (> 80 %), mention it — the next
-append may trigger overflow handling.
+append may trigger overflow handling. To pull a specific prior
+session into the current chat verbatim, point the user at
+`/chat-history import`; to mine a prior session for project-improving
+learnings, `/chat-history learn`. The body filter on `s` is the v4
+isolation surface in both cases.
 
 ## Gotchas
 
-- `.agent-chat-history` is git-ignored. This command never commits.
+- `agents/.agent-chat-history` is git-ignored. This command never commits.
 - The helper is the only way to read the file — do not cat or parse
   the JSONL directly; entry shape is owned by `scripts/chat_history.py`.
 - If `exists: false` but the rule says logging is enabled, the file is
@@ -100,8 +101,6 @@ append may trigger overflow handling.
 
 ## See also
 
-- [`chat-history`](../rules/chat-history-ownership.md) — the rule that writes the file
-- [`/chat-history resume`](chat-history-resume.md) — adopt + load
-- [`/chat-history clear`](chat-history-clear.md) — wipe
+- [`chat-history-platform-hooks`](../../../agents/contexts/chat-history-platform-hooks.md) — the hook-only contract
 - [`agent-settings` template](../templates/agent-settings.md) — `chat_history.*` reference
-- [`scripts/chat_history.py`](../../../scripts/chat_history.py) — helper API
+- [`scripts/chat_history.py`](../../../scripts/chat_history.py) — helper API (`status`, `read`, `sessions`, `prune-sessions`)

package/.agent-src/commands/chat-history.md

@@ -1,51 +1,52 @@
 ---
 name: chat-history
-description: Chat-history orchestrator — routes to show, resume, clear, checkpoint
+description: Chat-history orchestrator — routes to show, import, learn
 cluster: chat-history
 disable-model-invocation: true
 suggestion:
   eligible: true
-  trigger_description: "show chat-history status, resume from log, clear the chat-history file, append a checkpoint entry"
-  trigger_context: "user wants to inspect, restore, wipe, or manually flush .agent-chat-history"
+  trigger_description: "show chat-history status, inspect agents/.agent-chat-history log, import a prior session into the current chat, mine a prior session for project-improving learnings"
+  trigger_context: "user wants to inspect the persistent agents/.agent-chat-history log, pull a prior session in verbatim, or extract learnings from a prior session"
 ---
 
 <!-- cloud_safe: noop -->
 
 # /chat-history
 
-Top-level orchestrator for the `/chat-history` family. Replaces 4
-standalone commands with a single entry point + sub-command dispatch.
+Top-level orchestrator for the `/chat-history` family. After the
+hook-only reduction (`road-to-chat-history-hook-only`) writes and
+overflow handling are driven entirely by platform hooks +
+`scripts/chat_history.py` internals; the surfaced sub-commands are
+read-only on the log itself. Sessions coexist in one log file —
+each entry self-tags via the `s` field — so there is no ownership
+layer to recover from.
 
 ## Sub-commands
 
 | Sub-command | Routes to | Purpose |
 |---|---|---|
-| `/chat-history show` | `commands/chat-history/show.md` | Inspect the log — size, entries, fingerprint, last entries |
-| `/chat-history resume` | `commands/chat-history/resume.md` | Adopt and load the persistent log into the current conversation |
-| `/chat-history clear` | `commands/chat-history/clear.md` | Wipe the log (with optional archival backup) |
-| `/chat-history checkpoint` | `commands/chat-history/checkpoint.md` | Append a phase-boundary entry on CHECKPOINT-class platforms |
-
-Sub-command names match the locked contract in
-[`docs/contracts/command-clusters.md`](../../docs/contracts/command-clusters.md).
+| `/chat-history show` | `commands/chat-history/show.md` | Inspect the log — size, entries, header, last entries |
+| `/chat-history import` | `commands/chat-history/import.md` | List prior sessions, pick one, render its entries verbatim — selective cross-session import |
+| `/chat-history learn` | `commands/chat-history/learn.md` | List prior sessions, pick one, mine it for project-improving learnings via `learning-to-rule-or-skill` |
 
 ## Dispatch
 
 1. Parse the user's argument: `/chat-history <sub-command> [args]`.
 2. Look up the sub-command in the table above.
-3. Load the body of the routed file and follow its `## Instructions`
-   (or `## Steps`) section verbatim with the remaining args.
-4. If the sub-command is unknown or missing, print the table above and
-   ask:
-
-   > 1. show — inspect status, size, last entries
-   > 2. resume — adopt the log into the conversation
-   > 3. clear — wipe the file
-   > 4. checkpoint — append a phase-boundary entry
+3. Load the body of the routed file and follow its `## Steps`
+   section verbatim with the remaining args.
+4. If the sub-command is unknown or missing (including the bare
+   `/chat-history` invocation), route to `show` — the safe,
+   current-session inspector default. `import` and `learn` are
+   opt-in only.
 
 ## Rules
 
-- **Do NOT commit, push, or open a PR** unless the sub-command
-  explicitly authorizes it.
+- **Do NOT commit, push, or open a PR** — `show` and `import` are
+  read-only; `learn` writes proposal drafts under
+  `agents/proposals/` only and does not commit them.
 - **Do NOT chain sub-commands.** One `/chat-history <sub>` per turn.
-- If the user invokes `/chat-history` with no argument, **show the
-  menu** — do not guess which sub-command they meant.
+- **`import` and `learn` cross the session boundary** — only run
+  them when the user explicitly asked for cross-session reading.
+  The default read path (filtered to current session) stays in
+  effect for every other tool.

package/.agent-src/commands/council/default.md

@@ -28,8 +28,7 @@ The user invoked `/council default` on exactly one input mode:
 - `files:<path>,<path>` — a comma-separated file list
 
 Optional invocation flag: `mode:api|manual` overrides the per-member
-and global mode for this call only (see Step 2.5). `mode:playwright`
-is reserved for Phase 2c — refuse politely if invoked.
+and global mode for this call only (see Step 2.5).
 
 Optional **rounds**: `rounds:N` (1-3) enables multi-round debate. Round
 1 sees the artefact alone. Round 2+ sees the artefact plus anonymised
@@ -71,7 +70,7 @@ Read `.agent-settings.yml` → `ai_council`:
   to env vars. Ever.
 
 Load the price table via `scripts.ai_council.pricing.load_prices()`
-(auto-bootstraps `.agent-prices.md` from defaults if missing). Run
+(auto-bootstraps `agents/.agent-prices.md` from defaults if missing). Run
 `pricing.is_stale(table)` and, if stale, surface the staleness gate
 from the `ai-council` skill (§ Stale price-table gate) before
 continuing.
@@ -81,15 +80,13 @@ continuing.
 For each enabled member, resolve its mode via
 `scripts.ai_council.modes.resolve_mode(name, invocation_mode,
 member_settings, global_mode)`. Precedence: invocation flag >
-per-member setting > global setting > default (`api`).
+per-member setting > global setting > default (`manual`).
 
 Construct each member from the resolved mode:
 
 - `api` → `AnthropicClient` / `OpenAIClient` (billable, cost-gated).
 - `manual` → `ManualClient` from `scripts.ai_council.clients`
   (`billable=False`, no API key, no SDK call).
-- `playwright` → reserved for Phase 2c. If a settings/invocation
-  resolves to it, refuse with a one-line note.
 
 ### 3. Cost confirmation — ALWAYS ASK for billable members
 
@@ -203,7 +200,7 @@ council can act on the project directly.
 - **Stale price table, refresher fails (offline)** → state the
   failure, re-offer "continue with stale table / cancel", do not
   proceed silently.
-- **`.agent-prices.md` corrupt (missing frontmatter or columns)** →
+- **`agents/.agent-prices.md` corrupt (missing frontmatter or columns)** →
   surface the parse error, suggest deleting the file to bootstrap
   fresh from defaults; never silently fall back.
 - **All members error (CLI exit 1)** → render the errors via

package/.agent-src/commands/create-pr.md

@@ -106,19 +106,39 @@ Once the user approves the content from step 2:
 
 ### 4. After creation
 
-- Show the PR URL.
-- If a Jira ticket was linked, ask:
-  ```
-  > Transition Jira ticket {TICKET-ID} to "In Review"?
-  >
-  > 1. Yes — update status
-  > 2. No — leave as-is
-  ```
+#### 4a. Strip attribution footers (mandatory)
+
+`github-api` may server-side-append attribution after a clean send.
+Per [`no-attribution-footers`](../rules/no-attribution-footers.md),
+re-check the body after creation **and after every body PATCH**:
+
+1. `GET /repos/{owner}/{repo}/pulls/{number}` — re-fetch body.
+2. Search (case-insensitive) for: `Generated with [Augment Code]`,
+   `🤖 Generated with`, `Pull Request opened by [Augment Code]`,
+   `Co-authored by Augment Code`, unsolicited `augmentcode.com` link.
+3. If any present, strip with surrounding `---` and trailing
+   whitespace, then `PATCH /pulls/{number}` with cleaned body.
+4. Re-fetch to verify. If the pattern reappears, repeat once; if
+   still present, surface to user and stop (no strip/PATCH loop).
+5. Note in the reply how many footers were removed (or "clean").
+
+#### 4b. Show the PR URL
+
+#### 4c. Jira transition
+
+If a Jira ticket was linked, ask:
+```
+> Transition Jira ticket {TICKET-ID} to "In Review"?
+>
+> 1. Yes — update status
+> 2. No — leave as-is
+```
 
 ### Rules
 
 - **Always use the PR template** from `.github/pull_request_template.md` — read it, fill its sections.
 - **Always show the PR content before creating it** — never create blindly.
 - **Push the branch first** if it hasn't been pushed (with user permission).
+- **Never add attribution footers** — see [`no-attribution-footers`](../rules/no-attribution-footers.md). Strip-pass in 4a defends against tool-injected footers.
 - Only create the PR — never merge it.
 - Only commit or push with explicit user permission.

package/.agent-src/commands/sync-gitignore.md

@@ -11,7 +11,7 @@ suggestion:
 
 Ensures the consumer project's `.gitignore` contains every entry the
 package expects to be ignored (symlinked `.augment/` subdirectories,
-`/agent-config` CLI wrapper, `.agent-settings*`, `.agent-chat-history*`).
+`/agent-config` CLI wrapper, `.agent-settings*`, `agents/.agent-chat-history*`).
 Canonical list lives in `config/gitignore-block.txt`; the same file
 drives the installer, so the two cannot drift.