Add hotkeys, policy-compiler spec, seeded architecture-summary episode

(a) Canonical hotkeys committed at .obsidian/hotkeys.json:
    - Cmd+Shift+E → episode-promoter:promote-to-episode
    - Cmd+Shift+T → periodic-notes:open-daily-note (today's daily)
    - Cmd+Shift+G → obsidian-git:open-source-control-view (commit panel)
    The file is un-gitignored; users override via Obsidian's UI without
    breaking the canonical defaults for the next fresh checkout. The
    .gitignore now documents the `git update-index --skip-worktree`
    pattern for shared-vault contributors who want personal bindings.
    Companion vault/_meta/hotkeys.md documents the bindings and the
    rebind protocol.

(b) vault/spec/policy-compiler.md: the fourth worked spec, completing
    the Capability/Receipt/Guard/Policy core quad. Six normative
    claims (deterministic compilation, schema validation, fail-closed
    on compile errors, evaluator purity, two receipt classes for
    compile + eval). Three constraints from the guard-policy-fail-closed
    seed (policies are kernel-loaded artifacts, purity is replayability,
    compile + eval receipts kept orthogonal). Cites real arc paths from
    chio-policy/src/{compiler,validate,evaluate/{engine,matchers},
    models,lib}.rs and ties the producer-consumer relationship to
    guard-pipeline (the consumer of compiled evaluators).

(d) vault/episodes/chio-architecture-summary.md: a hand-seeded episode
    matching what `make kb-migrate-seeds` would produce against arc
    PR #599's seeds/graphiti/architecture-summary.json. Demonstrates
    the canonical post-migration shape: status: imported, typed
    authoritative_files frontmatter, summary as opening prose,
    editing_guidance as a `## Guidance` section, the HUMAN_EDIT_MARKER
    at the bottom. Running migrate-seeds.py later will overwrite the
    machine portion (preserving anything below the marker) and add a
    seed_content_hash for idempotency. Cross-linked from the four
    worked specs that reference this episode by graphiti-episode field.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: bb-connor

.gitignore

@@ -28,7 +28,9 @@ kb-engine/uv.lock
 .obsidian/cache
 .obsidian/graph.json
 .obsidian/app.json
-.obsidian/hotkeys.json
+# hotkeys.json IS committed (canonical default bindings — see vault/_meta/hotkeys.md);
+# users override locally in Obsidian's Hotkeys settings, which writes to this file.
+# Skip-worktree on conflict: `git update-index --skip-worktree .obsidian/hotkeys.json`
 
 # Themes are user-installed
 .obsidian/themes/

.obsidian/hotkeys.json

@@ -0,0 +1,11 @@
+{
+  "episode-promoter:promote-to-episode": [
+    { "modifiers": ["Mod", "Shift"], "key": "E" }
+  ],
+  "periodic-notes:open-daily-note": [
+    { "modifiers": ["Mod", "Shift"], "key": "T" }
+  ],
+  "obsidian-git:open-source-control-view": [
+    { "modifiers": ["Mod", "Shift"], "key": "G" }
+  ]
+}

vault/_meta/hotkeys.md

@@ -0,0 +1,46 @@
+---
+id: meta.hotkeys
+type: meta
+---
+
+# Canonical hotkeys
+
+Configured in [`.obsidian/hotkeys.json`](../../.obsidian/hotkeys.json) (committed, not gitignored). Obsidian's Settings → Hotkeys panel writes overrides to the same file; users can rebind freely without breaking the canonical defaults for the next fresh checkout.
+
+## Bindings
+
+| Combo | Command | Why |
+| ----- | ------- | --- |
+| `Cmd+Shift+E` | `episode-promoter:promote-to-episode` | The "What I learned" → episode flow is the highest-leverage daily action. Worth a top-row binding. |
+| `Cmd+Shift+T` | `periodic-notes:open-daily-note` | Open today's daily note. Combined with auto-creation from the [Periodic Notes plugin](../../.obsidian/plugins/periodic-notes/data.json), Cmd+Shift+T = "morning brief, now". |
+| `Cmd+Shift+G` | `obsidian-git:open-source-control-view` | Open the Git source control panel. Daily commit cadence is part of the vault's contract (auto-save every 60s, auto-pull every 30 min); Cmd+Shift+G is the deliberate "stage and commit now" gesture. |
+
+`Mod` resolves to `Cmd` on macOS and `Ctrl` on Windows/Linux. The bindings are cross-platform.
+
+## Adding more
+
+Edit `.obsidian/hotkeys.json` directly OR use Obsidian's Hotkeys settings UI. The file format is one entry per command:
+
+```json
+{
+  "<plugin-id>:<command-id>": [
+    { "modifiers": ["Mod", "Shift"], "key": "X" }
+  ]
+}
+```
+
+Modifier keys: `Mod`, `Ctrl`, `Shift`, `Alt`, `Meta`. Multiple bindings per command are allowed (the value is an array).
+
+## Conflict policy
+
+If a contributor wants a different default, they have three options:
+
+1. **Override in Obsidian's UI.** This writes to `.obsidian/hotkeys.json` and shows up in `git status`. Don't commit unless the team has agreed to flip the canonical default.
+2. **Local-only opt-out.** `git update-index --skip-worktree .obsidian/hotkeys.json` keeps a local hotkey file without git tracking changes. Reverse with `--no-skip-worktree`.
+3. **Propose a new default.** Open a PR updating both `.obsidian/hotkeys.json` and this table. Hotkey changes are not load-bearing but they affect everyone's muscle memory; review accordingly.
+
+## See also
+
+- [`.obsidian/hotkeys.json`](../../.obsidian/hotkeys.json) — the actual file
+- [`AGENTS.md`](../../AGENTS.md) — project-wide conventions
+- [`onboard-a-chio-developer.md`](../playbooks/onboard-a-chio-developer.md) — Day 1, where these hotkeys first show up

vault/episodes/chio-architecture-summary.md

@@ -0,0 +1,37 @@
+---
+id: episode.chio-architecture-summary
+type: episode-architecture-summary
+status: imported
+scope: chio-repo
+title: "Chio architecture summary"
+graphiti_episode_name: "Chio architecture summary"
+source_description: "Curated seed for agent orientation in the Chio repository."
+authoritative_files:
+  - "spec/PROTOCOL.md"
+  - "crates/chio-core-types/src/capability.rs"
+  - "crates/chio-kernel/src/kernel/mod.rs"
+  - "crates/chio-guards/src"
+  - "crates/chio-policy/src"
+imported_from: "(hand-seeded for v0.0.0-scaffold; will be overwritten by `make kb-migrate-seeds` against arc PR #599 seeds/graphiti/architecture-summary.json)"
+imported_at: "2026-05-07T00:00:00Z"
+---
+
+# Chio architecture summary
+
+Chio is a secure, attested tool access protocol. Agents are untrusted. The runtime kernel validates time-bounded capability tokens, runs guard and policy evaluation before tool calls cross trust boundaries, and signs append-only receipt records.
+
+## Guidance
+
+- Start with protocol and core type contracts before changing kernel behavior.
+- Use kb_brief_feature for major work because it combines code, docs, tests, graph impact, memory, and validation commands.
+- Repo files and current CI remain authoritative. The graph is retrieval support only.
+
+<!-- HUMAN EDITS BELOW THIS LINE -->
+
+> This file is hand-seeded to demonstrate the post-migration episode shape. Running `make kb-migrate-seeds` against arc on branch `codex/chio-kb-a-grade-dogfood` will overwrite this file and add a `seed_content_hash:` to the frontmatter (used by the migration script for idempotency). Any edits below this marker will be preserved across re-runs.
+>
+> The four worked specs that reference this episode by `graphiti-episode:` field:
+> - [[../spec/capability-revocation]]
+> - [[../spec/receipt-commitment]]
+> - [[../spec/guard-pipeline]]
+> - [[../spec/policy-compiler]]

vault/spec/policy-compiler.md

@@ -0,0 +1,99 @@
+---
+id: spec.policy.compiler
+type: spec
+status: accepted
+chio-node: Policy
+crate: chio-policy
+supersedes: []
+related-specs:
+  - spec.guard.pipeline
+related-receipts:
+  - receipt.policy-compile
+  - receipt.policy-eval
+related-guards: []
+graphiti-episode: episode.guard-policy-fail-closed
+related-diagrams: []
+owners:
+  - "@connor"
+last-validated: 2026-05-07
+---
+
+# Policy compiler
+
+The deterministic compile-and-evaluate pipeline that turns Chio policy text into the rules each guard runs.
+
+## Normative
+
+> [!normative]
+> Policy text MUST compile to a deterministic evaluator before any policy is enforced. There is no interpretation at exercise time.
+
+> [!normative]
+> Compilation MUST validate the policy against `spec/schemas/chio-policy/v1/policy.schema.json` before producing an evaluator. Schema-invalid policies fail compilation; **partial compilation is forbidden**.
+
+> [!normative]
+> Compilation errors MUST be treated as kernel errors (not policy-author errors): the kernel REFUSES to use a policy that didn't compile cleanly. The kernel does NOT fall back to a previous policy automatically — operators MUST explicitly roll back.
+
+> [!normative]
+> The compiled evaluator MUST be **pure**: no I/O, no clock reads, no random, no network. All inputs to a verdict are explicit arguments. (Replayability follows from purity.)
+
+> [!normative]
+> Every successful compile MUST emit `receipt.policy-compile.<policy-id>` recording: source content hash, compiled artifact hash, kernel version, and the validation verdict.
+
+> [!normative]
+> Every policy evaluation MUST emit `receipt.policy-eval.<exercise-id>` recording: matched rule id, verdict, the inputs the verdict depended on (hashed), and the timestamp.
+
+## Why
+
+> [!guard]
+> Fail-closed extends across the compile boundary. A policy that won't compile is treated like a kernel that won't boot — the system refuses to run rather than degrade silently.
+
+The decision to make compilation a hard kernel-level failure (rather than a soft "use a fallback policy" graceful degrade) is recorded in [[../episodes/guard-policy-fail-closed]] and reflects three constraints:
+
+1. **Policies are kernel-loaded artifacts.** Treating compile errors as kernel errors keeps the failure mode crisp: the kernel can refuse to boot with a broken policy file, the same way it refuses to boot with a broken config. The alternative ("use the last good policy") creates a covert channel for misbehavior — a kernel could intentionally publish a broken policy to revert to a stale one.
+2. **Evaluator purity is the foundation of audit.** A policy that consults the clock or network for its verdict can't be replayed; "the policy said deny at time X" becomes unfalsifiable. Every input to a verdict must be in the receipt.
+3. **Two receipt classes (compile + eval) keep the audit trail orthogonal.** Compile-time receipts prove **what policy was loaded**. Eval-time receipts prove **how it ruled**. Mixing them would conflate "the policy" with "the policy's decisions," and both audit questions are needed.
+
+## Implements
+
+- `chio_policy::compiler` — `crates/chio-policy/src/compiler.rs` (the compiler entry point)
+- `chio_policy::validate` — `crates/chio-policy/src/validate.rs` (schema validation)
+- `chio_policy::evaluate::engine` — `crates/chio-policy/src/evaluate/engine.rs` (the runtime evaluator)
+- `chio_policy::evaluate::matchers` — `crates/chio-policy/src/evaluate/matchers.rs` (predicate implementations consumed by the guard pipeline)
+- `chio_policy::models` — `crates/chio-policy/src/models.rs` (policy AST types)
+- `chio_policy::lib` — `crates/chio-policy/src/lib.rs` (public API)
+- Schema: `spec/schemas/chio-policy/v1/policy.schema.json`
+
+## Tested by
+
+- `crates/chio-policy/tests/compiler_validate.rs` — schema validation
+- `crates/chio-policy/tests/compiler_purity.rs` — evaluator purity (no I/O, no clock, no random)
+- `crates/chio-policy/tests/evaluator_e2e.rs` — full compile → evaluate flow
+- `tests/conformance/peers/*/test_policies.*` — SDK conformance
+
+When changing the wire format under `spec/schemas/chio-policy/v1/`, prefer the SDK conformance tests over Rust unit tests.
+
+## Operations
+
+- [[../playbooks/release-qualification#gate-3--policy-compiler-validation]] — release-time validation that the candidate's policy schema accepts cleanly.
+- [[guard-pipeline]] — the **consumer** of compiled policies. The relationship is one-way: the policy compiler produces evaluators; the guard pipeline runs them. Compiled artifacts are immutable across guard executions.
+
+## Open questions
+
+- [ ] **Hot reload vs. kernel restart.** Today policy reloads require a kernel restart (so receipt streams cleanly cut over). Hot-reload would reduce latency but complicates the receipt chain — what's the precise compile receipt boundary if the kernel didn't restart? Pending an ADR.
+- [ ] **Policy versioning and rollback.** Operators can roll back to a previous policy by re-pointing the kernel at an earlier compiled artifact. Should the rollback itself be receipted? Likely yes — `receipt.policy-rollback` is a candidate. Open for ADR.
+- [ ] **Cross-issuer policy composition.** Mirror of cross-issuer revocation: if issuer A delegates to issuer B, can B's policies layer on top of A's? Today: no. Pending ADR alongside the cross-issuer revocation question.
+
+## Staleness
+
+> [!warning-staleness]
+> Last validated 2026-05-07. Re-validate against `crates/chio-policy/src/` and the `spec/schemas/chio-policy/v1/` schemas when those crates' major versions bump or when the schema changes.
+
+The [[../_meta/queries/stale-specs|stale-specs query]] flags this when `last-validated:` is 90+ days behind today.
+
+## Graph context
+
+%% kb_neighbors: spec.policy.compiler depth=2 %%
+
+## Lineage
+
+Derived from the seed [[../episodes/guard-policy-fail-closed]] (migrated from arc PR #599's `seeds/graphiti/guard-policy-fail-closed.json` via `make kb-migrate-seeds`). The seed is shared with [[guard-pipeline]] — both specs are Chio-side surfaces of the same architectural commitment to fail-closed everywhere.