@event4u/agent-config 7.5.0 → 8.1.0

package/dist/agent-src/commands/roadmap/process-phase.md

@@ -30,12 +30,20 @@ Sibling of [`/roadmap:process-step`](process-step.md) and
 Run the canonical loop in
 [`contexts/execution/roadmap-process-loop`](../../contexts/execution/roadmap-process-loop.md)
 with the **scope delta below**. The loop file owns roadmap discovery,
-pre-run summary, cadence resolution, commit-step pre-scan, the step
-loop with AI-council branching, halt conditions, and the archival
-check.
+pre-run summary, cadence resolution, the § 3 pre-scan (execution
+contract when frontmatter declares `execution.mode: autonomous |
+phase-checkpoints` — see
+[`roadmap-execution-contract`](../../contexts/execution/roadmap-execution-contract.md) —
+otherwise the legacy commit-step ask), the step loop with AI-council
+branching, halt conditions, and the archival check.
 
 ## Scope delta
 
+- **Execution mode:** read `execution.mode` from frontmatter; under
+  `autonomous` / `phase-checkpoints` the run-start contract governs
+  the run's grants. `phase-checkpoints` behaves like `autonomous`
+  inside this single phase (its checkpoint prompt fires at the
+  boundary, where this wrapper stops anyway).
 - **Working set:** all open steps in the **first phase with
   `count_open > 0`**. If every phase is closed → report "Roadmap
   already complete." and run the archival check from
@@ -52,11 +60,15 @@ check.
 - **Autonomous within the phase, never beyond.** The user picks
   `process-step` for one step or `process-full` for the whole roadmap.
 - **No commit, push, branch, PR, tag, or bulk-destructive op** without
-  explicit permission this turn — see
-  [`commit-policy`](../../rules/commit-policy.md) and
+  explicit permission this turn **or an accepted run-start execution
+  contract** (whose grants cover exactly: the run's feature branch,
+  chunked commits on it, push to that branch only, PR-open — never
+  merge; see
+  [`roadmap-execution-contract § 3`](../../contexts/execution/roadmap-execution-contract.md)) —
+  see [`commit-policy`](../../rules/commit-policy.md) and
   [`scope-control § git-ops`](../../rules/scope-control.md#git-operations--permission-gated).
   Roadmap-listed commit steps follow the single-upfront-ask flow in
-  [`roadmap-process-loop § 3`](../../contexts/execution/roadmap-process-loop.md#3-commit-step-pre-scan--one-upfront-ask).
+  [`roadmap-process-loop § 3`](../../contexts/execution/roadmap-process-loop.md#3-pre-scan--execution-contract-or-commit-step-ask).
 - **Every checkbox edit syncs the dashboard in the same response** per
   [`roadmap-progress-sync`](../../rules/roadmap-progress-sync.md).
 - **AI-council consultations run silently when council is on.** No

package/dist/agent-src/commands/roadmap/process-step.md

@@ -32,6 +32,10 @@ with the **scope delta below**.
 
 ## Scope delta
 
+- **Execution mode:** `execution.mode` frontmatter is **ignored by this
+  wrapper** — a single-step run derives no execution contract
+  ([`roadmap-execution-contract`](../../contexts/execution/roadmap-execution-contract.md)
+  stays unloaded); existing per-step behavior applies unchanged.
 - **Working set:** the **first checkbox `[ ]` in document order**
   inside the first phase with `count_open > 0`. If every step is
   closed → report "Roadmap already complete." and run the archival

package/dist/agent-src/commands/roadmap.md

@@ -74,7 +74,7 @@ each only binds a scope delta.
 - **Do NOT commit, push, or open a PR** unless the sub-command
   explicitly authorizes it. Roadmap-listed commit steps follow the
   single-upfront-ask flow in
-  [`roadmap-process-loop § 3`](../contexts/execution/roadmap-process-loop.md#3-commit-step-pre-scan--one-upfront-ask).
+  [`roadmap-process-loop § 3`](../contexts/execution/roadmap-process-loop.md#3-pre-scan--execution-contract-or-commit-step-ask).
 - **Do NOT chain sub-commands.** One `/roadmap <sub>` per turn.
 - If the user invokes `/roadmap` with no argument, **show the menu** —
   do not guess which sub-command they meant.

package/dist/agent-src/commands/security-audit-config.md

@@ -30,7 +30,7 @@ Agentic Applications. Consumer-facing counterpart to the suite's own
 ### 1. Run the static audit
 
 ```bash
-python3 src/scripts/security_audit_config.py --root <repo> --json
+./scripts-run src/scripts/security_audit_config --root <repo> --json
 ```
 
 (omit `--root` to audit the current repo). Reuses the Phase-1 detection library

package/dist/agent-src/commands/sync-agent-settings.md

@@ -49,7 +49,7 @@ Use when:
 - To create `.agent-project-settings.yml` (team file) → that is a
   separate concern; this command only touches the developer file.
 - To migrate a legacy flat `.agent-settings` → run
-  `python3 scripts/install.py` first; the installer owns migrations.
+  `npx @event4u/agent-config install` first; the installer owns migrations.
 
 ## Steps
 

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

@@ -74,7 +74,7 @@ stop — there is nothing to fix:
 Run:
 
 ```bash
-python3 <script> --cleanup-legacy --dry-run
+./scripts-run <script> --cleanup-legacy --dry-run
 ```
 
 Capture stdout (unified diff) and stderr (summary line listing the
@@ -102,7 +102,7 @@ legacy entries that would be removed). Three outcomes:
 
 - `1` (Apply) → re-run **without** `--dry-run`:
   ```bash
-  python3 <script> --cleanup-legacy
+  ./scripts-run <script> --cleanup-legacy
   ```
   Confirm with the script's own summary lines (removed-legacy count and
   added-entries count both surface there).
@@ -139,12 +139,48 @@ from this command. One line of guidance is enough:
 - **Do NOT push, commit, or modify other files** — this command writes
   to `.gitignore` only.
 
+### 5. Ignored-but-tracked detection pass
+
+After the legacy-cleanup sync, run the tracked-but-ignored check:
+
+```bash
+npx tsx node_modules/@event4u/agent-config/src/scripts/check_tracked_but_ignored.ts
+```
+
+Files reported →
+
+```
+> ⚠️  Tracked but now ignored — will appear in every `git status` until untracked.
+> Fix (files stay on disk):
+>
+>   git rm --cached \
+>     <file1> \
+>     <file2>
+>
+> Then commit. One-time cleanup.
+```
+
+NEVER run `git rm --cached` automatically — git-ops are user-owned.
+
+### 6. Agent artefacts not covered
+
+Manifest-vs-block coverage check (`agents-paths.yml` is the reference):
+
+```bash
+npx tsx node_modules/@event4u/agent-config/src/scripts/check_gitignore_freshness.ts
+```
+
+Fails → offer block re-sync (option 1 sync / 2 skip).
+
 ## See also
 
 - [`/sync-gitignore`](../sync-gitignore.md) — append-only sync of the
   managed block (no legacy cleanup)
-- [`scripts/sync_gitignore.py`](../../../scripts/sync_gitignore.py) —
+- [`scripts/sync_gitignore.ts`](../../../src/scripts/sync_gitignore.ts) —
   the helper (`--cleanup-legacy` flag)
-- [`scripts/install.sh`](../../../scripts/install.sh) —
-  `migrate_legacy_root_infra` (moves the **files**, complement to this
-  command which fixes the **ignore rules**)
+- [`scripts/check_tracked_but_ignored.ts`](../../../src/scripts/check_tracked_but_ignored.ts) —
+  ignored-but-tracked detection
+- [`scripts/check_gitignore_freshness.ts`](../../../src/scripts/check_gitignore_freshness.ts) —
+  manifest vs block coverage
+- [`docs/contracts/agents-layout.md`](../../../docs/contracts/agents-layout.md) —
+  classification contract for `agents/` entries

package/dist/agent-src/commands/team-knowledge/bootstrap.md

@@ -0,0 +1,106 @@
+---
+model_tier: medium
+name: team-knowledge-bootstrap
+pack: meta
+tier: 2
+visibility: internal
+cluster: team-knowledge
+sub: bootstrap
+description: One-shot deterministic seed for a fresh project's knowledge layer — stages template pages from real config/directory detection, never LLM-invented claims. Review-then-commit.
+skills: []
+suggestion:
+  eligible: true
+  trigger_description: "bootstrap the knowledge base, seed project knowledge, initialize agents/knowledge, onboard this project's knowledge layer"
+  trigger_context: "a project has no agents/knowledge/ typed pages yet and the user wants a starting baseline"
+workspaces:
+  - agent-config-maintainer
+packs:
+  - meta
+---
+
+# /team-knowledge bootstrap
+
+Seeds a fresh project's `agents/knowledge/` typed pages from
+**deterministic static analysis only** — directory names and known
+config filenames, never file content, never an LLM-invented claim.
+Fast first pass; the deeper analyzers (`project-analysis-*`,
+`standards-from-config`, `module-detect-on-the-fly`) remain the tools
+for filling in what this script cannot know.
+
+## Steps
+
+### 1. Run the detector
+
+```bash
+./scripts-run src/scripts/bootstrap_knowledge
+```
+
+Writes 5 template pages to the gitignored `agents/.bootstrap-staging/`
+directory — never directly to `agents/knowledge/`:
+
+- `concepts/structure.md` — detected package manifest + top-level
+  directories (evidence: the manifest filename / directory name)
+- `concepts/standards.md` — WHICH lint/format/test config files exist
+  (not their content — run `standards-from-config` for that)
+- `concepts/modules.md` — empty seed, `[HUMAN: verify]` (module
+  boundaries need code reading, which this script never does)
+- `procedures/api-conventions.md` — empty seed, fills in from
+  `api_shape_learned` events over time
+- `sessions/common-mistakes.md` — empty seed, fills in from
+  `mistake_made` events over time
+
+### 2. Review with the user
+
+Present the 5 staged pages. Every inferential line carries
+`[HUMAN: verify]` — read them together before committing anything:
+
+```
+> Bootstrap staged 5 pages under agents/.bootstrap-staging/:
+>
+> 1. Review each page now
+> 2. Move all as-is into agents/knowledge/
+> 3. Move selected pages only
+> 4. Discard — start knowledge capture organically instead
+```
+
+**Never move a staged page into `agents/knowledge/` without this
+review** — a bootstrap page moved in blind defeats the "no invented
+claims" guarantee just as surely as inventing the claim directly.
+
+### 3. Move approved pages, regenerate the index
+
+For each approved page:
+
+```bash
+mkdir -p agents/knowledge/<type>
+mv agents/.bootstrap-staging/<type>/<file>.md agents/knowledge/<type>/<file>.md
+```
+
+Then:
+
+```bash
+./scripts-run src/scripts/generate_knowledge_index
+```
+
+The team-sharing gate still applies at commit time — none of these
+pages should carry `visibility: private`.
+
+### 4. Discard the rest
+
+Delete `agents/.bootstrap-staging/` once done (or leave it — it is
+gitignored and regenerates on the next bootstrap run).
+
+## Rules
+
+- Never reads file CONTENTS beyond checking whether a known manifest
+  filename exists — this is what makes the secret/PII exclusion
+  structural rather than a redaction pass that could fail.
+- Never runs automatically — one-shot, user-invoked.
+- Never writes directly to `agents/knowledge/` — staging is mandatory.
+- Do NOT commit the moved pages — that is the user's call.
+
+## See also
+
+- [`/team-knowledge consolidate`](consolidate.md) — the ongoing capture loop this one-shot seed feeds into.
+- [`standards-from-config`](../../skills/standards-from-config/SKILL.md) — the full pointer+digest derivation for coding standards.
+- [`project-analysis-core`](../../skills/project-analysis-core/SKILL.md) / [`module-detect-on-the-fly`](../../skills/module-detect-on-the-fly/SKILL.md) — the deeper analyzers for `modules.md`.

package/dist/agent-src/commands/team-knowledge/consolidate.md

@@ -0,0 +1,105 @@
+---
+model_tier: medium
+name: team-knowledge-consolidate
+pack: meta
+tier: 2
+visibility: internal
+cluster: team-knowledge
+sub: consolidate
+description: Review pending typed knowledge-observation events and file them into agents/knowledge/ pages as a human-reviewed batch — never writes without approval.
+skills: [file-editor]
+suggestion:
+  eligible: true
+  trigger_description: "consolidate knowledge events, review pending observations, file captured knowledge, promote knowledge candidates"
+  trigger_context: "pending events have accumulated in agents/knowledge/intake/ and are ready for review"
+workspaces:
+  - agent-config-maintainer
+packs:
+  - meta
+---
+
+# /team-knowledge consolidate
+
+Turns the gitignored, in-flight typed-observation events
+(`convention_detected` / `mistake_made` / `api_shape_learned` /
+`context_stale` — see `src/scripts/_lib/knowledge_events.ts`) into
+committed `agents/knowledge/` pages. This is the ONLY path from intake
+to a tracked page — no skill or rule writes a tracked knowledge page
+mid-task (see [`knowledge-pages`](../../templates/contexts/knowledge-pages.md)
+§ Storage location).
+
+## Steps
+
+### 1. Generate the report
+
+```bash
+./scripts-run src/scripts/consolidate_knowledge_events
+```
+
+Aggregates pending events by topic and finds the nearest EXISTING
+knowledge page for each aggregate (mechanical similarity only — the
+script never decides the triage verdict).
+
+No pending topics → tell the user and stop. Nothing to do.
+
+### 2. Triage each topic
+
+For each aggregate in the report, apply the same taxonomy
+[`memory-consolidation`](../../skills/memory-consolidation/SKILL.md)
+uses for engineering-memory facts:
+
+| Triage | Condition | Action |
+|---|---|---|
+| `NEW` | No nearest page reported | Draft a new page under the appropriate typed dir |
+| `EXTEND` | Nearest page reported, covers the topic but misses this detail | Draft an addition to that page |
+| `CONFIRM` | Nearest page already states this exactly | Discard this aggregate — no page change |
+| `CONFLICT` | Nearest page states the opposite or a stale variant | Draft BOTH positions into that page with `contested: true`, never silently overwrite |
+
+A high similarity score alone does not distinguish `EXTEND` /
+`CONFIRM` / `CONFLICT` — read the matched page and the aggregate's
+events before deciding.
+
+### 3. Draft and present the batch
+
+For every `NEW` / `EXTEND` / `CONFLICT` aggregate, draft the page
+content (following [`knowledge-pages`](../../templates/contexts/knowledge-pages.md) —
+`date + what + why` for session entries, ≤ 200 lines per page) and
+present the full batch to the user:
+
+```
+> Knowledge consolidation — N topic(s) ready for review:
+>
+> 1. [NEW] <topic> → agents/knowledge/concepts/<slug>.md
+> 2. [EXTEND] <topic> → agents/knowledge/procedures/<existing>.md
+> 3. [CONFLICT] <topic> → agents/knowledge/concepts/<existing>.md (contested)
+>
+> 1. Write all — 2. Write selected — 3. Discard all — 4. Edit a draft first
+```
+
+**Never write before this confirmation.**
+
+### 4. Write, regenerate, clear
+
+On approval:
+
+1. Write each approved page (respecting the team-sharing gate —
+   never set `visibility: private` on a page landing here).
+2. Regenerate the index: `./scripts-run src/scripts/generate_knowledge_index`.
+3. Clear the consumed intake: `./scripts-run src/scripts/consolidate_knowledge_events --commit`
+   (all-or-nothing — re-run step 1 first if the user picked "write
+   selected" and some topics were discarded, so only genuinely
+   consumed events are cleared).
+
+## Rules
+
+- Never invents a page from an aggregate the user did not approve.
+- Never resolves a `CONFLICT` verdict automatically — both positions
+  land in the page, human resolves later.
+- Never writes a page with `visibility: private` (belongs in the
+  ADR-100 global store instead).
+- Do NOT commit the written pages — that is the user's call.
+
+## See also
+
+- [`memory-consolidation`](../../skills/memory-consolidation/SKILL.md) — the sibling loop for the 5 fixed engineering-memory types; this command is its knowledge-page counterpart.
+- [`learning-to-rule-or-skill`](../../skills/learning-to-rule-or-skill/SKILL.md) — where a page's recurring topic graduates into a skill/rule once it crosses the skill-candidate threshold.

package/dist/agent-src/commands/team-knowledge.md

@@ -0,0 +1,64 @@
+---
+model_tier: medium
+name: team-knowledge
+disable-model-invocation: true
+pack: meta
+intent: "Manage the repo-tracked team-knowledge layer — consolidate typed observation events into agents/knowledge/ pages, bootstrap a project baseline"
+routes_to: [team-knowledge-consolidate, team-knowledge-bootstrap]
+replaces: []
+tier: 2
+visibility: internal
+description: Team-knowledge orchestrator — routes to consolidate and bootstrap
+cluster: team-knowledge
+type: orchestrator
+suggestion:
+  eligible: true
+  trigger_description: "consolidate knowledge events, review pending knowledge observations, promote captured knowledge into pages"
+  trigger_context: "user wants to turn accumulated in-flight observations into committed agents/knowledge/ pages"
+workspaces:
+  - agent-config-maintainer
+packs:
+  - meta
+---
+
+# /team-knowledge
+
+Top-level orchestrator for the `/team-knowledge` family — the
+consolidation gate over the typed knowledge-observation events
+captured during normal task work (see
+[`knowledge-pages`](../templates/contexts/knowledge-pages.md) and the
+event schema in `src/scripts/_lib/knowledge_events.ts`).
+
+Not to be confused with the pre-existing `/knowledge` cluster (local
+file ingestion into `agents/memory/knowledge/`) — different concern
+(arbitrary local documents), unrelated to this repo-tracked,
+lifecycle-typed team-knowledge layer under `agents/knowledge/`.
+
+## Sub-commands
+
+| Sub-command | Routes to | Purpose |
+|---|---|---|
+| `/team-knowledge consolidate` | `commands/team-knowledge/consolidate.md` | Read pending intake events, propose tracked-page creates/updates as a reviewable batch, write only on approval |
+| `/team-knowledge bootstrap` | `commands/team-knowledge/bootstrap.md` | One-shot deterministic seed of a fresh project's knowledge pages from real config/directory detection — staged, never auto-committed |
+
+Sub-command names match the locked contract in
+[`docs/contracts/command-clusters.md`](../docs/contracts/command-clusters.md).
+
+## Dispatch
+
+1. Parse the user's argument: `/team-knowledge <sub-command> [args]`.
+2. Look up the sub-command in the table above.
+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, print the table above and ask:
+
+   > 1. consolidate — review pending knowledge events and file them as pages
+   > 2. bootstrap — seed a fresh project's knowledge pages from detection
+
+## Rules
+
+- **Never writes a tracked page without human approval.** Intake is
+  proposal-only; the consolidate flow always shows a batch and waits.
+- **Never fires automatically** — the user invokes this explicitly.
+- **Do NOT commit, push, or open a PR** unless the sub-command
+  explicitly authorizes it.

package/dist/agent-src/contexts/authority/commit-mechanics.md

@@ -71,6 +71,14 @@ The pre-scan ask is the **only** permitted commit-related question
 in autonomous mode. Once answered, the decision is cached for the
 rest of the roadmap execution.
 
+When the roadmap declares `execution.mode: autonomous |
+phase-checkpoints`, this pre-scan ask is subsumed by the run-start
+**execution contract** — one acceptance covers commits, the run's
+feature branch, push to that branch only, and PR-open; see
+[`roadmap-execution-contract`](../execution/roadmap-execution-contract.md)
+and [`scope-mechanics § Roadmap execution contract`](scope-mechanics.md).
+The Hard-Floor per-commit diff gate above is unaffected.
+
 ## Speech-act check on commit phrases
 
 The same speech-act check from

package/dist/agent-src/contexts/authority/destructive-mechanics.md

@@ -55,6 +55,17 @@ A roadmap or task authorizes the *edit*; only the user-this-turn
 authorizes the *commit* (row 6 of the rule's trigger table). Surface
 the diff (paths + counts), get confirmation, then commit.
 
+## Inspect before delete or overwrite
+
+Before running any delete or overwrite — even one already cleared by
+the checks above — look at the target first. If its actual contents
+contradict how it was described (a "generated" file that turns out to
+carry hand-edits, a "stale" branch with commits you don't recognize, an
+"empty" directory that isn't), surface the discrepancy and stop instead
+of proceeding on the original description. The same holds for anything
+you did not create yourself this session: verify before assuming it is
+safe to remove or replace.
+
 ## Failure modes
 
 - Treating a standing autonomy directive as cover for a Hard-Floor

package/dist/agent-src/contexts/authority/scope-mechanics.md

@@ -58,6 +58,31 @@ pinning inside it. If the user names a version in a planning
 request, ask whether the artifact tracks the work or the release;
 default to work.
 
+## Roadmap execution contract — run-scoped standing permission
+
+An **accepted run-start execution contract**
+([`roadmap-execution-contract`](../execution/roadmap-execution-contract.md),
+derived by `roadmap-process-loop § 3` when the roadmap declares
+`execution.mode: autonomous | phase-checkpoints`) IS "explicit
+permission … in a standing instruction not yet revoked" for
+`scope-control § git-ops` — **for that run, and for exactly four
+operations**:
+
+1. Create the run's feature branch (`feat/<roadmap-slug>`, or reuse
+   the current worktree branch).
+2. Chunked commits on that branch (Hard-Floor per-commit diff gate
+   stays; split per `commit-policy`).
+3. Push to **that branch only** — any other ref stays Hard Floor.
+4. Open ONE PR (description-only flow) — never merge / close /
+   retarget.
+
+Boundaries that survive every contract: the frontmatter field alone
+grants **nothing** (declaration of intent — no accepted contract, no
+grants); grants expire when the run ends or halts; prod-trunk
+operations, deploys, bulk deletions, infra commits, and merges are
+outside contract scope always; kernel-rule edits keep their own-PR +
+24h-soak guarantee.
+
 ## Brief-before-asking — separate branch / PR / worktree
 
 If a task seems to need a separate branch or PR (spike, hotfix,

package/dist/agent-src/contexts/communication/rules-auto/reply-close-mechanics.md

@@ -0,0 +1,43 @@
+# Reply close — work summary + PR link
+
+Lookup material for the reply-close carve-out in the
+[`direct-answers`](../../../rules/direct-answers.md) Brevity Iron Law. Rule body
+states the obligation in one line; this file is the detail.
+
+## The carve-out
+
+Brevity governs the reply **body**; the **close** is the exception.
+
+- Reply that landed **substantial work** — multi-step change, roadmap/branch
+  progress, or a created/updated PR — ends with **ONE** compact status summary at
+  the very end, never mid-reply: what's done, what remains.
+- **Simple one-answer replies still skip the summary** (Brevity Iron Law unchanged
+  for them). Summary is for work replies, not every turn.
+
+## PR link is the literal last line
+
+PR **created or updated this turn** → its raw GitHub URL is the **literal last
+line**, after the summary, nothing below it — so the user never hunts for it. One
+PR → one URL line.
+
+- Only when a PR was actually created/updated **this turn**. No PR → no link line.
+- Raw URL (not a masked markdown link) so it is unmistakable and clickable.
+
+## Why it does not collide with sibling rules
+
+- **`language-and-tone`** last-line rule: a raw URL is language-neutral → satisfies
+  the "every user-visible token mirrors the user's language" gate.
+- **`no-pr-progress-comments`** / **`no-attribution-footers`**: those govern
+  comments posted *on the PR*. Summary + URL here are the **chat reply body**, not
+  a PR comment — neither applies.
+- **`user-interaction`**: a numbered-options block, when present, still comes last
+  among interactive elements; the PR URL sits below it as the final line and is not
+  an "open question" → does not trip the no-trailing-open-question rule.
+
+## Failure modes
+
+- Burying the summary mid-reply, then continuing with more detail below it.
+- Emitting the summary for a trivial one-answer reply (brevity says skip).
+- Creating a PR but leaving its URL mid-reply, forcing the user to scroll/search.
+- Masking the URL behind link text so it is not obviously the PR.
+- Adding a PR-link line when no PR was created this turn.

package/dist/agent-src/contexts/contracts/agents-md-anatomy.md

@@ -104,7 +104,7 @@ package edit touches the same hot file.
    `agents/settings/contexts/`, `docs/contracts/`, an existing rule body, or
    an existing skill body. Replace in-file with a substantive
    pointer. Never invent a new top-level dir.
-5. **Verify.** Run `python3 scripts/lint_agents_md.py` until green;
+5. **Verify.** Run `./scripts-run src/scripts/lint_agents_md` until green;
    `wc -c AGENTS.md` ≤ target cap; emergency-triage block intact.
 
 ## Common gotchas

package/dist/agent-src/contexts/contracts/artifact-engagement-flow.md

@@ -213,7 +213,7 @@ rule listed above:
 
 ```bash
 # Validate every line against the schema + redaction floor
-python3 -c '
+node -e '
 import pathlib, sys
 sys.path.insert(0, ".agent-src.uncondensed/templates/scripts")
 from telemetry.engagement import EngagementSchemaError, parse_event
@@ -232,7 +232,7 @@ print(f"{ok} valid, {bad} rejected")
 '
 
 # A bad-line spot-check that does not depend on the validator
-python3 -c '
+node -e '
 import json, pathlib, re
 forbidden = re.compile(r"[/\\\\]|\.[a-z0-9]{1,10}$", re.IGNORECASE)
 for line in pathlib.Path(".agent-engagement.jsonl").read_text().splitlines():

package/dist/agent-src/contexts/contracts/frugality-charter.md

@@ -18,6 +18,7 @@ Cite the source rule in writer artifacts; do **not** restate it here.
 | Numbered-options trade-off rule (real consequence, not sequencing) | [`user-interaction § Iron Law 1 — Single-Source Recommendation`](../../rules/user-interaction.md#iron-law-1--single-source-recommendation) |
 | Cheap-question pre-send check (skip the ask if context already answers) | [`no-cheap-questions § Pre-Send Self-Check`](../../rules/no-cheap-questions.md#pre-send-self-check--mandatory-before-every-question) |
 | Tool-call discipline, act-skip-narration, fresh output over memory | [`token-efficiency § The Iron Laws`](../../rules/token-efficiency.md#the-iron-laws) and its mechanics file |
+| Budget is an input to the decision, never the decision — surface the trade-off before auto-rejecting a net-positive change on cost grounds | [`token-budget-discipline § Value-over-budget escalation`](../../rules/token-budget-discipline.md#value-over-budget-escalation) |
 
 ## Confirmation taxonomy
 

package/dist/agent-src/contexts/execution/auto-dispatch-classification.md

@@ -21,10 +21,20 @@ A task is classified **delegable** when **any** of these holds:
    `parallelizable: steps | files | independent` in its frontmatter.
    - `steps` → ordered plan → `do-in-steps`.
    - `files` / `independent` → independent slices → `do-in-parallel`.
-2. **Ordered-plan structure** — the task is an explicit ordered plan (numbered
-   steps / a roadmap phase / a checklist) → `do-in-steps`.
-3. **Independent-slices structure** — N independent targets of the same shape
-   (e.g. "review these 5 files", "convert each adapter") → `do-in-parallel`.
+2. **Ordered-plan structure** — explicit ordered plan (numbered steps / a roadmap
+   phase / a checklist) → `do-in-steps`. Deterministic markers:
+   - `1. … 2. … 3.` numbered list in the user message.
+   - References a roadmap phase or checklist.
+   - "first … then … finally" with distinct deliverables.
+   - "in N steps" or "phase by phase".
+3. **Independent-slices structure** — N ≥ 3 independent targets of the same shape
+   → `do-in-parallel`. Deterministic markers (N ≥ 3 of the same form):
+   - N file paths, each a separate analysis/edit target.
+   - N named modules/components for the same action.
+   - N named test files, adapters, endpoints, or services to convert/review/audit.
+   - "for each X in [list]" where list ≥ 3 items, no cross-item dependency.
+   Do **not** fire on interdependent lists (e.g. "add these 3 sequential
+   migrations") — those are ordered plans (signal 2).
 
 AND the **task-size floor** is cleared: the task's estimated size exceeds a
 minimum (trivial one-line edits never delegate — the dispatch overhead

package/dist/agent-src/contexts/execution/autonomy-mechanics.md

@@ -71,3 +71,14 @@ regardless of `personal.autonomy`:
 Push, merge, rebase, branch creation, PR operations, and tags
 remain permission-gated by
 [`scope-control § git-operations`](../../rules/scope-control.md#git-operations--permission-gated).
+
+## End-of-turn checkpoint
+
+Before ending a turn, check the last paragraph of the reply. If it is a
+plan, an open question the context already answers, or a promise of
+unexecuted work ("I'll…", "next I will…"), do that work now with tool
+calls instead of ending the turn — this is what "the turn isn't done
+until it's done" means in practice. This checkpoint operates inside the
+existing bounds: the N=3 validation-loop budget and the Hard Floor
+still apply unchanged; the checkpoint closes out work already in scope,
+it never licenses continuing past either limit.