opencode-wait-a-minute 0.0.0-stage → 1.1.0-rc.10

package/skills/tastemaker/SKILL.md

@@ -0,0 +1,8 @@
+---
+name: tastemaker
+description: Curates and applies design taste profiles to UI components.
+---
+
+# Tastemaker
+
+Curates and applies design taste profiles. Follow `references/tastemaker.md`.

package/skills/tastemaker/references/tastemaker.md

@@ -0,0 +1,14 @@
+# Tastemaker
+
+## Definition
+Tastemaker is the curatorial layer that ensures the UI isn't just "correct" (functional/accessible) but "refined" (high taste/premium feel).
+
+## Taste Profiles
+- **Minimalist**: Max whitespace, monochromatic with 1 accent, extreme typographic hierarchy.
+- **Enterprise**: Compact density, high utility, strict alignment, neutral palette.
+- **Playful**: Bold colors, softer radii, micro-animations, asymmetrical elements.
+
+## Application Process
+1. **Profile Selection**: Identify the desired taste profile for the project.
+2. **Audit**: Review current UI against profile characteristics.
+3. **Refine**: Adjust tokens (spacing, radii, color contrast) to align with the profile.

package/skills/tdd/SKILL.md

@@ -0,0 +1,38 @@
+---
+name: tdd
+description: Test-driven development. Use when the user wants to build features or fix bugs test-first, mentions "red-green-refactor", or wants integration tests.
+---
+
+# Test-Driven Development
+
+TDD is the red → green loop. This skill is the reference that makes that loop produce tests worth keeping: what a good test is, where tests go, the anti-patterns, and the rules of the loop. Every section applies on every cycle: consult them before and during the loop, not after.
+
+When exploring the codebase, read `GLOSSARY.md` (if it exists) so test names and interface vocabulary match the project's domain language, and respect ADRs in the area you're touching.
+
+## What a good test is
+
+Tests verify behavior through public interfaces, not implementation details. Code can change entirely; tests shouldn't. A good test reads like a specification: "user can checkout with valid cart" tells you exactly what capability exists, and it survives refactors because it doesn't care about internal structure.
+
+See [tests.md](tests.md) for examples and [mocking.md](mocking.md) for mocking guidelines.
+
+## Seams: where tests go
+
+A **seam** is the public boundary you test at: the interface where you observe behavior without reaching inside. Tests live at seams, never against internals.
+
+**Test only at pre-agreed seams.** Before writing any test, write down the seams under test and confirm them with the user. No test is written at an unconfirmed seam. You can't test everything, so agreeing the seams up front is how testing effort lands on the critical paths and complex logic instead of every edge case.
+
+Ask: "What's the public interface, and which seams should we test?" Give each proposed seam a one-line note on what it catches and what it misses.
+
+When the shape of that interface is itself in question (how deep the module is, where the seam belongs, what the interface should expose), call the Skill tool with "codebase-design" for the vocabulary. It is the shared source of the module, interface, depth, seam, adapter, leverage and locality terms, and it is a reference to consult, not a session to run.
+
+## Anti-patterns
+
+- **Implementation-coupled**: mocks internal collaborators, tests private methods, or verifies through a side channel (querying the database instead of using the interface). The tell: the test breaks when you refactor but behavior hasn't changed.
+- **Tautological**: the assertion recomputes the expected value the way the code does (`expect(add(a, b)).toBe(a + b)`, a snapshot derived by hand the same way, a constant asserted equal to itself), so it passes by construction and can never disagree with the code. Expected values must come from an independent source of truth: a known-good literal, a worked example, the spec.
+- **Horizontal slicing**: writing all tests first, then all implementation. Bulk tests verify _imagined_ behavior: you test the _shape_ of things rather than user-facing behavior, the tests go insensitive to real changes, and you commit to test structure before understanding the implementation. Work in **vertical slices** instead: one test → one implementation → repeat, each test a **tracer bullet** that responds to what the last cycle taught you.
+
+## Rules of the loop
+
+- **Red before green.** Write the failing test first, then only enough code to pass it. Don't anticipate future tests or add speculative features.
+- **One slice at a time.** One seam, one test, one minimal implementation per cycle.
+- **Refactoring is not part of the loop.** It belongs to the review stage (see the `code-review` skill), not the red → green implementation cycle.

package/skills/visual-review/SKILL.md

@@ -0,0 +1,103 @@
+---
+name: design-visual-frontend
+description: Design, build, redesign, or critically review distinctive frontend interfaces with strong composition, domain authenticity, responsive behavior, component coherence, and browser-verified visual quality. Use for websites, landing pages, login and form flows, dashboards, admin tools, product pages, portfolios, visual UI reviews, anti-template redesigns, or any request where frontend aesthetics and usability both matter.
+---
+
+# Design Visual Frontend
+
+Create frontend UI whose composition, content, and interaction fit the actual subject and user task. Do not treat visual quality as a list of fashionable effects. Diagnose the page structure first, implement from a compact design decision sheet, and verify rendered evidence across the required viewports.
+
+## Core Workflow
+
+1. Inspect the brief, existing project, assets, stack, and user-provided references.
+2. Classify the dominant surface using `references/surface-archetypes.md`.
+3. Write the compact decision sheet below before UI code.
+4. Read only the references routed by the task.
+5. Build from tokens and reusable component rules.
+6. When browser tooling is available, render the real page at the viewport matrix below and inspect the result visually.
+7. Apply every hard gate in `references/review-gates.md`; rebuild when a gate fails.
+8. Verify interaction, focus, errors, loading, reduced motion, and realistic content. When browser tooling is unavailable, inspect the implementation and give the user a concise manual visual-check list instead of claiming rendered verification.
+
+For reviews or diagnosis requests, stop after evidence-backed findings unless the user also asks for changes.
+
+## Compact Decision Sheet
+
+Keep this short. It is a decision artifact, not a design essay.
+
+1. `Surface`: archetype, primary user, and single primary job.
+2. `P1 / P2 / P3 / Action`: first read, supporting context, proof/detail, and next action.
+3. `Content truth`: real assets/data, user-provided content, public facts, or omitted claims.
+4. `Composition`: one mobile and one wide ASCII wireframe with named region roles.
+5. `System`: palette roles, type roles, spacing rhythm, radius, border/elevation, icon family.
+6. `Signature`: one subject-specific memorable device and why it belongs.
+7. `Cliche budget`: generic visual motifs used; one may be used without special justification, while additional motifs need distinct subject-specific jobs.
+8. `Failure risks`: the two most likely structural failures and how browser evidence will detect them.
+
+If the task is open-ended and a materially different composition could better serve the user, compare two directions. They must differ in protagonist, region roles, evidence, and interaction attitude. Do not generate directions that differ only in palette or decoration. Ask the user to choose only when the alternatives change the product relationship or brand position; otherwise select using brief evidence and proceed.
+
+## Reference Routing
+
+Always read:
+
+- `references/core-design.md`
+- `references/surface-archetypes.md`
+- `references/review-gates.md`
+
+Read when applicable:
+
+- Forms, controls, dashboards, navigation, UI copy, or state: `references/components-content.md`
+- Recognizable industry or institution: `references/domain-guidance.md`
+- Frontend implementation or browser verification: `references/frontend-implementation.md`
+
+Do not load every reference by default. Avoid re-reading a reference already read in the current task unless the design changes substantially.
+
+## Hard Composition Rules
+
+- The dominant user job determines the protagonist. A login page foregrounds authentication; a dashboard foregrounds state and actions; a product page foregrounds the product.
+- Every major desktop region must have a functional, evidentiary, narrative, or perceptual role.
+- A full-height divider is a strong visual object. Use it only when both sides are meaningful peers or interaction crosses the boundary. Do not divide marketing atmosphere from a small task panel.
+- On wide screens, fixed-width content must not become stranded inside expanding empty fields.
+- For compact task surfaces such as login, search, booking, and checkout, keep required inputs and the primary action visible at `390x844` when the task length permits.
+- Brand display type, illustrations, ambient motion, or product marks must not outweigh the active task on task-led screens.
+- Use one leading signature device. Grids, particles, giant rings, neon glow, pseudo-terminal text, glass, bento grids, huge type, noise, and decorative telemetry are generic motifs, not evidence of a subject.
+- Treat one generic motif as the default budget. Additional motifs must perform different, visible content or interaction jobs and must be supported by the brief; otherwise remove them.
+- Never use fake metrics, testimonials, logos, legal identifiers, certifications, contact details, screenshots, or operational data to make a design feel credible.
+
+## Visual Verification Matrix
+
+When browser automation or browser control is available, capture and inspect the actual rendered UI:
+
+| Viewport | Required use |
+| --- | --- |
+| `390x844` | Mobile order, task visibility, touch targets, wrapping |
+| `768x1024` | Tablet transition and intermediate breakpoints |
+| `1440x900` | Standard desktop composition |
+| `1920x1080` | Wide desktop space roles |
+| `2560x1080` | Required for full-bleed, split-screen, fixed-width, or cinematic layouts |
+
+The `2560x1080` check cannot be replaced by a `1440px` screenshot. Wide-screen failures often remain invisible at standard desktop sizes.
+
+Use browser automation or browser control already available in the environment. Prefer a real viewport API over browser window sizing. Inspect screenshots at 100% scale and interact with the page rather than judging HTML alone.
+
+Do not install a browser, automation framework, runtime, or audit dependency solely to satisfy this skill unless the user asks for it. If no browser capability is available, state that rendered visual verification was not performed and hand the viewport matrix to the user for manual inspection.
+
+## Implementation Contract
+
+- Preserve the existing stack and local patterns when present.
+- Encode choices as tokens or reusable classes/components.
+- Use one icon family and accessible controls.
+- Provide real states: default, hover, focus, active, disabled, loading, error, empty, permission, or offline where relevant.
+- Keep visible copy inside the product's world. Put implementation notes in comments or delivery notes.
+- Respect reduced motion and avoid expensive continuous effects.
+- Do not substitute static linting, source inspection, or an accessibility checklist for visual browser evidence.
+
+## Completion Standard
+
+Do not declare completion when any hard gate fails. Do not average severe problems into a passing score. The weakest critical dimension controls readiness.
+
+Report:
+
+- what was built or reviewed;
+- which viewports and interactions were verified, or which require manual inspection because browser tooling was unavailable;
+- the weakest remaining dimension and its visible evidence;
+- any limitation that could not be tested.

package/skills/visual-review/references/review-gates.md

@@ -0,0 +1,42 @@
+# Review Gates
+
+Apply these gates to browser evidence when browser tooling is available. They are non-compensating: one failed critical gate means the design is not ready, regardless of strengths elsewhere. When browser tooling is unavailable, use the gates to identify implementation risks, clearly label them as unverified, and hand them to the user for manual visual inspection.
+
+## Gate A: Five-Second Clarity
+
+At each required viewport, identify:
+
+- what the surface is;
+- who or what it belongs to;
+- the primary subject/job;
+- the next action or continuation.
+
+Fail when decoration, a logo, a giant headline, or empty space delays the answer on a task, command, inspection, or conversion surface.
+
+## Gate B: Protagonist and Action
+
+The protagonist must match the surface archetype. The primary action must read as part of the same visual event.
+
+Task-led hard checks:
+
+- short tasks show required inputs and primary action at `390x844`;
+- the task remains the strongest working object at desktop and wide desktop;
+- brand or atmosphere does not receive more visual weight than the task.
+
+## Gate C: Spatial Completion
+
+Name the role of every major region at `1440`, `1920`, and `2560` when applicable.
+
+Fail when:
+
+- a fixed panel is surrounded by expanding unused fields;
+- cropping the outer 25% removes no meaningful context;
+- a full-height divider becomes the strongest vertical object without representing real peer regions;
+- large gutters have no functional, evidentiary, narrative, or perceptual consequence.
+
+## Gate D: Cliche Budget and Authenticity
+
+Count generic motifs: grid, particles, giant ring, neon glow, pseudo-terminal, glass, noise, bento, huge headline, decorative telemetry.
+
+- `0-1`: acceptable when coherent with the surface archetype.
+- `2+`: fail, regardless of aesthetic execution.

package/skills/visual-review/references/surface-archetypes.md

@@ -0,0 +1,37 @@
+# Surface Archetypes
+
+Choose the dominant archetype from the user's primary job. Mixed pages may contain secondary archetypes, but the first viewport needs one leader.
+
+## Task-Led
+
+Examples: login, signup, checkout, booking, search, upload, application, submission, recovery.
+
+Protagonist: the task, its context, and current state.
+
+Required regions:
+
+- inputs, selectors, or provider actions;
+- selected account, organization, product, appointment, or target when relevant;
+- primary action and recovery path;
+- error, denied, locked, loading, success, and retry states as appropriate;
+- support, policy, device, session, deadline, or consequence context when useful.
+
+## Command-Led
+
+Examples: dashboards, admin tools, monitors, editors, operational consoles.
+
+Protagonist: current state plus available action.
+
+Required regions: orientation, toolbar, filters, status, data/table/chart, selection, detail, feedback.
+
+## Inspection-Led
+
+Examples: product details, report preview, documentation, article, portfolio item, profile, invoice.
+
+Protagonist: the entity, its data, and its story.
+
+## Conversion-Led
+
+Examples: landing pages, product overview, services page, marketing home.
+
+Protagonist: the value proposition and the call to action.

package/skills/wizard/SKILL.md

@@ -0,0 +1,44 @@
+---
+name: wizard
+description: Generate an interactive bash wizard that walks a human through steps only they can perform. Use when provisioning infrastructure, setting up credentials or CI secrets, walking an unfamiliar third-party dashboard, or running a one-off migration or cutover. Don't invoke this for steps the agent can perform itself.
+---
+
+# Wizard
+
+A **wizard** is a bash script that walks a human, step by step, through a manual procedure that's tedious to do by hand and tedious to re-explain to an AI every time. It opens each URL, says exactly what to click and copy, captures the values, writes them where they belong (`.env`, GitHub secrets), confirms at every stage, and shows how many stages are left. It might configure third-party services, run a one-off migration, or move the project from one state to another.
+
+The delightful UX is already solved by [template.sh](template.sh): stage-by-stage progress, confirmation gates, cross-platform URL opening (including WSL), hidden secret entry, idempotent `.env` upserts, `gh secret`/`gh variable` writes, and a closing summary. **Your job is only to scope the procedure and author its stages.** The library above the `STAGES` marker is identical in every wizard; that consistency is the point: never hand-edit it.
+
+A wizard is ephemeral by default: built for one run, saved to a scratch or `scripts/` path, deleted when the job's done. Commit it only when the user wants a repeatable setup path that should live in the repo.
+
+## Process
+
+### 1. Scope the procedure
+
+Work out every manual step the human must take and every value that gets captured along the way. Read the repo first, don't ask cold:
+
+- For setup: `.env`, `.env.example`, `.env.*`, `README`, `docker-compose*`, framework config, and `.github/workflows/*` (every `secrets.*` / `vars.*` reference is a value the wizard must produce).
+- For a migration or transition: the current state, the target state, and the irreversible actions between them.
+
+Then show the user the ordered list of stages and the values each produces, and confirm: they may add, drop, or reorder.
+
+**Done when:** every stage is named in order, and for each captured value you know (a) where the human gets it, (b) where it's written (`.env`, a GitHub secret, both, or nowhere; some stages are pure actions), and (c) whether it's secret (hidden entry) or public.
+
+### 2. Map each stage's journey
+
+For each stage, write the precise path a human follows: which URL to open, what to do there, where a value is shown, which variable it fills: e.g. "Dashboard → Developers → API keys → Reveal test key → copy". Where you don't actually know the current UI or the exact command, say so and ask the user or check the docs: never invent steps that may not exist.
+
+**Done when:** every stage traces to concrete instructions a stranger could follow.
+
+### 3. Author the wizard
+
+Copy `template.sh` to the target path. Replace the example stage with one `stage` per step, in dependency order. Use the library helpers: `stage`, `say`/`step`, `open_url`, `ask`/`ask_secret`, `write_env`, `set_secret`/`set_var`, `pause`/`confirm`. Set `TOTAL_STAGES` to the number of stages you wrote.
+
+Hold the bar the template sets: open the URL before asking for its value, use `ask_secret` for anything secret, `write_env` every persisted value, `set_secret` only the values CI actually needs, and `confirm` before any irreversible action. Each `stage` clears the screen so only the current step is visible: keep a stage to one focused task so nothing the human needs scrolls away. Don't touch the library above the marker.
+
+### 4. Verify and hand off
+
+- `bash -n <script>`; run `shellcheck` if available.
+- `chmod +x <script>`.
+- Don't run it end-to-end yourself: it opens browsers and blocks on human input. Trace it statically instead: every value from step 1 is captured and lands where step 1 said, and every `set_secret` name exactly matches a `secrets.*` reference in CI.
+- Tell the user how to run it. If it's a repeatable setup path, commit it and link it from the README so the next person runs the script instead of asking an AI.

package/skills/writing-for-agents/SKILL.md

@@ -0,0 +1,81 @@
+---
+name: writing-for-agents
+description: Writing documents for agents. Use when creating or editing skills, or modifying AGENTS.md or CLAUDE.md.
+---
+
+Reference for writing any document an agent consumes: a skill, an `AGENTS.md` / `CLAUDE.md`, a doc reached by a pointer. The packaging differs; the writing does not: the same levers make each one predictable, since the agent takes the same _process_ every run rather than producing the same output.
+
+When the document you're writing is a skill, read [`SKILL-MECHANICS.md`](SKILL-MECHANICS.md) for frontmatter, invocation choice, and router skills.
+
+## Context pointers
+
+A **context pointer** is a reference held in the agent's context that names some out-of-context material and encodes the condition for reaching it. A skill's description is one; a line in `AGENTS.md` naming a doc is the same object. The pointer's _wording_, not its target, decides when the agent reaches the material, and how reliably. A must-have target behind a weakly worded pointer is a variance bug: sharpen the wording first, and inline the material only if sharpening fails.
+
+A pointer does two jobs: state what the material is, and list the **branches** that should trigger reaching it (a branch is a distinct case the document handles, so different runs take different paths through it). Every word of an always-loaded pointer costs on every turn, so it earns even harder pruning than the body:
+
+- **Front-load the leading word**: the pointer is where it does its triggering work.
+- **One trigger per branch.** Synonyms that rename a single branch are one branch written twice; collapse them and keep only genuinely distinct branches.
+- **Cut identity the body already carries.**
+
+## The two loads
+
+Every document and pointer you add spends one of two budgets:
+
+- **Context load** is the cost of always-loaded material on the agent's window: an `AGENTS.md` line, a skill description, anything sitting in context every turn, spending tokens and attention whether or not it fires.
+- **Cognitive load** is the cost on the human: which documents exist and when to reach for each. The human is the index. Not a cost to minimise: it is the price of human agency; spend it where human judgement matters, remove it where it does not.
+
+Material reached only through a pointer escapes context load at the price of the pointer's own line; material with no pointer at all rides entirely on cognitive load.
+
+## Information hierarchy
+
+A document is built from two content types: **steps** (the ordered actions the agent performs) and **reference** (definitions, rules, facts consulted on demand). The two mix freely: all steps (a recipe), all reference (a review's rules, this skill), or both. The core decision is where each piece sits on the **information hierarchy**, a ladder ranked by how immediately the agent needs the material:
+
+1. **In-file step** is the primary tier: what the agent does, in order.
+2. **In-file reference** is consulted on demand. Often a legitimately flat peer-set (every rule of a review on one rung), which is a fine arrangement, not a smell.
+3. **Disclosed reference** is pushed out into a separate file, reached by a context pointer, loaded only when the pointer fires. Spans a sibling file in the same folder through fully external reference that lives anywhere and any document can point at.
+
+Push too little down and the top bloats; push too much and you hide material the agent actually needs. That tension is the whole decision.
+
+**Progressive disclosure** is the move down the ladder (out of the main file and behind a pointer) so the top stays legible. Not primarily a token optimisation: it is how the hierarchy is protected. Branching is the cleanest disclosure test: inline what every branch needs, and push behind a pointer what only some branches reach. When a document has steps, in-file reference that should be disclosed buries them and turns attending to them into a coin-flip: a variance lever, not just a legibility one.
+
+**Co-location** is the within-file companion: where the ladder decides _how far down_ a piece sits, co-location decides _what sits beside it_ once there. Keep a concept's definition, rules, and caveats under one heading rather than scattered, so reading one part brings its neighbours with it. The test: the document should read like documentation written for the agent. Grouped material reads that way; scattered material does not. (Distinct from duplication: that repeats one meaning in two places; scattering fragments one meaning across many.)
+
+**Sprawl** is the failure mode here: a document simply too long, even when every line is live and unique. Attention thins across the excess, and every extra line is one more to keep relevant. The cure is the ladder: disclose reference behind pointers, and split by branch or sequence so each path carries only what it needs.
+
+## Steps and completion criteria
+
+Every step ends on a **completion criterion**, the condition that tells the agent the work is done. Two properties make it a lever:
+
+- **Clarity**: can the agent tell done from not-done? A vague bound ("understanding reached") invites **premature completion**: ending the step before it is genuinely done, attention slipping to _being done_. The visible steps still ahead (the **post-completion steps**) supply the pull; the criterion's clarity is the resistance. Defend in order: **sharpen the bound first** (local and cheap); only if it is irreducibly fuzzy _and_ you observe the rush, hide the later steps by splitting the sequence. Hiding only works across a real context boundary (a hand-off or a subagent dispatch; an inline call leaves the later steps in context and clears nothing).
+- **Demand**: how much it requires. "Every modified model accounted for" forces thorough work where "produce a change list" does not. Demand drives **legwork** (the digging the agent does within the work, latent in the wording rather than written as its own step), and it is not step-bound: "every rule applied" binds a body of flat reference just as "every step done" binds a sequence, which is how an all-reference document still carries an exhaustiveness bar.
+
+The strongest criteria are both checkable and exhaustive.
+
+## When to split
+
+Splitting one document into two spends one of the two loads, so split only when the cut earns it:
+
+- **By sequence**: split a run of steps where the post-completion steps tempt the agent to rush the one in front of it. Keeping them out of view drives more legwork on the current task. Beware the reverse: merging sequences exposes each step's later steps to what follows, inviting premature completion.
+- **By invocation**, skill-specific: see [`SKILL-MECHANICS.md`](SKILL-MECHANICS.md).
+
+## Leading words
+
+A **leading word** is a compact concept already living in the model's pretraining that the agent thinks with while running the document (_lesson_, _fog of war_, _tracer bullets_). Repeated as a token, never as a sentence, it accumulates a distributed definition and anchors a whole region of behaviour in the fewest tokens, by recruiting priors the model already holds. Coining your own works if you define it clearly, but a made-up word recruits no priors: you pay in definition tokens what a pretrained word gives free; reach for an existing word first.
+
+It anchors twice. In the body, _execution_: the agent reaches for the same behaviour every time the word appears, and inside flat reference it focuses attention on a class of thing to look for. In a pointer, _invocation_: when the same word lives in your prompts, your docs, and your codebase, the agent links that shared language to the material and reaches it more reliably.
+
+Hunt for opportunities to refactor with leading words. A triad spelled out at three sites, a pointer spending a sentence to gesture at one idea. Each is a passage begging to collapse into a single token:
+
+- "fast, deterministic, low-overhead" → _tight_ (a _tight_ loop).
+- "a loop you believe in" → _red_, turning a fuzzy gate into a binary observable state (the loop goes _red_ on the bug, or it doesn't).
+
+You win twice: fewer tokens, and a sharper hook for the agent to hang its thinking on. Assume every document is carrying restatements that leading words retire. Go find them.
+
+**Negation** is the failure mode beside this lever: steering by prohibition drags the forbidden behaviour into context and makes it _more_ available, not less. _Don't think of an elephant_, and the elephant is all there is; the negation is a weak modifier the strongly-activated concept overruns, so the ban half-reads as an instruction to do the thing. Prompt the **positive**: state the target behaviour ("write one-line comments") so the banned one is never spoken. A prohibition earns its place only as a hard guardrail you cannot phrase positively; even then, pair it with the positive target so attention lands on what to do.
+
+## Pruning
+
+- Keep each meaning in a **single source of truth**: one authoritative place, so changing the behaviour is a one-place edit. **Duplication** (the same meaning in more than one place) costs maintenance and tokens, and inflates a meaning's prominence on the ladder past its real rank. (The accidental inverse of a leading word, which repeats a token on purpose, never the meaning.)
+- The **environment** is a source of truth too (`package.json` scripts, config files, the directory layout, `--help` output), and a document that restates it is a **cache**: a copy of a lookup, earning its load only when the lookup is expensive. Cache what the agent cannot find by looking: the unwritten convention, the reason behind a choice, the gotcha no config confesses. Leave the one-file, one-command lookups to the environment, where they cannot go stale.
+- Check every line for **relevance**: does it still bear on what the document does? A line loses relevance by never bearing on the task (mere exposition, or a branch that should be disclosed) or by going stale as the behaviour or world it describes changes. Shorter documents are easier to keep relevant. Without a pruning discipline the default fate is **sediment**: stale layers that settle because adding feels safe and removing feels risky, until you must core down through them to find what is still live.
+- Hunt **no-ops** sentence by sentence: an instruction the model already obeys by default pays load to say nothing. The test (does it change behaviour versus the default?) is model-relative, not reader-relative: two people disagreeing about a no-op disagree about the default, and settle it by running the document, not by debate. When a sentence fails, delete the whole sentence rather than trim words from it. The test also grades leading words: a word too weak to beat the default (_be thorough_ when the agent is already thorough-ish) is a no-op, and the fix is a stronger word (_relentless_), not a different technique.

package/src/cognition/cognition-store.js

@@ -0,0 +1,251 @@
+/**
+ * Cognition Store — persistent runtime support for hypothesis-driven problem solving.
+ *
+ * Implementa spec: hypothesis-experiment-loop.
+ *
+ * Almacena hipótesis, experimentos y observaciones como append-only JSONL
+ * bajo `.wam/tasks/<taskId>/cognition/`. Permite continuar tras compaction
+ * sin re-intentar estrategias fallidas.
+ *
+ * Source of truth para datos cognitivos del task. Cualquier lectura/escritura
+ * de hipótesis, experimentos u observaciones debe pasar por este módulo.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+
+const COGNITION_DIR = "cognition";
+const FILES = {
+  hypotheses: "hypotheses.jsonl",
+  experiments: "experiments.jsonl",
+  observations: "observations.jsonl",
+};
+
+/** U1: never unlink cognition records. Archive via status append. */
+export const DELETION_POLICY = "soft-archive";
+
+// -- Status constants (single source of truth) --
+// Hypotheses lifecycle: PROPOSED → TESTING → SUPPORTED | REJECTED → ARCHIVED
+export const HYPOTHESIS_STATUS = Object.freeze({
+  PROPOSED: "proposed",
+  TESTING: "testing",
+  SUPPORTED: "supported",
+  REJECTED: "rejected",
+  ARCHIVED: "archived",
+});
+
+// Experiment lifecycle: proposed → completed | failed
+export const EXPERIMENT_STATUS = Object.freeze({
+  PROPOSED: "proposed",
+  COMPLETED: "completed",
+  FAILED: "failed",
+});
+
+export function migrateLegacyCognition(taskRoot, taskId) {
+  const legacyFile = path.join(taskRoot, ".wam", "tasks", taskId, "cognition.json");
+  if (!fs.existsSync(legacyFile)) return false;
+
+  const data = JSON.parse(fs.readFileSync(legacyFile, "utf-8"));
+  const dir = cognitionRoot(taskRoot, taskId);
+  ensureDir(dir);
+
+  if (data.hypotheses) {
+    data.hypotheses.forEach(h => appendLine(path.join(dir, FILES.hypotheses), h));
+  }
+  if (data.experiments) {
+    data.experiments.forEach(e => appendLine(path.join(dir, FILES.experiments), e));
+  }
+  if (data.observations) {
+    data.observations.forEach(o => appendLine(path.join(dir, FILES.observations), o));
+  }
+
+  fs.renameSync(legacyFile, legacyFile + ".migrated");
+  return true;
+}
+
+export function archiveHypothesis(taskRoot, taskId, hypothesisId, reason = "archived") {
+  const dir = cognitionRoot(taskRoot, taskId);
+  const file = path.join(dir, FILES.hypotheses);
+  appendLine(file, {
+    id: hypothesisId,
+    status: HYPOTHESIS_STATUS.ARCHIVED,
+    reason,
+    archivedAt: Date.now(),
+  });
+}
+
+export function hasRepetitiveFailure(taskRoot, taskId, { hypothesisId, actionDescription } = {}) {
+  const experiments = listExperiments(taskRoot, taskId);
+  return experiments.some(
+    (e) =>
+      e.hypothesisId === hypothesisId &&
+      e.actionDescription === actionDescription &&
+      (e.status === EXPERIMENT_STATUS.FAILED),
+  );
+}
+
+function cognitionRoot(taskRoot, taskId) {
+  return path.join(taskRoot, ".wam", "tasks", taskId, COGNITION_DIR);
+}
+
+function ensureDir(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+}
+
+function genId(prefix) {
+  return `${prefix}${Date.now().toString(36)}${Math.random().toString(36).slice(2, 6)}`;
+}
+
+function appendLine(filePath, obj) {
+  ensureDir(path.dirname(filePath));
+  const line = JSON.stringify({ ...obj, createdAt: obj.createdAt || Date.now() }) + "\n";
+  fs.appendFileSync(filePath, line, "utf-8");
+}
+
+function readAll(filePath) {
+  if (!fs.existsSync(filePath)) return [];
+  const seen = new Map();
+  fs.readFileSync(filePath, "utf-8")
+    .split("\n")
+    .filter(Boolean)
+    .map((l) => { try { return JSON.parse(l); } catch { return null; } })
+    .filter(Boolean)
+    .forEach((obj) => { if (obj.id) seen.set(obj.id, obj); });
+  return Array.from(seen.values());
+}
+
+// -- Hypotheses --
+
+export function createHypothesis(taskRoot, taskId, { statement, confidence = 0.5 }) {
+  const dir = cognitionRoot(taskRoot, taskId);
+  const file = path.join(dir, FILES.hypotheses);
+  const h = {
+    id: genId("H"),
+    statement,
+    confidence,
+    status: HYPOTHESIS_STATUS.PROPOSED,
+  };
+  appendLine(file, h);
+  return h;
+}
+
+export function listHypotheses(taskRoot, taskId) {
+  const file = path.join(cognitionRoot(taskRoot, taskId), FILES.hypotheses);
+  return readAll(file);
+}
+
+export function updateHypothesisStatus(taskRoot, taskId, id, status) {
+  const file = path.join(cognitionRoot(taskRoot, taskId), FILES.hypotheses);
+  if (!fs.existsSync(file)) return null;
+  const lines = readAll(file);
+  const target = lines.find((h) => h.id === id);
+  if (!target) return null;
+  appendLine(file, { ...target, status, updatedAt: Date.now() });
+  return { ...target, status, updatedAt: Date.now() };
+}
+
+export function getActiveHypotheses(taskRoot, taskId) {
+  return listHypotheses(taskRoot, taskId)
+    .filter((h) =>
+      h.status === HYPOTHESIS_STATUS.PROPOSED ||
+      h.status === HYPOTHESIS_STATUS.TESTING
+    );
+}
+
+// -- Experiments --
+
+export function createExperiment(taskRoot, taskId, { hypothesisId, actionDescription, risk = "SAFE", reversible = true, expectedObservation }) {
+  const dir = cognitionRoot(taskRoot, taskId);
+  const file = path.join(dir, FILES.experiments);
+  const e = {
+    id: genId("E"),
+    hypothesisId,
+    actionDescription,
+    risk,
+    reversible,
+    expectedObservation,
+    status: EXPERIMENT_STATUS.PROPOSED,
+  };
+  appendLine(file, e);
+  return e;
+}
+
+export function listExperiments(taskRoot, taskId) {
+  const file = path.join(cognitionRoot(taskRoot, taskId), FILES.experiments);
+  return readAll(file);
+}
+export function getExperiment(taskRoot, taskId, id) {
+  return listExperiments(taskRoot, taskId).find((e) => e.id === id) || null;
+}
+export function getHypothesis(taskRoot, taskId, id) {
+  return listHypotheses(taskRoot, taskId).find((h) => h.id === id) || null;
+}
+export function getObservation(taskRoot, taskId, id) {
+  return listObservations(taskRoot, taskId).find((o) => o.id === id) || null;
+}
+
+export function completeExperiment(taskRoot, taskId, id, { result = "ok" } = {}) {
+  return updateExperiment(taskRoot, taskId, id, { status: EXPERIMENT_STATUS.COMPLETED, result });
+}
+
+export function failExperiment(taskRoot, taskId, id, reason = "") {
+  return updateExperiment(taskRoot, taskId, id, { status: EXPERIMENT_STATUS.FAILED, reason });
+}
+
+function updateExperiment(taskRoot, taskId, id, patch) {
+  const file = path.join(cognitionRoot(taskRoot, taskId), FILES.experiments);
+  if (!fs.existsSync(file)) return null;
+  const lines = readAll(file);
+  const target = lines.find((e) => e.id === id);
+  if (!target) return null;
+  appendLine(file, { ...target, ...patch, updatedAt: Date.now() });
+  return { ...target, ...patch, updatedAt: Date.now() };
+}
+
+export function findRepeatedExperiment(taskRoot, taskId, { hypothesisId, actionDescription }) {
+  const all = listExperiments(taskRoot, taskId);
+  return all.filter((e) =>
+    e.hypothesisId === hypothesisId &&
+    e.actionDescription === actionDescription &&
+    (e.status === EXPERIMENT_STATUS.COMPLETED || e.status === EXPERIMENT_STATUS.FAILED)
+  );
+}
+
+// -- Observations --
+
+export function recordObservation(taskRoot, taskId, { experimentId, hypothesisId, result, facts = [], actual, unexpected, provenance }) {
+  const dir = cognitionRoot(taskRoot, taskId);
+  const file = path.join(dir, FILES.observations);
+  const o = { id: genId("O"), experimentId, hypothesisId, result, facts };
+  if (actual !== undefined) o.actual = actual;
+  if (unexpected !== undefined) o.unexpected = unexpected;
+  if (provenance !== undefined) o.provenance = provenance;
+  appendLine(file, o);
+  return o;
+}
+
+export function listObservations(taskRoot, taskId) {
+  const file = path.join(cognitionRoot(taskRoot, taskId), FILES.observations);
+  return readAll(file);
+}
+
+export function getObservationsForExperiment(taskRoot, taskId, experimentId) {
+  return listObservations(taskRoot, taskId).filter((o) => o.experimentId === experimentId);
+}
+
+// -- Compact state (for context packs) --
+
+export function buildCompactState(taskRoot, taskId) {
+  const hypotheses = listHypotheses(taskRoot, taskId);
+  return {
+    activeHypotheses: hypotheses.filter((h) =>
+      h.status === HYPOTHESIS_STATUS.PROPOSED ||
+      h.status === HYPOTHESIS_STATUS.TESTING
+    ),
+    supportedHypotheses: hypotheses.filter((h) => h.status === HYPOTHESIS_STATUS.SUPPORTED),
+    rejectedHypotheses: hypotheses.filter((h) => h.status === HYPOTHESIS_STATUS.REJECTED),
+    archivedHypotheses: hypotheses.filter((h) => h.status === HYPOTHESIS_STATUS.ARCHIVED),
+    recentExperiments: listExperiments(taskRoot, taskId).slice(-5),
+    recentObservations: listObservations(taskRoot, taskId).slice(-5),
+  };
+}