@amoree-code/ocean 0.0.0-stage → 1.1.0

package/templates/workspace/charter/policies/contracts/task.md

@@ -0,0 +1,189 @@
+# Task record schema
+
+The structural contract for `~/ocean/04-projects/<project>/tasks/<ID>/task.md`. One
+file per durable task. **The project owns its work**, and that record is the
+authoritative one. `task.md` is the **only** mandatory file in a task; everything
+else is an artifact created on demand (see §4).
+
+There is no global task namespace. `~/ocean/tasks/` held redirect pointers for one
+release and has been deleted; an id resolves directly at `04-projects/<project>/tasks/<ID>/`
+(`ocean-paths` was the resolver for this in an earlier CLI generation — it was
+consolidated away and is not a real command anymore). If two projects ever claim the
+same id, that is a conflict to resolve by hand, not to merge.
+
+`ocean memory doctor` does not validate this — it owns the memory store. This schema is
+the contract; the rule that enforces it in practice is
+`charter/policies/task.md` (`ocean policy task`).
+
+**Workspace paths are the live layout, not a moving target.** The relocation this
+section used to describe (several private roots migrated one reversible slice at a
+time via an `ocean-paths` resolver) is finished; that tool was consolidated away and
+is not a real command anymore. There is no `work` root — tasks and context live
+directly under each project, so `04-projects/<project>/tasks/<ID>/` is the lookup for a
+durable record. If a root is ever found present in two different layouts at once,
+that is a conflict to resolve by hand — never merge, copy, or pick a side
+automatically.
+
+---
+
+## 1. Identity
+
+```
+<SCOPE>-<NNN>
+```
+
+`SCOPE` is short, uppercase, and stable: a project key from
+`04-projects/registry.md` (`RCCM`, `RIYADA`, `HARMONY`), `OCEAN` for work on this
+system, or `OPS` for machine/workspace work with no project. `NNN` is a zero-padded
+counter within the scope, never reused.
+
+The ID is the task's name everywhere — index, session records, commit messages, chat.
+It never changes, including after the task is archived.
+
+## 2. Frontmatter
+
+```yaml
+---
+id: OCEAN-002 # required · matches the directory name
+title: <one line> # required · what the task is, not how
+state: active # required · see §3
+project: ocean # required · registry name, or `-` for none
+opened: 2026-08-31 # required · YYYY-MM-DD
+updated: 2026-08-31 # required · YYYY-MM-DD, bumped whenever the file changes
+artifacts: [decisions.md] # required · [] when task.md is the whole record
+
+class: medium # optional · small | medium | large — how much reasoning the work needs
+expected_context: small # optional · small | medium | large — how much context it should take
+---
+```
+
+`class` and `expected_context` are **durable classifications of the task**, and the only
+routing-relevant fields a task carries. `class` is what the work is: `small` is a change
+whose shape is already known, `medium` is ordinary implementation and debugging, `large` is
+architecture, security, an ambiguous requirement or a migration. `expected_context` is a
+prediction, used to notice when a task's real context runs far past what its shape implied.
+
+Neither is a limit, and neither is enforced. **Runtime decisions do not belong here** — the
+model and effort actually used, which memory and knowledge were retrieved, which
+capabilities were exposed, whether a graph was consulted, and what the session did at the
+end are all properties of one run rather than of the task, and are recorded in runtime
+receipts. A task that accumulated them would become a log of every attempt at it.
+
+`claimed_by`, `claimed_at` and `claimed_paths` are **optional and transient**: they say a
+session is working on the task right now (T-270). `claimed_at` is an ISO-8601 UTC timestamp;
+`claimed_paths` is an inline list (`[kernel, docs]`). A claim goes stale after 2 hours and is
+removed by `ocean tasks release` — it is not part of the task's lasting description. Rules
+and commands: `ocean policy task`, "Claims".
+
+`artifacts` lists what actually exists beside `task.md`, and nothing more. It is a
+manifest, not a plan: a name appears here the moment the file is written and never
+before. An empty list is the normal, healthy value.
+
+`project: -` is legitimate. A task does not need a project.
+
+## 3. States
+
+```
+todo ──▶ active ──▶ done ──▶ (archive/)
+          │  ▲
+          │  └──── paused ──┐  deliberately set aside; resumable by choice
+          ├──────▶ blocked ─┤  cannot proceed; waiting on something external
+          │        ▲        │
+          │        └────────┘
+          └──────▶ cancelled ──▶ (archive/)
+```
+
+| State       | Means                                                       | Leaves when                             |
+| ----------- | ----------------------------------------------------------- | --------------------------------------- |
+| `todo`      | promoted to a durable task, not started                     | work begins → `active`                  |
+| `active`    | being worked now                                            | paused, blocked, finished, or abandoned |
+| `paused`    | set aside by choice, resumable                              | picked up again → `active`              |
+| `blocked`   | cannot proceed; the blocker is named in the body            | blocker clears → `active`               |
+| `done`      | finished **and** verified — the verification ran and passed | archived                                |
+| `cancelled` | abandoned; the reason is recorded in the body               | archived                                |
+
+**There is no `current` task and no stored pointer to one.** The active set is derived:
+every task whose `state: active`. More than one may be active at a time — that is the
+normal case, not an error. Which one a given moment concerns is resolved the same way
+the active _project_ is (cwd against the registry) or by asking. Nothing mutable is
+stored to answer it.
+
+`done` is a state; archiving is a location. A task stays under `tasks/` while it is
+still live context and moves to `archive/<ID>/` when it is not.
+
+## 4. Body
+
+Recovery fields first — they are what a cold session reads. This is the checkpoint
+mechanism: for most tasks `task.md` **is** the checkpoint, and no separate
+`checkpoint.md` exists.
+
+```markdown
+## Objective
+
+<what done looks like from outside, one or two lines>
+
+## Definition of done
+
+<the observable condition that proves it works>
+
+## Next action
+
+<the single next thing to do — concrete enough to start cold>
+
+## Verification
+
+<the command that proves the work, and its last actual result>
+
+## Blockers
+
+<none, or the specific thing and who or what can clear it>
+
+## Log
+
+- 2026-08-31 — <what landed, with the file it touched>
+```
+
+Optional sections, added only when there is something to put in them: `## Scope`
+(explicit non-goals), `## Sessions` (only when the session records are hard to find).
+
+`## Log` is append-only and dated. It replaces the old `completed:` / `remaining:` /
+`last_successful_action:` fields: what landed is in the log, what remains is the next
+action, and the last successful action is the last log line.
+
+## 5. Artifacts
+
+An artifact is any file in the task directory other than `task.md`. It exists only
+because something needed to persist that `task.md` could not hold.
+
+**No artifact is scaffolded. Ever.** There is no fixed set, no template directory, and
+no empty placeholder. A task directory containing only `task.md` is complete.
+
+Two tests decide, in order:
+
+1. **Is it needed?** Would a future session — or the same session after compaction — be
+   materially worse off without this file? If the answer is "it might be nice", the
+   answer is no.
+2. **Does it belong to the task, or to the world?** Task-specific → the task directory.
+   Reusable beyond this task → `05-knowledge/<kind>/` instead, and the task links
+   to it. Durable fact about the user → `02-personal/`.
+
+Test 2 is the one that keeps task directories small. A finding worth keeping is almost
+always knowledge, not a task artifact.
+
+Naming is descriptive and lowercase (`research.md`, `decisions.md`, `checkpoint.md`,
+`api-notes.md`). The common shapes and their triggers are in
+`charter/policies/task.md` § Task artifacts; that list is a guide to recognising a trigger, never a
+checklist to satisfy.
+
+## 6. Completion
+
+When a task reaches `done`:
+
+1. The verification in `## Verification` has actually run, and its real output is recorded.
+2. Each artifact is resolved once — promoted to `05-knowledge/<kind>/` if reusable,
+   left with the task if not. Nothing is copied to both places.
+3. `state: done`, `updated:` bumped, the index line updated.
+4. The task moves to `archive/<ID>/` when it stops being live context.
+
+Steps 2–4 are bookkeeping: they belong to `task-scribe` and `memory-curator`, never to a
+reasoning model.

package/templates/workspace/charter/policies/git.md

@@ -0,0 +1,60 @@
+# Policy — git
+
+Load for anything beyond reading git state. The hard remote boundary is in the bootstrap
+because it must never depend on this file having been read.
+
+**Local and remote are separate trust boundaries. Maximum autonomy locally; explicit human
+approval remotely.**
+
+## Free, no asking
+
+`status` · `diff` · `log` · `show` · `branch` · `checkout` / `switch` · `add` · `commit` ·
+`stash` · `fetch` · `pull` · rebasing local unpushed work · reading anything with `gh`.
+
+## Publication is the last step, not the next one
+
+Keep substantial workspace, public-repo and private-repo restructuring local until the
+owner says the structure is settled and explicitly asks to publish. Do not propose `push`
+as the automatic next action while architecture or public/private boundaries are still
+moving.
+
+## When local work is done
+
+Stop and report. Do not push, and do not ask permission in advance of finishing:
+
+```
+The task is complete locally.
+
+Branch:  <name>
+Commit:  <sha> <subject>
+Tests:   <command> → <actual result>
+Changes: <n files — the notable ones>
+
+Ready to push and open/update the PR. Do you want me to push?
+```
+
+After an explicit yes: push → verify the remote ref → `gh pr list --head <branch>` →
+create the PR, or update the existing one. **Never open a second PR for a branch that
+already has one.** Never merge, never close, never force push, never rewrite history that
+has been pushed — each is the owner's call, asked for by name.
+
+Run verification locally to prove a fix, then delete temporary test files before staging.
+
+## Working in the kernel
+
+Code work happens in `~/ocean/kernel` itself, on its own branch — no worktrees (owner decision
+2026-10-16). `git fetch origin && git switch -c <branch> origin/main`, commit, push by name with
+approval, PR, owner merges. If the kernel tree already has uncommitted changes you did not make,
+they belong to another session: never stash, commit, discard or `git add -A` them — stage by
+path, or stop and say so. Before editing, claim the task and the dirs
+(`ocean policy task`, "Claims"); use path `kernel` if you will switch branches or commit — the
+checkout has one HEAD, and another session may be committing in it right now.
+`~/ocean` is not a Git repository for our purposes (see below), so task records are plain-file
+edits and need no branch.
+
+## Only the kernel uses Git
+
+Git exists only in `~/ocean/kernel` (its own remote): branch, push with explicit
+approval, PR, owner merges. Everything else, including `~/ocean`, is local files with no remote
+and no repository to think about — edit them, never commit or mention committing. Copying any
+private data into `kernel/` crosses a trust boundary and needs approval each time.

package/templates/workspace/charter/policies/graph.md

@@ -0,0 +1,47 @@
+# Policy — Graph Brain
+
+Load when navigating an unfamiliar or large tree. Graph Brain is an **accelerator, not a
+first step.**
+
+## Decide in this order
+
+1. **Can the cheap route answer it?** `ocean context`, the project index, the registry,
+   `grep`, a targeted read. Usually yes — then stop.
+2. **Is a fresh graph already built?** Query it.
+3. **Would building one materially help this task?** Only then build it.
+
+A one-line fix, a config change, an obvious bug or a file you already know needs no graph.
+Reading the file is faster.
+
+## Two graphs, never merged
+
+| Ask | Graph | Root |
+|---|---|---|
+| where is X recorded · what did we decide · what is still open | global brain | `~/ocean` |
+| how does this code work · what calls it · what breaks if I change it | project graph | the project repo |
+| what is true about the owner | neither — `memory/MEMORY.md` | |
+
+```bash
+graphify query "<question>"   graphify path "<A>" "<B>"   graphify explain "<X>"
+cd <root> && graphify update .        # --force after deletions
+```
+
+- **`--code-only` is mandatory** on every client and public code repository.
+- **Never pass `--no-gitignore`** — it drags worktrees and `runtime/` into the graph.
+- **Never merge the two graphs, and never `--global`.** The private graph carries personal
+  memory and is `publishable: false`.
+- **Never set `GEMINI_API_KEY` / `GOOGLE_API_KEY`.** With a key set, extraction routes to
+  Google, which on the private root would ship memory off the machine. There is no key
+  today; keep it that way.
+
+## What a graph is and is not
+
+**Graph explains. Files decide. Tests prove.** It tells you where to look; open the real
+file before changing anything, and prove the change with tests. Never quote a graph node as
+evidence — it is a summary from extraction time and goes stale the moment a file changes.
+
+Derived, never authoritative: rebuilt on demand, gitignored, never edited, never committed,
+never published. It may suggest a relevant skill, capability or record, but the real record
+must still be read and the task's approval gates still apply.
+
+Detail: `05-knowledge/architecture/ocean-graph-brain.md`.

package/templates/workspace/charter/policies/knowledge.md

@@ -0,0 +1,33 @@
+# Policy — knowledge
+
+Load when recording or retrieving what past work taught.
+
+**Knowledge answers: what did work teach us that saves effort next time.** Lifespan: until
+superseded. `~/ocean/05-knowledge/<kind>/`.
+
+Knowledge exists to **cut tokens**: retrieving one compact entry beats re-reading old files
+and re-deriving what was already established.
+
+## Kinds
+
+`task-results/` · `technical-solutions/` · `decisions/` · `architecture/` · `research/` ·
+`discoveries/` · `failures/`
+
+## Before investigating
+
+Search `knowledge/` **before** investigating from scratch. **Check `decisions/` before
+proposing something that contradicts a past decision** — that is the section's whole
+purpose. `knowledge/README.md` is the index.
+
+## Writing
+
+Small and factual. An entry that has to be skimmed has failed. No transcripts, no
+narration. Mark verification honestly: `verified` (we ran it) · `inferred` · `unverified` ·
+`outdated`. A guess recorded as verified is worse than no entry.
+
+## Deduplicate
+
+Do not store the same content in a session record, a task, knowledge, memory and the
+daily log. **One authoritative artifact, plus references.** A decision is stored once; the
+task references it, the session references it, and the daily log records only that the
+decision was made.

package/templates/workspace/charter/policies/lifecycle.md

@@ -0,0 +1,119 @@
+# Policy — the context lifecycle
+
+Load when deciding whether this session should keep going.
+
+```
+WORK → PERSIST DURABLE STATE → DETECT BOUNDARY → CHECKPOINT
+     → DISCARD LOW-VALUE WORKING CONTEXT → RECONSTRUCT CHEAPLY → CONTINUE
+```
+
+**Persistent intelligence without persistent context.** Durable state lives on disk; the
+working context is disposable. A long-lived session is not the execution model — it is the
+thing measurement found expensive.
+
+## Why
+
+Measured over 53 sessions: per-turn context grew roughly linearly and never fell, no
+session ever checkpointed and restarted, and cached re-reads were 57% of weighted spend.
+The always-loaded prompt is 8% of where a long session ends up. Session length is the
+cost.
+
+## The decision is a command, not a judgement call
+
+```bash
+ocean lifecycle                     # continue · checkpoint · compact · fresh · handoff
+ocean lifecycle --task <ID>       # against one record
+ocean lifecycle --json              # the same verdict, with every signal behind it
+```
+
+Deterministic, no model, and it explains itself. Evidence it takes from the records and
+from the client's own transcript: task state, verification, whether the record
+reconstructs cold, an open handoff, turn count, per-turn growth, large raw tool results.
+
+**No single threshold decides anything.** Two independent cost signals are required
+before context is called expensive, and it is never discarded for being large.
+
+## What it cannot know, state explicitly
+
+Nothing on disk knows whether the reasoning in flight still needs this transcript, whether
+your next request starts a different workstream, or whether the next step is heavy
+disposable investigation. Those are flags, and the default is conservative:
+
+| | |
+|---|---|
+| `--resolved` | nothing in flight depends on the current context |
+| `--complete` | the task's work is done |
+| `--transition <ID>` | the next request starts that other task |
+| `--exploration` | the next step is heavy disposable investigation |
+| `--milestone` · `--verification passed` | durable progress the record does not carry |
+
+Without `--resolved`, FRESH is never recommended. That is deliberate: a keyword rule
+guessing at intent would be trusted, and would be wrong.
+
+## The five decisions
+
+| | |
+|---|---|
+| **CONTINUE** | the same task is in flight and its context is still deciding the work |
+| **CHECKPOINT** | durable progress the record does not yet carry — persist it, keep going |
+| **COMPACT** | expensive, and the record cannot reconstruct it: compress rather than lose it |
+| **FRESH** | the task is finished, or a different one starts, or context is expensive and the record reconstructs cold |
+| **HANDOFF** | isolate heavy disposable investigation in a worker so its output never enters this context |
+
+COMPACT is the narrow case, not the habit: it needs expense *and* a record that cannot
+rebuild the work. Repeated compaction of the same context is the pattern this replaces.
+
+## Checkpointing
+
+```bash
+ocean tasks checkpoint <ID> --note "what landed, evidence, verification state" \
+                              --next "the one next action"
+```
+
+One writer, one record. It writes nothing when nothing changed, so a boundary that is not
+a boundary costs nothing.
+
+Carries: goal · status · milestone · decisions · changed files · evidence · verification
+state · blockers · next action · handoff state.
+
+Never: conversation history · raw logs · repeated explanation · superseded reasoning ·
+large tool output. Those are why the transcript is expensive; copying them into the record
+moves the cost instead of removing it.
+
+`log` is the one-line note. `checkpoint` also moves `## Next action`, which is what the
+next cold session actually reads — a record whose next action describes the previous
+boundary sends it to the wrong place.
+
+## Restarting is the owner's move
+
+No agent can clear or restart its own Claude Code session. `/clear` and `/effort` are
+typed by a person, `--effort` and `--continue` start a new process, and a hook receives the
+effort as read-only input. So FRESH prints the boundary and the resume command, and stops
+there. Claiming a restart happened would be worse than naming whose move it is.
+
+## Effort
+
+```bash
+ocean lifecycle effort --class <small|medium|large>
+ocean lifecycle effort --doctor        # what the client is configured to do, against policy
+```
+
+Effort follows the declared class — `small: low`, `medium: medium`, `large: high` — and is
+overridden **down** to `low` for mechanical work: grep, path lookup, task bookkeeping,
+deterministic commands, summaries, simple edits, routine tests, file routing.
+
+Raising it above the class default needs one of the recorded reasons in the model policy:
+architecture contract change, security-sensitive decision, large blast radius, ambiguous
+root cause, cross-system reasoning, or lower effort having demonstrably failed. A failure
+count is not a reason.
+
+The verified effort levers are client-owned: `claude --effort <level>` at launch,
+`/effort` typed in a session, and `CLAUDE_CODE_EFFORT_LEVEL` for one process. Ocean does
+not maintain a duplicate global `settings.json` effort setting.
+
+Per-task effort via a subagent's `effort:` frontmatter is **confirmed not to work**:
+re-probed 2026-09-05 from an ordinary session (no ultracode), a subagent declaring `high`
+recorded `medium` — its parent session's level, not the declared one. `model:` in the same
+frontmatter *is* honoured. The field has been removed from every agent file; a task's
+effort is whatever the session runs at, full stop — set it with `--effort` or
+`CLAUDE_CODE_EFFORT_LEVEL` before delegating. Full routing: `ocean policy models`.

package/templates/workspace/charter/policies/memory.md

@@ -0,0 +1,67 @@
+# Policy — memory
+
+Load when recording or retrieving a durable fact about the owner.
+
+**Memory answers: what is true about the owner and their world.** Lifespan: years.
+`~/ocean/02-personal/<section>/`.
+
+**The test when it is ambiguous:** would this still be true if they never wrote another line
+of code? Yes → memory. No → knowledge (`knowledge.md`).
+
+## One home
+
+Ocean is the only memory home (`05-knowledge/decisions/ocean-is-the-only-memory-home.md`).
+A client's own store (Claude Code, Codex, Gemini, Hermes, Antigravity, claude.ai) is a cache:
+promote a durable fact found there into Ocean; on conflict Ocean wins.
+
+## Sections
+
+`identity/` · `education/` · `career/` · `projects/` · `goals/` · `travel/` ·
+`preferences/` · `interests/`
+
+**One canonical home per fact.** A fact touching two sections lives in the one matching its
+meaning; the other links to it. Example: a course funded by a grant lives in `education/`,
+the move it requires in `travel/`, and neither repeats the other. No place or topic gets its
+own section just because it recurs.
+
+Project *implementation* detail stays in the repo at `.claude/memory/`, not here. Project
+memory lives in `04-projects/<project>/memory/` (indexed by its `MEMORY.md`); reference
+material lives in `04-projects/<project>/docs/` — never at the project root.
+
+## Retrieval — never load everything
+
+```
+task → identify the domain → read the index → open only what it names
+```
+
+`memory/MEMORY.md` is the index and the only file read by default. A React question needs
+`preferences/`. A question about that course needs `education/` and `travel/`. Neither
+needs the other. Reading the whole store is a mistake, not thoroughness.
+
+## Promotion
+
+```
+observation → candidate → classify → promote? → memory | knowledge | discard
+```
+
+Promote only what will still be true and useful in a month, is not already recorded, and is
+not derivable from the repo or git history. **Most observations promote to nothing** — that
+is correct, not a failure. Search before writing; update an existing entry rather than
+adding a near-duplicate. Never store secrets or temporary debugging state.
+
+If a fact fits no existing section, say so and propose one rather than scattering it into
+the nearest file.
+
+## Conflicts
+
+New information contradicting a record is never silently kept alongside it and never
+resolved by invention. Record both versions in `memory/CONFLICTS.md`, ask which is current,
+then update the owning file and remove the entry. Supersession by time — a job change, a
+finished certificate — is not a conflict: update it, and mark the old value `historical` if
+it still explains something.
+
+## Writing
+
+Delegate to `memory-curator`. It owns the section routing, the frontmatter schema and the
+conflict procedure. `ai-memory doctor` checks structure, duplicates, broken links and
+orphans.

package/templates/workspace/charter/policies/minimal-change.md

@@ -0,0 +1,43 @@
+# Policy — minimal change
+
+Load before writing new code, and before proposing a new file, dependency, or abstraction.
+
+## The sequence
+
+Answer these in order. Stop at the first one that resolves the task — do not keep going
+"just in case" a later question would also apply.
+
+```
+1. Does this actually need to exist?
+2. Does the repository already do this somewhere?
+3. Does the language or platform standard library solve it?
+4. Does an already-installed dependency solve it?
+5. Can an existing abstraction be extended safely, in place?
+6. What is the smallest correct patch?
+```
+
+Only after (6) does new code get written. Three similar lines beat a premature
+abstraction; a bug fix does not need surrounding cleanup; a one-shot script does not need
+a framework.
+
+## What this never cuts
+
+Never in the name of a smaller diff:
+
+- validation, authorization, or a security check the task actually requires
+- accessibility or data integrity
+- error handling for a case that can actually happen
+- backwards compatibility where something else still depends on the old shape
+- a test that establishes the change is correct
+
+The target is the smallest *necessary* implementation, not the smallest character count.
+Removing a guard to shrink a diff is not this policy — it is a defect this policy exists
+to prevent.
+
+## Dependencies specifically
+
+Before adding one, per `ocean policy stack`: what layer does it solve, do we already solve
+that layer, and what is the runtime/context cost of pulling it in versus writing the 10%
+actually needed. A dependency added to save twenty lines that then needs its own update
+cadence, its own failure mode, and its own security surface is not a smaller change — it
+is a deferred larger one.

package/templates/workspace/charter/policies/models.md

@@ -0,0 +1,57 @@
+# Policy — model and effort routing
+
+Load when choosing a model, choosing an effort level, or delegating.
+
+Routing happens **by delegation to model-pinned agents**, never by a gateway and never by
+asking the owner to switch. Recorded: `knowledge/decisions/no-model-routing-gateway.md`.
+
+## Tiers
+
+| Tier | What runs it | For |
+|---|---|---|
+| **0** | no model at all | path resolution, task lookup, project detection, parsing config, reading the registry, listing changed files, filtering a log, counting tokens |
+| **1** | cheapest capable model | classification, small summaries, log reduction, retrieval ranking, bookkeeping |
+| **2** | the normal model | implementation, UI, refactoring, ordinary debugging, tests, docs |
+| **3** | the strong reasoning model | architecture, security reasoning, deeply ambiguous problems, difficult cross-system debugging, large migrations |
+
+**Tier 0 first, always.** Before routing anything to a model, ask whether reliable
+deterministic code already answers it. `ocean context`, `ocean tasks`, `ocean observe`
+and `git` are Tier 0 and answer most of what a session needs to know. (`ocean-paths` was
+a Tier-0 tool in an earlier CLI generation; it was consolidated away and is not a real
+command anymore — resolve a task path directly at `04-projects/<project>/tasks/<ID>/`.)
+
+A strong model should make difficult decisions, not spend turns on grep, file reading and
+bookkeeping. **Administrative work never runs on the task's model**: memory and knowledge
+routing → `memory-curator`; summaries, checkpoints, logs, registry updates → `task-scribe`.
+
+## Effort follows the task's class
+
+The task declares `class`. Match effort to it: `small` → low, `medium` → normal,
+`large` → high. "Always think deeply" and "always be exhaustive" are not policies; they
+are a standing bill.
+
+## Escalation is evidence, not arithmetic
+
+Escalate to Tier 3 when there is a **reason**, and record it:
+
+- the failure is a genuine reasoning difficulty, not a typo or a wrong path;
+- the cause is in a different place from the symptom;
+- a race, a heisenbug, or state that changes under observation;
+- the blast radius is large, or the change is architecturally load-bearing;
+- two honest attempts failed **and the hypotheses ruled out are written down**.
+
+Two failures alone are not a reason. Two failures whose evidence points somewhere the
+current tier cannot reach is. Say one line — *"Two attempts failed; handing the root-cause
+hunt to `debugger`, ruled out: X, Y."* — then do it. A bare counter is a conservative
+floor, not the rule: never escalate past three failures without a written reason.
+
+## Delegation carries the task forward
+
+It never restarts it. Hand the agent the objective, what is already done, what was already
+ruled out, and where the record is. Never re-derive established work.
+
+```
+simple:   TASK → tier 2 → execute → verify → done
+complex:  TASK → architect (tier 3) → plan → tier 2 implements → test
+                → debugger (tier 3) only if verification is genuinely hard
+```

package/templates/workspace/charter/policies/privacy-terms.txt

@@ -0,0 +1,3 @@
+# Private terms, one per line: names, places, employers, project codenames.
+# `node scripts/check-template-purity.mjs --private <workspace>` rejects any of them in a shared file.
+# <term>

package/templates/workspace/charter/policies/response.md

@@ -0,0 +1,39 @@
+# Policy — response format
+
+Load when writing a substantial reply or a report.
+
+## Shape
+
+The smallest response shape is enough for simple messages; use the lightest complete
+format that answers the request. Use bold sparingly.
+
+## Formatting rules
+
+- Never claim a test passed, a fix worked, or a task is complete without a real check.
+  Say what is unverified.
+- Do not perform destructive actions without explicit approval: delete, force-push,
+  overwrite, drop, or equivalent irreversible work.
+- Do not mark owner approval or final verification on the user's behalf.
+- Keep reports concise. No filler, no restating the request. A report ends with exactly
+  one next step.
+- Use a markdown table for structured or comparative data instead of a bullet list.
+- Every code block carries a language tag (`ts`, `bash`, `sql`, `text`, `json`, ...); never
+  an untagged block.
+
+## Default tone
+
+Direct, warm, no preamble. Answer first, explain only if needed.
+
+## Prompt artifacts
+
+A requested reusable prompt comes back as one fenced `text` block, ready to paste.
+Explanatory prose stays outside the prompt block.
+
+## Cost
+
+Output and thinking are real cost. For execution work: result first; no preamble; no
+repeating the plan after every tool call; no background replay unless the user asks.
+
+For long-running work, update only on meaningful events: finding, defect, phase change,
+blocker, verification result, or changed strategy. Silence between meaningful events is
+correct.