oris-skills 2.2.3 → 3.0.1

package/skills/oris-flow/references/new.md

@@ -10,7 +10,7 @@ RULES: `references/conventions.md`. Writes ONLY after the recap is confirmed.
 
 1. PURPOSE — the product in one sentence; it anchors every agent decision and opens AGENTS.md.
 2. TYPE — webapp | api | library | cli | monorepo. Drives layout and verify strategy.
-3. STACK — recommend from purpose + the user's existing repos (setup maps of sibling
+3. STACK — recommend from purpose + the user's existing repos (`AGENTS.md` of sibling
    projects when visible). Never impose.
 4. TEST RUNNER + LINT — the stack's default unless the user objects. Non-negotiable that
    one exists: agents need a red/green signal, not opinions.
@@ -42,10 +42,10 @@ RUN the test command and the lint command; SHOW real output — fail first, then
 
 ## Arm the flow
 
-1. RUN `npx oris-skills flow scan --repository-root <repo> --write` — manifest + maps;
-   the commands just verified → mark `confirmed`.
-2. RUN `npx oris-skills loop bootstrap --repository-root <repo>`.
-3. tasksRoot: `.oris-flow/tasks` (default — the project stays clean).
+1. The commands just verified are ALREADY in `AGENTS.md` (scaffold table) — that is the
+   whole record; nothing else to generate.
+2. WRITE `.oris-flow/settings.json` with the defaults (`references/settings.md`);
+   tasksRoot `.oris-flow/tasks` — the project stays clean.
 
 AFTER: offer discover the first feature (`skills/oris-flow/references/discover.md`) | stop.
 
@@ -61,4 +61,4 @@ AFTER: offer discover the first feature (`skills/oris-flow/references/discover.m
 - [ ] Purpose, type, stack, test runner confirmed before any write.
 - [ ] AGENTS.md sparse and commands-first; CONTEXT.md + ADR-0001 written.
 - [ ] Test + lint observed running (fail → pass shown).
-- [ ] Manifest written with confirmed commands; loop bootstrapped.
+- [ ] Verified commands recorded in `AGENTS.md`; settings written with defaults.

package/skills/oris-flow/references/plan.md

@@ -4,13 +4,17 @@ Interview the technical owner until another agent or developer could execute the
 without guessing.
 
 RULES: `references/conventions.md`. Doc standards: `references/doc-policy.md`.
+Research: `references/research.md`.
 
 ## Before asking
 
 1. EXPLORE: `functional-analysis.md` + `acceptance-criteria.md` when present (preferred,
    not required — offer discovery only when the functional source is too weak to plan
-   safely), task docs, setup map, standards, code, tests, build scripts.
-2. PREFER existing project patterns over new abstractions. Keep uncertainty visible.
+   safely), task docs, `AGENTS.md`, standards, code, tests, build scripts.
+2. RESEARCH external surfaces (`references/research.md`): the plan leans on a
+   third-party API, library, or service → verify against its current official docs at
+   the repo's pinned versions; sources go into the plan.
+3. PREFER existing project patterns over new abstractions. Keep uncertainty visible.
 
 ## Interview
 
@@ -36,6 +40,7 @@ ON generate → write `{tasksRoot}/{task}/implementation-plan.md` (language `art
 ### 2. …
 ## Verification    (commands, tests, what proves each step)
 ## Risks & open points
+## Sources         (only when research ran: link + what it settled)
 ## Change history  (date | source | change | reason)
 ```
 

package/skills/oris-flow/references/setup.md

@@ -1,25 +1,20 @@
 # Oris Setup
 
-Make the repo cheap for agents to understand — manifest + maps + AI-readiness + loop
-readiness. ADAPT to what the repo IS; never force one structure. Writes ONLY after the
-user confirms the recap.
+Make the repo cheap for agents to understand — `AGENTS.md` as the one durable store,
+preferences in `.oris-flow/settings.json`, AI-readiness checked. ADAPT to what the repo
+IS; never force one structure. Writes ONLY after the user confirms the recap.
 
-RULES: `references/conventions.md`. Map format: `references/repo-map.md`.
+RULES: `references/conventions.md`. Settings: `references/settings.md`.
 IF the repo is empty or brand-new → route to `skills/oris-flow/references/new.md` instead.
 
 ## Mode
 
-IF `.oris-flow/manifest.json` exists → CHECK freshness first:
-`npx oris-skills flow scan --repository-root <repo> --check` — `fresh: true` → say so
-(a rescan would be a no-op); stale → the `changedFiles` list names the areas worth
-refreshing. THEN ask ONE question with these options:
-- refresh all (keeps `confirmed` values — scan merges, never overwrites them)
-- update one area (`--area <section>`)
-- review stale sections
+IF `AGENTS.md` (or `CLAUDE.md`) exists → this is a refresh: READ it first, then ask ONE
+question with these options:
+- update it from a fresh scan (scan below; edits merge in, confirmed facts stay)
+- review one section
 - show summary (no writes)
-- recreate from scratch
 - preferences → Local Preferences below; touches only `.oris-flow/settings.json`
-- clean runtime → preview with `npx oris-skills flow clean-runtime --repository-root <repo> --dry-run`, confirm, run without `--dry-run`
 
 ELSE → create from scratch.
 
@@ -27,8 +22,8 @@ ELSE → create from scratch.
 
 1. CONFIRM the target repository root (ask only if multiple roots are plausible).
 2. SCAN: `npx oris-skills flow scan --repository-root <repo> --json` — deterministic
-   baseline: `projectType`, stacks, commands (with confidence), sections, `truncated`
-   flag. Scan output = draft evidence, not truth.
+   baseline: `projectType`, stacks, commands (with confidence), areas, `truncated` flag.
+   Scan output = draft evidence, not truth; it writes nothing.
 3. IF `truncated: true` → say so, then per-area subagent scans are REQUIRED, not optional.
 4. FAN OUT parallel subagent scans (docs, frontend, backend/data, tests/build, local
    skills/rules) by DEFAULT whenever the repo has more than one of those areas —
@@ -43,14 +38,15 @@ SHOW compactly: detected project type + evidence, stacks, commands, AI-readiness
 Then WALK decisions ONE per turn — short explainer first, recommended answer first:
 
 - **Project type** — confirm `projectType` (webapp | api | library | cli | monorepo); it
-  drives which map sections matter and how criteria/verify observe behavior.
+  drives how criteria/verify observe behavior.
 - **Tasks root** — where Oris writes task documents. Default `.oris-flow/tasks` (keeps
   the project clean); keep `docs/tasks` only when the team already treats task docs as
-  project docs. Record in `setup.tasksRoot`.
-- **Verify commands** — show detected build+test commands; user confirms or corrects →
-  mark `confirmed`. They feed implement, verify, and loop VERIFIER; unconfirmed = a guess.
-- **Version control for `.oris-flow/`** — commit (team default) or gitignore. Task docs
-  follow the same choice.
+  project docs. Record in settings `tasksRoot`.
+- **Verify commands** — show detected build+test commands; user confirms or corrects.
+  Confirmed commands go into `AGENTS.md` — they feed implement, verify, and fix;
+  unconfirmed = a guess.
+- **Version control for `.oris-flow/`** — commit (team default) or gitignore. Record in
+  settings `versionControl`.
 
 ## 3. AI-readiness check
 
@@ -63,7 +59,7 @@ fix offer:
 | `CONTEXT.md` | domain glossary — the names agents must use for the product's concepts |
 | `docs/adr/` | decisions agents must not re-litigate |
 | project skills/rules (`.claude/skills`, `.cursor/rules`) | repeatable workflows as source of truth |
-| confirmed test/build commands | deterministic feedback loop — agents verify instead of guessing |
+| confirmed test/build commands in `AGENTS.md` | deterministic feedback — agents verify instead of guessing |
 
 ON explicit confirmation per file → scaffold the missing ones minimal.
 
@@ -71,32 +67,29 @@ ON explicit confirmation per file → scaffold the missing ones minimal.
 
 1. RECAP: repo, mode, project type, tasksRoot, files to write, AI-readiness gaps,
    choices. CONFIRM explicitly.
-2. WRITE `.oris-flow/manifest.json` + `.oris-flow/maps/**` (confirmed facts get
-   confidence `confirmed` so refresh preserves them), then apply:
-   - `npx oris-skills flow version-control --repository-root <repo> --mode commit|gitignore`
-   - `npx oris-skills loop bootstrap --repository-root <repo>` when adapter/hooks are missing.
-3. OFFER next: discovery | technical plan | loop (`npx oris-skills loop demo` for
-   first-timers) | refresh one area | stop.
+2. WRITE `AGENTS.md` (edit the file that exists — never create `AGENTS.md` beside
+   `CLAUDE.md`) + `.oris-flow/settings.json`, then apply:
+   `npx oris-skills flow version-control --repository-root <repo> --mode commit|gitignore`.
+3. OFFER next: discovery | technical plan | review one area | stop.
 
 ## Local Preferences
 
 1. READ `.oris-flow/settings.json` (defaults in `references/settings.md`).
 2. ASK what to change: artifactLanguage (document language, default `en`) | responseStyle
-   (standard | caveman — maximum token density in chat).
+   (standard | caveman — maximum token density in chat) | tasksRoot | versionControl.
 3. SHOW summary, CONFIRM, write ONLY the settings file.
 
 ## Never
 
 - Write before the recap is explicitly confirmed.
-- Overwrite `confirmed` values on refresh — the scan merges; missing evidence marks
-  stale, never deletes.
-- Overwrite existing agent files: edit the file that exists, never create `AGENTS.md`
-  beside `CLAUDE.md`.
-- Copy secrets into `.oris-flow/**`, docs, or loop state.
+- Overwrite existing agent files: edit the file that exists, never create a rival.
+- Bloat `AGENTS.md`: facts agents need on every request only — commands, structure
+  pointers, decisions; long reference material belongs in `docs/` or skills.
+- Copy secrets into `AGENTS.md`, `.oris-flow/**`, or docs.
 
 ## Done when
 
 - [ ] Mode chosen; scan ran before questions; decisions asked one at a time with explainers.
-- [ ] Project type and tasksRoot recorded; confirmed commands marked `confirmed`.
+- [ ] Confirmed commands and decisions recorded in `AGENTS.md`; preferences in settings.
 - [ ] AI-readiness gaps reported; files scaffolded only on explicit per-file confirmation.
 - [ ] Explicit confirmation before every write; no secrets in repository files.

package/skills/oris-flow/references/verify.md

@@ -1,7 +1,7 @@
 # Verify
 
 Check every acceptance criterion against the REAL product once, with evidence. One pass,
-no loop ceremony.
+no ceremony.
 
 RULES: `references/conventions.md`. Doc standards: `references/doc-policy.md`.
 
@@ -10,7 +10,7 @@ RULES: `references/conventions.md`. Doc standards: `references/doc-policy.md`.
 1. FIND `{tasksRoot}/{task}/acceptance-criteria.md` ({task} per doc-policy). IF missing →
    offer: define criteria first (`skills/oris-flow/references/criteria.md`) | verify against a
    confirmed chat recap | stop.
-2. READ setup map + verification conventions (test commands, run scripts, environments)
+2. READ `AGENTS.md` + verification conventions (test commands, run scripts, environments)
    before improvising.
 3. PLAN one check per AC: command, test, API call, or observed behavior.
 
@@ -39,9 +39,8 @@ Date: … | Source: acceptance-criteria.md | Verified by: oris-flow verify route
 ## Change history  (date | source | change | reason)
 ```
 
-ON fix → enter `skills/oris-flow/references/fix.md` with the failing AC as the bug report.
-LONG iterative fixing with re-verification each pass → recommend
-`skills/oris-flow/references/loop.md` only when one fix-verify pass is clearly not enough.
+ON fix → enter `skills/oris-flow/references/fix.md` with the failing AC as the bug report;
+re-verify the fixed criteria afterwards, as many fix-verify passes as the user approves.
 
 ## Never
 

package/agents/oris-loop-debriefer.md

@@ -1,30 +0,0 @@
----
-name: oris-loop-debriefer
-description: Learns across Oris Loop receipts and tunes the loop prompts (improve.mode auto) or proposes changes (propose). Use after passes complete.
-readonly: false
----
-
-You are the Oris Loop debriefer.
-
-Rules:
-
-1. Use receipts and referenced evidence only; no durable pattern from a single weak signal.
-2. Separate design problems from execution, environment, verifier, and changed-goal problems.
-3. improve.mode auto: you may rewrite files under the loop's `prompts/` — copy the old file to `history/` first, note the change for the receipt. One improvement per debrief.
-4. improve.mode propose: write the smallest evidence-backed change to `proposals/`; change nothing else.
-5. NEVER touch loop.md scope, limits, permissions, or verification — always a proposal.
-   NEVER weaken verification to make passes green — fix the loop, not the bar.
-6. Keep the summary compact.
-
-Output:
-
-```json
-{
-  "role": "debriefer",
-  "outcome": "keep|tuned|proposed|execution-issue|environment-blocked|inconclusive",
-  "insight": "",
-  "changedFiles": [],
-  "proposalPath": "",
-  "nextAction": ""
-}
-```

package/agents/oris-loop-doctor.md

@@ -1,32 +0,0 @@
----
-name: oris-loop-doctor
-description: Diagnoses Oris Loop run evidence and decides whether to continue, block, ask the user, or propose a minimal loop patch.
-readonly: true
----
-
-You are the Oris Loop Doctor.
-
-Rules:
-
-1. Diagnose from receipts and verifier evidence, not confidence.
-2. Distinguish loop design issues from execution mistakes, verifier issues,
-   environment failures, changed goals, and insufficient evidence.
-3. Do not patch the loop directly.
-4. Propose the smallest loop change only when evidence shows the loop design is
-   the problem.
-5. Require approval for changes to scope, authority, commands, paths, stop
-   rules, risk, credentials, or external systems.
-
-Output:
-
-```json
-{
-  "role": "doctor",
-  "decision": "continue|advance|complete|ask-user|propose-patch|blocked",
-  "diagnosis": "",
-  "evidence": "",
-  "patchSummary": "",
-  "approvalRequired": true,
-  "nextAction": ""
-}
-```

package/agents/oris-loop-executor.md

@@ -1,35 +0,0 @@
----
-name: oris-loop-executor
-description: Performs one bounded action for an approved Oris Loop pass. Use only when the orchestrator provides loop scope, current phase, allowed paths, and verification intent.
-readonly: false
----
-
-You are the Oris Loop executor.
-
-Rules:
-
-1. Verify the task includes `ORIS LOOP ACTIVE`.
-2. Read only the loop definition, context, and files in declared scope.
-3. Perform exactly one bounded action. Re-read the fresh state of every file
-   you touch before editing it. The action proves bigger than bounded → stop
-   and return blocked with what you found; half-done work is worse than none.
-4. Preserve unrelated user work.
-5. Do not commit, push, deploy, write DevOps, send external messages, expose
-   credentials, or edit `.oris-flow/runtime/**`.
-6. Return a compact result with changed files, claim, risk, and suggested
-   verifier check. claim = what changed + the exact command or observation
-   that proves it.
-
-Output:
-
-```json
-{
-  "role": "executor",
-  "state": "claimed|blocked",
-  "summary": "",
-  "changedFiles": [],
-  "claim": "",
-  "evidenceHint": "",
-  "blocker": ""
-}
-```

package/agents/oris-loop-verifier.md

@@ -1,35 +0,0 @@
----
-name: oris-loop-verifier
-description: Independently verifies an Oris Loop executor claim using declared project evidence. Use after an executor reports a bounded action.
-readonly: true
----
-
-You are the Oris Loop verifier.
-
-Rules:
-
-1. Do not trust the executor claim without evidence. Run the checks FIRST,
-   judge after — a claim you could not check is inconclusive, never pass.
-2. Use the verification command, static check, browser evidence, or review rule
-   declared by the loop.
-3. Do not edit product files — you only observe, never fix.
-4. Keep raw logs out of the orchestrator response; point to evidence files when
-   available.
-5. Report pass, fail, blocked, or inconclusive.
-
-Output:
-
-```json
-{
-  "role": "verifier",
-  "state": "pass|fail|blocked|inconclusive",
-  "goalMet": false,
-  "summary": "",
-  "evidence": "",
-  "evidencePath": "",
-  "failureSignal": "",
-  "nextRecommendation": ""
-}
-```
-
-`goalMet` is true only when the loop goal itself is satisfied, not just this pass.

package/references/loop-adapter.schema.json

@@ -1,93 +0,0 @@
-{
-  "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "https://oris.dev/schemas/oris-loop-adapter-v1.json",
-  "title": "Oris Loop Repository Adapter",
-  "type": "object",
-  "additionalProperties": false,
-  "required": ["$schema", "schemaVersion", "repository", "paths", "commands", "preflight"],
-  "properties": {
-    "$schema": {
-      "const": "https://oris.dev/schemas/oris-loop-adapter-v1.json"
-    },
-    "schemaVersion": {
-      "const": 1
-    },
-    "repository": {
-      "type": "string",
-      "minLength": 1
-    },
-    "paths": {
-      "type": "object",
-      "additionalProperties": false,
-      "required": ["runtime", "allowed", "protected"],
-      "properties": {
-        "taskRoots": {
-          "type": "array",
-          "uniqueItems": true,
-          "items": { "$ref": "#/$defs/relativePath" }
-        },
-        "runtime": { "$ref": "#/$defs/relativePath" },
-        "loops": { "$ref": "#/$defs/relativePath" },
-        "allowed": {
-          "type": "array",
-          "minItems": 1,
-          "uniqueItems": true,
-          "items": { "$ref": "#/$defs/relativePath" }
-        },
-        "protected": {
-          "type": "array",
-          "uniqueItems": true,
-          "items": { "$ref": "#/$defs/relativePath" }
-        },
-        "testDir": { "$ref": "#/$defs/relativePath" }
-      }
-    },
-    "commands": {
-      "type": "object",
-      "minProperties": 1,
-      "propertyNames": { "pattern": "^[a-z][a-z0-9-]*$" },
-      "additionalProperties": { "$ref": "#/$defs/command" }
-    },
-    "models": {
-      "type": "object",
-      "description": "Model alias map per repository, e.g. { \"smart\": \"composer-2.5\" }; loop.md can reference aliases",
-      "propertyNames": { "pattern": "^[a-z][a-z0-9-]*$" },
-      "additionalProperties": { "type": "string", "minLength": 1 }
-    },
-    "preflight": {
-      "type": "object",
-      "additionalProperties": false,
-      "required": ["minFreeDiskGiB"],
-      "properties": {
-        "minFreeDiskGiB": {
-          "type": "number",
-          "minimum": 0
-        }
-      }
-    }
-  },
-  "$defs": {
-    "relativePath": {
-      "type": "string",
-      "minLength": 1,
-      "not": { "pattern": "(^|[\\\\/])\\.\\.([\\\\/]|$)" }
-    },
-    "command": {
-      "type": "object",
-      "additionalProperties": false,
-      "required": ["executable", "args", "cwd"],
-      "properties": {
-        "executable": { "type": "string", "minLength": 1 },
-        "args": {
-          "type": "array",
-          "items": { "type": "string" }
-        },
-        "cwd": { "$ref": "#/$defs/relativePath" },
-        "requiresFreeDiskGiB": {
-          "type": "number",
-          "minimum": 0
-        }
-      }
-    }
-  }
-}

package/references/loop-contract.md

@@ -1,126 +0,0 @@
-# Oris Loop Contract (v2)
-
-An Oris loop is a project-local feedback system: observe → choose ONE bounded action → act → verify with real evidence → record → repeat or stop. It is never permission for work outside its approved scope.
-
-## Layout — everything lives in the project
-
-```text
-.oris-flow/
-  adapter.json          repo adapter (paths, commands, model aliases) — `npx oris-skills loop bootstrap`
-  loops/{slug}/
-    loop.md             approved contract (front matter below)
-    prompts/            one editable file per ACTIVE role
-      orchestrator.md   injected each pass by the stop hook (optional; default shipped)
-      executor.md       required
-      verifier.md       required
-      doctor.md         only when roles includes doctor
-      debriefer.md      only when roles includes debriefer (required for improve.mode: auto)
-    context.md          living handoff snapshot (facts, next action)
-    receipts/           one compact receipt per pass
-    proposals/          unapproved improvement patches
-    history/            archived loop.md and prompt versions
-  runtime/              machine-owned state — agents NEVER edit it
-```
-
-## loop.md front matter (the runtime contract)
-
-```yaml
----
-schemaVersion: 2
-kind: oris-loop
-name: my-loop            # stable slug
-approved: true           # set by the user's approval at craft — loop cannot start without it
-phases: [work]
-roles: [executor, verifier]   # default; opt in doctor and/or debriefer only when needed
-limits:
-  maxIterations: 10
-  maxNoProgress: 2       # consecutive passes without verified progress → blocked
-  maxMinutes: 240
-models:                  # per-role: "inherit" | adapter alias | platform model id
-  default: inherit
-  verifier: inherit      # override any role independently
-improve:
-  mode: propose          # propose | auto (auto = debriefer may rewrite prompts/ between passes)
-permissions:
-  allowedPaths: []
-  forbiddenActions: [commit, push, deploy, external-message]
-verification:
-  commands: []
-  evidenceRequired: true
----
-Goal: one sentence.
-Stop: one sentence.
-```
-
-Schema: `references/loop.schema.json`. Body = human summary; prompts live in `prompts/`, never inline.
-`approved: true` marks user approval of goal, scope, prompts, and limits. It never authorizes work outside the loop.
-
-## Roles
-
-Default roles are **executor + verifier** — enough for most loops. Opt in `doctor` (multi-phase loops with non-trivial stop logic) and `debriefer` (long unattended runs that should learn across passes) via `roles:` in loop.md.
-
-| Role | Default | Does | Never |
-|------|---------|------|-------|
-| orchestrator (main chat) | always | reads context, spawns roles, writes receipts, sets state | executor/verifier/doctor work |
-| executor | yes | ONE bounded action per pass | self-verify, exceed scope |
-| verifier | yes | independent evidence check per user criteria; sets `goalMet` when the LOOP goal is satisfied | trust claims, edit product files |
-| doctor | opt-in | decision from evidence: `continue \| advance \| complete \| ask-user \| propose-patch \| blocked` (canonical enum — every doctor prompt uses exactly these) | edit files, patch loop.md |
-| debriefer | opt-in | learn across receipts; tune prompts (auto) or propose (propose) | touch scope/limits/permissions |
-
-Without a doctor, the verifier verdict maps to the state directly: `pass` + `goalMet` → complete; `pass`/`fail` → continue; `blocked`/`inconclusive` → ask-user.
-
-Every prompt is a file the user can edit; the next pass obeys the edited file. The executor prompt carries the literal gate `ORIS LOOP ACTIVE` — executors refuse tasks without it. Subagent output is a single ```json fenced block; raw logs go to `.oris-flow/runtime/evidence/`. Read-only roles (verifier, doctor) run without write permission in headless mode.
-
-## Models
-
-`inherit` → the current session's model (no explicit model passed).
-Adapter aliases → `adapter.json` `models: { "smart": "<platform-model-id>" }`; loop.md references the alias, so the same loop.md ports across platforms.
-Anything else → passed through as a platform model id.
-
-## Triggers per platform
-
-| Platform | Mechanism |
-|----------|-----------|
-| Cursor | `.cursor/hooks.json` stop hook → injects the next pass into the same chat |
-| Claude Code | `.claude/settings.json` Stop hook → `decision: block` continues the same session |
-| Codex / CI | `npx oris-skills loop run` — each role is a separate CLI process |
-
-`npx oris-skills loop bootstrap` writes adapter + hooks + wrappers. The injected pass message comes from `prompts/orchestrator.md` (or the shipped default) with `{{placeholders}}` filled from runtime state.
-
-## States and outcomes
-
-Machine states: `continue` | `advance` | `complete` | `ask-user` | `blocked` | `cancelled`.
-`ask-user` pauses the loop for input or approval — the hook stops resuming until the state is set back to `continue` (or the loop is restarted). It is NOT a failure.
-Receipt results: `Success` | `Clean no-op` | `Blocked` | `Approval required` | `Exhausted` | `No progress`.
-Every `set-state` carries `--progress yes|no` (yes = the verifier confirmed forward movement); `maxNoProgress` consecutive `no` passes force `blocked`.
-Hitting any limit without meeting the goal = `blocked`, NEVER success.
-
-## Receipt (per pass)
-
-```markdown
-# Oris Loop Receipt
-Loop: <slug> | Pass: <n> | Result: <outcome>
-Scope: <inspected/changed>
-Check: <verification + conditions>
-Evidence:
-- <summary + pointer>
-Actions:
-- <bounded action + outcome>
-Improved: <prompt tuned this pass, or none>
-Next: <next action | approval | blocker | nothing>
-```
-
-No secrets, no private reasoning, no full transcripts in receipts.
-
-## Self-improvement
-
-- `improve.mode: auto` → debriefer may rewrite `prompts/*.md` (archive old file to `history/` first, note the change in the receipt). One improvement per pass, evidence-backed.
-- `improve.mode: propose` → every change lands in `proposals/` until the user approves.
-- BOTH modes: scope, limits, permissions, verification commands change only via approved proposal; previous `loop.md` → `history/loop.vN.md`.
-
-## Iteration rules
-
-- Re-read fresh state before consequential actions; preserve unrelated user work.
-- Only declared paths, commands, tools, and data policy.
-- NEVER: commit, push, branch, PR, deploy, DevOps writes, external messages, credential exposure — unless the loop explicitly permits that exact action.
-- Real verification before claiming success. Update only `context.md`, receipts, and declared write scopes.