microwave-method 0.1.0__tar.gz

microwave_method-0.1.0/.gitattributes

@@ -0,0 +1,12 @@
+* text=auto
+*.sh text eol=lf
+*.py text eol=lf
+*.md text eol=lf
+*.csv text eol=lf
+*.yml text eol=lf
+*.json text eol=lf
+hooks/pre-commit text eol=lf
+*.ps1 text eol=crlf
+*.png binary
+*.ico binary
+*.icns binary

microwave_method-0.1.0/.github/workflows/gates.yml

@@ -0,0 +1,34 @@
+name: gates
+on:
+  pull_request:
+  push:
+    branches: [main]
+
+permissions:
+  contents: read
+
+jobs:
+  gates:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - name: Wiki integrity
+        run: python gates/gate_wiki.py
+      - name: Anti-slop sweep
+        run: python gates/gate_slop.py
+      - name: Generated docs are fresh
+        run: python gates/gate_docs.py
+      - name: All agent cards (active and staged)
+        run: |
+          set -e
+          found=0
+          for card in wiki/agents/*.md wiki/_staging/*.md; do
+            [ -e "$card" ] || continue
+            case "$card" in *README.md) continue;; esac
+            found=1
+            python gates/run_gates.py "$card"
+          done
+          [ "$found" = "1" ] || echo "no agent cards yet"

microwave_method-0.1.0/.gitignore

@@ -0,0 +1,8 @@
+__pycache__/
+*.pyc
+.DS_Store
+Thumbs.db
+*.bak.*
+dist/
+.venv/
+embodiment/icons/build/

microwave_method-0.1.0/CODEOWNERS

@@ -0,0 +1,10 @@
+# The gatekeeper owns the protected space: no change to the rules, the flows,
+# or the meta wiki merges without their review (pair with branch protection,
+# see docs/governance.md "Repo layer").
+/gates/        @microphage-create
+/flows/        @microphage-create
+/hooks/        @microphage-create
+/harness/      @microphage-create
+/wiki/adr/     @microphage-create
+/.github/      @microphage-create
+/CODEOWNERS    @microphage-create

microwave_method-0.1.0/CONTRIBUTING.md

@@ -0,0 +1,31 @@
+# Contributing
+
+The most valuable first contribution takes five minutes: run the macOS or
+Linux embodiment adapter on a real machine and report what happened (see
+`docs/embodiment.md`). Open an issue titled `adapter-report: <os>` with your
+OS version, your terminal, and the output of:
+
+```
+python3 embodiment/embody.py wiki/agents/factory.md --dry-run
+python3 embodiment/embody.py wiki/agents/factory.md
+python3 embodiment/embody.py wiki/agents/factory.md --remove
+```
+
+## Pull requests
+
+- Run the gates before pushing: `python gates/gate_wiki.py && python
+  gates/gate_slop.py` (the pre-commit hook does this if you ran
+  `hooks/install-hooks.sh`). CI runs them on every PR.
+- Changes to `gates/`, `flows/`, `hooks/`, `harness/` or `wiki/adr/` go
+  through the amend-rule flow (`flows/amend-rule.md`) and require gatekeeper
+  review (see CODEOWNERS).
+- Keep it stdlib-only (ADR-007): a PR adding a dependency to a gate or an
+  adapter core path will be declined.
+- Prose follows the repo's own slop rules (`slop/slop-rules.csv`); the gates
+  will tell you.
+
+## Scope
+
+Bug fixes, adapter reports, portability fixes and slop-rule contributions
+are welcome directly. New flows, gates or adapters: open an issue first so
+the design discussion happens before the code.

microwave_method-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Microphage SASU (Romain Bigache)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

microwave_method-0.1.0/NOTICE.md

@@ -0,0 +1,35 @@
+# Notices
+
+Microwave Method is an original work by Microphage SASU (Romain Bigache), MIT licensed.
+
+## Attribution
+
+The elicitation and guided-creation approach is inspired by the
+**BMAD-METHOD** project (https://github.com/bmad-code-org/BMAD-METHOD),
+released under the MIT License, copyright (c) 2025 BMad Code, LLC and
+contributors.
+
+Adapted from BMAD-METHOD (MIT), with gratitude:
+- `techniques/brainstorming-methods.csv`: from
+  `src/core-skills/bmad-brainstorming/assets/brain-methods.csv`
+- `techniques/elicitation-methods.csv`: from
+  `src/core-skills/bmad-advanced-elicitation/assets/methods.csv`
+
+Adapted from bmad-module-creative-intelligence-suite
+(https://github.com/bmad-code-org/bmad-module-creative-intelligence-suite,
+MIT, copyright (c) 2025 BMad Code, LLC), with gratitude:
+- `techniques/design-methods.csv`, `techniques/solving-methods.csv`,
+  `techniques/innovation-frameworks.csv`, `techniques/story-types.csv`:
+  from `src/skills/bmad-cis-*/`.
+
+The severity-grid and derived-verdict pattern in `flows/devil-review.md` is
+informed by the design discussion published in the BMAD Test Architecture
+Enterprise module (criteria registry: fixed severities, verdicts derived
+from findings).
+
+"BMAD" is a trademark of its respective owner. Microwave Method is not
+affiliated with, endorsed by, or sponsored by the BMAD project. No BMAD
+trademark is used to name or brand this project.
+
+The persistent-wiki pattern draws on Andrej Karpathy's public `llm-wiki` gist
+(concept, not code).

microwave_method-0.1.0/PKG-INFO

@@ -0,0 +1,228 @@
+Metadata-Version: 2.5
+Name: microwave-method
+Version: 0.1.0
+Summary: An agent factory with a governed memory. One command drops it into your repo and hands you to your coding agent for a guided welcome.
+Project-URL: Homepage, https://github.com/microphage-create/microwave-method
+Author: Microphage
+License-Expression: MIT
+License-File: LICENSE
+License-File: NOTICE.md
+Keywords: agents,factory,governance,llm,wiki
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# Microwave Method
+
+**An agent factory with a governed memory. Heavy pass once per agent, light pass per feature. Context is cooked once and reheated at cache price.**
+
+*Methods tell you what to do. Microwave verifies it was done.*
+
+[![gates](https://github.com/microphage-create/microwave-method/actions/workflows/gates.yml/badge.svg)](https://github.com/microphage-create/microwave-method/actions/workflows/gates.yml)
+[![license: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+
+Microwave is a method, not a runtime. It ships as markdown flows, templates, and
+a handful of dependency-free scripts that any coding agent (Claude Code, Codex,
+Cursor, ...) can execute. It answers one question organizations keep failing at:
+**how do you let everyone create agents without ending up with a pile of agents
+nobody can map?**
+
+> [Gartner projects 150,000+ agents per Fortune 500 enterprise by 2028](https://cxotoday.com/editors-picks/how-to-manage-ai-agent-sprawl-a-six-step-framework-by-gartner/),
+> and prescribes exactly three things: rules for who creates agents, a central
+> inventory, and a lifecycle that retires redundant ones.
+> [94% of IT leaders say agent sprawl is already increasing complexity and risk; 12% have a central platform for it](https://www.outsystems.com/news/enterprise-ai-agent-report-2026/).
+> Microwave is that missing method, as open source you install in your repo,
+> not a SaaS you buy.
+
+## Why "Microwave"
+
+A microwave oven does not cook your dish from scratch. It excites the water
+molecules already present in it. That is the whole thesis: **your wiki atoms are
+the water molecules.** The expensive work (specifying an agent, curating what it
+learned) is done once and stored. Every subsequent feature just reheats context
+that already exists, at cache-read price, instead of rediscovering it from
+scratch on every session.
+
+## The middle you were missing
+
+- Heavyweight agent methods give you structure, at the cost of hours of ceremony
+  per object, producing documents nobody reads again.
+- Plan-mode-style planning gives you speed, and leaves nothing behind: no
+  durable artifact, no governance, no compounding.
+
+Microwave is the middle, **by construction, not by promise**, through two
+mechanical tests:
+
+1. **The consumption test.** A method step exists only if its artifact is
+   consumed by someone: the runtime, the registry, or the gatekeeper. A step whose
+   output nobody reads is deleted from the method.
+2. **The ceremony selector.** The depth of the creation flow is proportional to
+   the agent's blast radius (what it can read, write, spend, or touch), never to
+   the creator's mood. Read-only helper: fast path, minutes. Agent that writes,
+   spends, or touches production: full path, with a human gatekeeper before
+   activation.
+
+## How it works
+
+One recursive method, two planes, one registry.
+
+```
+            META PLANE (the factory)                 PRODUCT PLANE (the work)
+  ┌────────────────────────────────────┐    ┌────────────────────────────────────┐
+  │ PASS 1 - heavy, ONCE per agent     │    │ PASS 2 - light, EVERY feature      │
+  │ elicit → spec → anti-dup → build   │    │ intent → short story with          │
+  │ → embodiment → card in registry    │───▶│ verifiable done-criteria → build   │
+  │ → wiki seeded                      │    │ → traces written to the wiki       │
+  └────────────────────────────────────┘    └────────────────────────────────────┘
+                    ▲                                        │
+                    └──── governed promotion (gatekeeper) ◀──┘
+```
+
+- **The registry** is an index-first file: one line per agent, cards opened on
+  demand, readable by humans and by LLMs, consumed at runtime. A registry the
+  runtime reads cannot rot into dead documentation.
+- **The wiki** has one format and two scopes: `wiki/agents/` +
+  `wiki/adr/` (org-wide meta plane) and `wiki/projects/<name>/` (product
+  plane). Learnings are promoted upward only through the gatekeeper. Subsidiarity:
+  every atom lives at the lowest level that suffices.
+- **Recursion is governed.** Agents may create agents, but only through the
+  factory: the factory is the single entry point of creation. That is the
+  anti-sprawl invariant.
+
+## The memory is a wiki, not a RAG
+
+Most tools bolt memory on as a RAG: chop your docs into chunks, turn each chunk
+into an opaque vector, and at query time pull back "whatever looks similar". It
+half-works, and it rots invisibly: chunks are cut mid-thought, similarity
+retrieval is fuzzy so it misses the relevant and drags in noise, nobody can read
+a vector, and nothing is governed, so a stale or wrong chunk lives forever.
+
+Microwave's memory is a governed wiki of atoms (the Karpathy pattern). One atom
+is one idea, in plain markdown, tagged (type, id) and linked to the others.
+Three things follow:
+
+- **Readable both ways.** The same file serves the human, who reads and corrects
+  it, and the agent, which opens it on demand. One source of truth, not a doc set
+  for people plus a vector store for the machine. You can see, in plain text,
+  what your system knows.
+- **Targeted, not fuzzy.** An index holds one line per atom; the agent reads the
+  menu and opens the exact atom by name, instead of scooping the whole fridge
+  hoping to catch the right chunk. Deterministic where RAG is probabilistic. It
+  is the microwave again: excite the right molecule, do not reheat the whole pan.
+- **Governed and alive.** The gates refuse duplicates, doctrine distills instead
+  of piling up, and wikilinks turn atoms into a graph, a real body of knowledge.
+  This is the second brain of your whole workflow: a persistent external memory
+  your agents query, not a throwaway context reloaded blind every session.
+
+RAG is not wrong; it is the right tool for searching a huge unstructured corpus.
+But for the cumulative memory of a workflow, knowledge you want correct,
+structured and current, the atom wiki wins outright, and at scale the index can
+itself gain a retrieval layer. Right tool, right place.
+
+## Gates, not meetings
+
+A creation plan passes a series of **machine gates**, like a CI for agent
+creation. No committee, no ceremony:
+
+<!-- microwave:gates start -->
+<!-- generated by gates/docgen.py, do not edit by hand -->
+
+| Gate | Guarantee |
+|---|---|
+| `gate_antidup` | no unjustified overlap with the registry |
+| `gate_brief` | the 3-section brief is complete |
+| `gate_schema` | the agent card matches the template contract |
+| `gate_testable` | every done-criterion is tied to an executable check |
+| `gate_embodiment` | the agent has a body when it needs one |
+| `gate_slop` | durable artifacts do not read like slop |
+| `gate_wiki` | the wiki is linked, indexed, and its atoms carry their contract |
+| `gate_docs` | generated doc sections match their source |
+
+<!-- microwave:gates end -->
+
+This table is generated from the gates themselves by `gates/docgen.py` and
+cannot go stale: `gate_docs` fails the build if it drifts from the code
+(ADR-022). The slop bank (`slop/slop-rules.csv`) ships as a generic starter and
+takes your org's own rows; the mechanism does not change.
+
+Every gate rejects with an actionable message; you fix and re-run. Gates check
+form; substance is attacked by the **devil loop** (`flows/devil-loop.md`): a
+fresh agent session with no creation context reviews every full-path creation
+adversarially, round after round, until it finds nothing. **One single human
+point**: the gatekeeper, only on the full path, judging only cards with a
+clean devil report. On the fast path, green gates = `gates/activate.py`,
+nobody to wait for.
+
+Rules are enforced at the harness level, the way a coding agent is denied
+reading your `.env`: the system refuses, goodwill is not involved. Shipped as
+artifacts: example permission deny-rules (`harness/`), a pre-commit hook that
+runs the gates (`hooks/`), a CI workflow (`.github/workflows/gates.yml`) and
+`CODEOWNERS` on the protected space. One thing files cannot carry: enable
+branch protection on your host (the installer prints the command). Rules are
+inviolable in execution and amendable only through process
+(`flows/amend-rule.md`): a constitution, not a dogma.
+
+## Agents as apps
+
+An agent that can do damage is not done until it has a body (a read-only
+one may stay bodiless): pass 1 generates its desktop presence: an icon, a short name, a themed terminal profile, a launcher. These
+are **terminals dressed as apps, not apps replacing the terminal**: full
+terminal power, zero anonymity. With five sessions open in parallel you know
+who is who at a glance. One identity manifest, one adapter per OS
+(Windows Terminal + PowerShell, iTerm2/Terminal.app, freedesktop). The
+Windows adapter is the tested reference; **macOS and Linux adapters are
+experimental (written, not yet run on real machines): testing one takes five
+minutes and a report is a welcome first contribution.** See
+`docs/embodiment.md`.
+
+## Install (one line)
+
+```powershell
+# Windows (PowerShell 7+), from your repo:
+irm https://raw.githubusercontent.com/microphage-create/microwave-method/main/install/bootstrap.ps1 | iex
+```
+
+```bash
+# macOS / Linux, from your repo:
+curl -fsSL https://raw.githubusercontent.com/microphage-create/microwave-method/main/install/bootstrap.sh | bash
+```
+
+Prerequisites: `git` and Python 3.10+, nothing else (stdlib only). Per-OS
+walkthrough, troubleshooting and uninstall: `docs/install.md`. The generated
+reference (flows, gates, decisions) is `docs/reference.md`.
+
+This copies the flows, templates, technique banks, slop rules, gates,
+embodiment tooling, harness examples and hooks into your repo, wires the
+pre-commit hook, and drops the CI workflow and a CODEOWNERS placeholder. Finish the hardening by enabling
+branch protection (the installer prints the command).
+
+Then start where every real organization starts: with what already exists:
+open your coding agent and say *"run the Microwave adopt flow"*. It scans
+wherever your agents sleep (`.claude/`, prompt folders, repos), archives one
+inventory entry per artifact found, and writes the shopping list of
+migrations (`wiki/_archive/BACKLOG.md`). Migrating an archived agent through
+*"run the Microwave create-agent flow"* is the cheapest creation you will
+ever run: the entry is the elicitation input.
+
+## The economics, honestly
+
+- Reading context dominates agent cost: **76.1% of operation tokens** in
+  measured coding sessions (SWE-Pruner, arXiv:2601.16746).
+- Static context files alone are disputed: one study measured −28.6% runtime
+  (arXiv:2601.20404), two replications found no correctness effect
+  (arXiv:2602.11988, arXiv:2607.27250). We do not sell that number.
+- What holds: **continuously refined context beats static context** (33.0% vs
+  28.3% resolution, p<0.001, arXiv:2606.20512). It is the *governed upkeep* of
+  context that pays, not the file. That upkeep is precisely what this method
+  automates, and what your provider's prompt cache (0.1x read price) turns into
+  savings across sessions and agents.
+
+Measure your own numbers: the method instruments itself (see `docs/method.md`).
+
+## Status
+
+Extracted from a system operated daily since early 2026 by its author (45+
+active skills, a 4-generation governed rule corpus, 300+ knowledge atoms on a
+single product). Bootstrapped light, self-hosting as soon as the factory runs:
+Microwave's next module is created by Microwave.
+
+MIT. See `NOTICE.md` for attributions.

microwave_method-0.1.0/README.md

@@ -0,0 +1,215 @@
+# Microwave Method
+
+**An agent factory with a governed memory. Heavy pass once per agent, light pass per feature. Context is cooked once and reheated at cache price.**
+
+*Methods tell you what to do. Microwave verifies it was done.*
+
+[![gates](https://github.com/microphage-create/microwave-method/actions/workflows/gates.yml/badge.svg)](https://github.com/microphage-create/microwave-method/actions/workflows/gates.yml)
+[![license: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+
+Microwave is a method, not a runtime. It ships as markdown flows, templates, and
+a handful of dependency-free scripts that any coding agent (Claude Code, Codex,
+Cursor, ...) can execute. It answers one question organizations keep failing at:
+**how do you let everyone create agents without ending up with a pile of agents
+nobody can map?**
+
+> [Gartner projects 150,000+ agents per Fortune 500 enterprise by 2028](https://cxotoday.com/editors-picks/how-to-manage-ai-agent-sprawl-a-six-step-framework-by-gartner/),
+> and prescribes exactly three things: rules for who creates agents, a central
+> inventory, and a lifecycle that retires redundant ones.
+> [94% of IT leaders say agent sprawl is already increasing complexity and risk; 12% have a central platform for it](https://www.outsystems.com/news/enterprise-ai-agent-report-2026/).
+> Microwave is that missing method, as open source you install in your repo,
+> not a SaaS you buy.
+
+## Why "Microwave"
+
+A microwave oven does not cook your dish from scratch. It excites the water
+molecules already present in it. That is the whole thesis: **your wiki atoms are
+the water molecules.** The expensive work (specifying an agent, curating what it
+learned) is done once and stored. Every subsequent feature just reheats context
+that already exists, at cache-read price, instead of rediscovering it from
+scratch on every session.
+
+## The middle you were missing
+
+- Heavyweight agent methods give you structure, at the cost of hours of ceremony
+  per object, producing documents nobody reads again.
+- Plan-mode-style planning gives you speed, and leaves nothing behind: no
+  durable artifact, no governance, no compounding.
+
+Microwave is the middle, **by construction, not by promise**, through two
+mechanical tests:
+
+1. **The consumption test.** A method step exists only if its artifact is
+   consumed by someone: the runtime, the registry, or the gatekeeper. A step whose
+   output nobody reads is deleted from the method.
+2. **The ceremony selector.** The depth of the creation flow is proportional to
+   the agent's blast radius (what it can read, write, spend, or touch), never to
+   the creator's mood. Read-only helper: fast path, minutes. Agent that writes,
+   spends, or touches production: full path, with a human gatekeeper before
+   activation.
+
+## How it works
+
+One recursive method, two planes, one registry.
+
+```
+            META PLANE (the factory)                 PRODUCT PLANE (the work)
+  ┌────────────────────────────────────┐    ┌────────────────────────────────────┐
+  │ PASS 1 - heavy, ONCE per agent     │    │ PASS 2 - light, EVERY feature      │
+  │ elicit → spec → anti-dup → build   │    │ intent → short story with          │
+  │ → embodiment → card in registry    │───▶│ verifiable done-criteria → build   │
+  │ → wiki seeded                      │    │ → traces written to the wiki       │
+  └────────────────────────────────────┘    └────────────────────────────────────┘
+                    ▲                                        │
+                    └──── governed promotion (gatekeeper) ◀──┘
+```
+
+- **The registry** is an index-first file: one line per agent, cards opened on
+  demand, readable by humans and by LLMs, consumed at runtime. A registry the
+  runtime reads cannot rot into dead documentation.
+- **The wiki** has one format and two scopes: `wiki/agents/` +
+  `wiki/adr/` (org-wide meta plane) and `wiki/projects/<name>/` (product
+  plane). Learnings are promoted upward only through the gatekeeper. Subsidiarity:
+  every atom lives at the lowest level that suffices.
+- **Recursion is governed.** Agents may create agents, but only through the
+  factory: the factory is the single entry point of creation. That is the
+  anti-sprawl invariant.
+
+## The memory is a wiki, not a RAG
+
+Most tools bolt memory on as a RAG: chop your docs into chunks, turn each chunk
+into an opaque vector, and at query time pull back "whatever looks similar". It
+half-works, and it rots invisibly: chunks are cut mid-thought, similarity
+retrieval is fuzzy so it misses the relevant and drags in noise, nobody can read
+a vector, and nothing is governed, so a stale or wrong chunk lives forever.
+
+Microwave's memory is a governed wiki of atoms (the Karpathy pattern). One atom
+is one idea, in plain markdown, tagged (type, id) and linked to the others.
+Three things follow:
+
+- **Readable both ways.** The same file serves the human, who reads and corrects
+  it, and the agent, which opens it on demand. One source of truth, not a doc set
+  for people plus a vector store for the machine. You can see, in plain text,
+  what your system knows.
+- **Targeted, not fuzzy.** An index holds one line per atom; the agent reads the
+  menu and opens the exact atom by name, instead of scooping the whole fridge
+  hoping to catch the right chunk. Deterministic where RAG is probabilistic. It
+  is the microwave again: excite the right molecule, do not reheat the whole pan.
+- **Governed and alive.** The gates refuse duplicates, doctrine distills instead
+  of piling up, and wikilinks turn atoms into a graph, a real body of knowledge.
+  This is the second brain of your whole workflow: a persistent external memory
+  your agents query, not a throwaway context reloaded blind every session.
+
+RAG is not wrong; it is the right tool for searching a huge unstructured corpus.
+But for the cumulative memory of a workflow, knowledge you want correct,
+structured and current, the atom wiki wins outright, and at scale the index can
+itself gain a retrieval layer. Right tool, right place.
+
+## Gates, not meetings
+
+A creation plan passes a series of **machine gates**, like a CI for agent
+creation. No committee, no ceremony:
+
+<!-- microwave:gates start -->
+<!-- generated by gates/docgen.py, do not edit by hand -->
+
+| Gate | Guarantee |
+|---|---|
+| `gate_antidup` | no unjustified overlap with the registry |
+| `gate_brief` | the 3-section brief is complete |
+| `gate_schema` | the agent card matches the template contract |
+| `gate_testable` | every done-criterion is tied to an executable check |
+| `gate_embodiment` | the agent has a body when it needs one |
+| `gate_slop` | durable artifacts do not read like slop |
+| `gate_wiki` | the wiki is linked, indexed, and its atoms carry their contract |
+| `gate_docs` | generated doc sections match their source |
+
+<!-- microwave:gates end -->
+
+This table is generated from the gates themselves by `gates/docgen.py` and
+cannot go stale: `gate_docs` fails the build if it drifts from the code
+(ADR-022). The slop bank (`slop/slop-rules.csv`) ships as a generic starter and
+takes your org's own rows; the mechanism does not change.
+
+Every gate rejects with an actionable message; you fix and re-run. Gates check
+form; substance is attacked by the **devil loop** (`flows/devil-loop.md`): a
+fresh agent session with no creation context reviews every full-path creation
+adversarially, round after round, until it finds nothing. **One single human
+point**: the gatekeeper, only on the full path, judging only cards with a
+clean devil report. On the fast path, green gates = `gates/activate.py`,
+nobody to wait for.
+
+Rules are enforced at the harness level, the way a coding agent is denied
+reading your `.env`: the system refuses, goodwill is not involved. Shipped as
+artifacts: example permission deny-rules (`harness/`), a pre-commit hook that
+runs the gates (`hooks/`), a CI workflow (`.github/workflows/gates.yml`) and
+`CODEOWNERS` on the protected space. One thing files cannot carry: enable
+branch protection on your host (the installer prints the command). Rules are
+inviolable in execution and amendable only through process
+(`flows/amend-rule.md`): a constitution, not a dogma.
+
+## Agents as apps
+
+An agent that can do damage is not done until it has a body (a read-only
+one may stay bodiless): pass 1 generates its desktop presence: an icon, a short name, a themed terminal profile, a launcher. These
+are **terminals dressed as apps, not apps replacing the terminal**: full
+terminal power, zero anonymity. With five sessions open in parallel you know
+who is who at a glance. One identity manifest, one adapter per OS
+(Windows Terminal + PowerShell, iTerm2/Terminal.app, freedesktop). The
+Windows adapter is the tested reference; **macOS and Linux adapters are
+experimental (written, not yet run on real machines): testing one takes five
+minutes and a report is a welcome first contribution.** See
+`docs/embodiment.md`.
+
+## Install (one line)
+
+```powershell
+# Windows (PowerShell 7+), from your repo:
+irm https://raw.githubusercontent.com/microphage-create/microwave-method/main/install/bootstrap.ps1 | iex
+```
+
+```bash
+# macOS / Linux, from your repo:
+curl -fsSL https://raw.githubusercontent.com/microphage-create/microwave-method/main/install/bootstrap.sh | bash
+```
+
+Prerequisites: `git` and Python 3.10+, nothing else (stdlib only). Per-OS
+walkthrough, troubleshooting and uninstall: `docs/install.md`. The generated
+reference (flows, gates, decisions) is `docs/reference.md`.
+
+This copies the flows, templates, technique banks, slop rules, gates,
+embodiment tooling, harness examples and hooks into your repo, wires the
+pre-commit hook, and drops the CI workflow and a CODEOWNERS placeholder. Finish the hardening by enabling
+branch protection (the installer prints the command).
+
+Then start where every real organization starts: with what already exists:
+open your coding agent and say *"run the Microwave adopt flow"*. It scans
+wherever your agents sleep (`.claude/`, prompt folders, repos), archives one
+inventory entry per artifact found, and writes the shopping list of
+migrations (`wiki/_archive/BACKLOG.md`). Migrating an archived agent through
+*"run the Microwave create-agent flow"* is the cheapest creation you will
+ever run: the entry is the elicitation input.
+
+## The economics, honestly
+
+- Reading context dominates agent cost: **76.1% of operation tokens** in
+  measured coding sessions (SWE-Pruner, arXiv:2601.16746).
+- Static context files alone are disputed: one study measured −28.6% runtime
+  (arXiv:2601.20404), two replications found no correctness effect
+  (arXiv:2602.11988, arXiv:2607.27250). We do not sell that number.
+- What holds: **continuously refined context beats static context** (33.0% vs
+  28.3% resolution, p<0.001, arXiv:2606.20512). It is the *governed upkeep* of
+  context that pays, not the file. That upkeep is precisely what this method
+  automates, and what your provider's prompt cache (0.1x read price) turns into
+  savings across sessions and agents.
+
+Measure your own numbers: the method instruments itself (see `docs/method.md`).
+
+## Status
+
+Extracted from a system operated daily since early 2026 by its author (45+
+active skills, a 4-generation governed rule corpus, 300+ knowledge atoms on a
+single product). Bootstrapped light, self-hosting as soon as the factory runs:
+Microwave's next module is created by Microwave.
+
+MIT. See `NOTICE.md` for attributions.

microwave_method-0.1.0/SECURITY.md

@@ -0,0 +1,28 @@
+# Security policy
+
+## Reporting a vulnerability
+
+Use GitHub private vulnerability reporting on this repository (Security tab
+> "Report a vulnerability"). Please do not open public issues for
+exploitable findings. You will get an acknowledgment within 72 hours.
+
+## Scope
+
+The installers (`install/`), the git hook (`hooks/`), the gates (`gates/`)
+and the embodiment adapters (`embodiment/`) run on contributor machines:
+anything that lets a crafted agent card, wiki atom, or CSV rule row execute
+unintended code or write outside the repository is in scope. The YAML-subset
+parser (`gates/_lib.py`) processes untrusted card content and is in scope.
+
+## Hardening notes for users
+
+- The one-line installers clone the `main` branch. For a reproducible,
+  auditable install, clone a tagged release and run `install/install.sh`
+  (or `.ps1`) from it instead of piping the bootstrap.
+- `embodiment.launch` is validated against shell metacharacters by
+  `gate_schema` and re-validated by `embody.py`; adapters escape identity
+  strings anyway (defense in depth).
+
+## Supported versions
+
+Only the latest release and `main` are supported.