{
"CONTEXT_THRIFT.md": {
"what": "This is the human-readable rulebook for protecting the orchestrator's context window, which the kit treats as its scarcest resource. It prescribes delegated reading, filtered event monitors, cheap surveys before deep audits, model tiering, disk-backed state, batched human questions, and one-writer file discipline.",
"example": "It says a noisy monitor should be stopped and re-armed with tighter filters immediately, rather than allowed to consume a turn per event.",
"acronyms": {
"CT": "Context-thrift rule family",
"CT1-CT10": "The numbered context-thrift rules",
"L": "Lesson or scar identifier",
"RESUME.md": "A disk-backed handoff/state snapshot"
}
},
"FEATURE_MAP_BUILD_SPEC.md": {
"what": "This is the strict production specification for a self-contained, multipage HTML feature map of the kit. It fixes the page order, semantic HTML, print and screen CSS, required lifecycle/orchestra/tool/template/integrity content, pinned spellings, and a QA checklist that prevents invented or garbled facts.",
"example": "Its v2 addendum requires Page 7 to show all three verdicts: validated / unverified / contradicted, with contradicted blocking the decision.",
"acronyms": {
"HTML": "HyperText Markup Language",
"CSS": "Cascading Style Sheets",
"TOC": "Table of Contents",
"QA": "Quality assurance",
"WCAG-AA": "Web Content Accessibility Guidelines, level AA",
"P1-P12": "The twelve principle identifiers",
"L1-L29": "Lesson/scar identifiers in the pinned terminology",
"CT1-CT10": "Context-thrift rule identifiers",
"BC-*": "Behavioral-contract evaluation cases",
"KB-*": "Knowledge-base pattern identifiers",
"SSH": "Secure Shell"
}
},
"HOW_TO_USE.md": {
"what": "This is the command-by-command operating manual for installing, configuring, running, steering, auditing, and recovering a kit-managed fleet. It explains prerequisites, the project.env surface, the control bus, quota and SSH fallbacks, the fable-terminal build, Pi deployment, dogfood loop, and multi-vendor courier side-tasks.",
"example": "Its terminal runbook copies the tools and the worked project.env/worker prompt, queues `fable-terminal`, then starts the pilot with `./pool.sh 1 fable-terminal`.",
"acronyms": {
"YAML": "A human-readable data-serialization format used for the machine canon",
"SSH": "Secure Shell, used for remote machine offload",
"CLI": "Command-Line Interface",
"API": "Application Programming Interface",
"JSON": "JavaScript Object Notation",
"PyYAML": "The Python YAML parsing library",
"TUI": "Terminal User Interface",
"L": "Lesson/scar identifier",
"KB": "Knowledge-base pattern identifier",
"⚠": "The kit's marker for an assumption, uncertainty, or deferred claim"
}
},
"INTAKE.md": {
"what": "This is the narrative intake questionnaire that turns an underspecified project into a buildable fleet contract. It asks for units and slicing, the source-of-truth spec, gates, dogfood and cold-user completion, guardrails, executors, limits, storage, backup, concurrency, reporting, and unattended recovery, while marking blocking questions.",
"example": "The questionnaire asks for a countable atom and its ground truth, such as ticket-to-merge commits, chapters-to-accepted files, or SKUs-to-scanner records.",
"acronyms": {
"Q-": "Prefix for an intake question identifier",
"G-ID": "A named build-failing guardrail identifier",
"API": "Application Programming Interface",
"SSH": "Secure Shell",
"L28": "The lesson requiring a cold-user product walk, not just green tests",
"P12": "The ask-once principle",
"KB": "Knowledge-base pattern identifier",
"⚠": "The uncertainty marker used for assumptions and deferred answers"
}
},
"LESSONS.md": {
"what": "This is the human narrative companion to the append-only scar log in kernel/lessons.yaml. It records real incidents, the rule learned from each incident, and the structural fix or related practice, so later projects inherit hard-won safeguards instead of repeating fleet-scale mistakes.",
"example": "The scar named L29 records a priority unit receiving zero work because its executor lane was already capped, and turns that incident into the rule to probe each lane before launching it.",
"acronyms": {
"L": "Lesson/scar identifier",
"PROV": "Provisional local lesson identifier before canonical numbering",
"EL": "Entabeni-kit lesson identifier",
"KB": "Knowledge-base pattern identifier",
"YAML": "The data format used by the canonical scar file",
"L34": "The canonical-owns-the-numbers scar about single-writer lesson allocation",
"L96": "The one-standing-harvester scar about preventing concurrent canonical writes"
}
},
"NOTEBOOKLM_PROMPTS.md": {
"what": "This is the prompt pack for regenerating the kit's visual presentation suite in NotebookLM after the textual canon freezes. It defines an exact 12-slide deck, a minimal infographic, and a nine-branch mind map, then gives pinned terminology and failure conditions for QA of generated text.",
"example": "The slide prompt requires the tool page to contain exactly the seventeen named tools and the ladder `ollama-local → grok-cli → codex-cli → in-family implementer → conductor → ceiling`.",
"acronyms": {
"QA": "Quality assurance",
"P1-P12": "The twelve principle identifiers",
"L1-L29": "Lesson/scar identifiers in the prompt's fixed vocabulary",
"CT": "Context-thrift rule family",
"BC": "Behavioral contract",
"KB": "Knowledge-base pattern",
"TOC": "Table of contents",
"JSON": "JavaScript Object Notation"
}
},
"NOTEBOOKLM_SOURCE.md": {
"what": "This is the dense canon source loaded into NotebookLM for independent grounding of the kit's doctrine and feature map. It consolidates principles, lifecycle phases, orchestration layers, vendor seats, tools, templates, integrity rules, terminal/Pi profiles, and the honesty ledger in source-structured prose.",
"example": "Its lifecycle section names Phase 2 as the pilot and requires the gate FAIL→fix→PASS cycle, real atoms, control-bus liveness, an honest milestone, and a pause/resume drill.",
"acronyms": {
"L": "Lesson/scar identifier",
"P": "Principle identifier",
"CT": "Context-thrift identifier",
"BC": "Behavioral contract identifier",
"KB": "Knowledge-base identifier",
"CLI": "Command-Line Interface",
"SSH": "Secure Shell",
"TUI": "Terminal User Interface",
"JSON": "JavaScript Object Notation",
"YAML": "The machine-readable data format used by the kit"
}
},
"ORCHESTRATION.md": {
"what": "This is the human narrative lifecycle for running a project as a fleet: intake, apparatus, pilot, fan-out, watch, done-audit, completion, and optional ship. It also documents recovery keys, machine and quota fallbacks, the self-correction loop, side-task delegation, and the live-testbed feedback loop for deployed fable units.",
"example": "The pilot must inject a benign directive that writes a marker, receives an ACK, and continues, because the control bus is the only steering wheel available at scale.",
"acronyms": {
"P1-P12": "The ordered principles",
"L": "Lesson/scar identifier",
"KB": "Knowledge-base pattern identifier",
"SSH": "Secure Shell",
"API": "Application Programming Interface",
"BC": "Behavioral contract case",
"PROV": "Provisional local scar prefix",
"ACK": "Acknowledgement from a worker that it executed a directive",
"RESUME": "The on-disk handoff/state record"
}
},
"PRINCIPLES.md": {
"what": "This is the human-readable statement of the kit's twelve ordered principles. It explains why ground truth beats claims, why judgment belongs to the orchestrator, why gates and pilots matter, how to fix systemic classes, how to keep honest ledgers, how to recover from death, and when to ask the human.",
"example": "Principle 1 says a DONE claim must be checked against commits, files, records, or a running process before it is accepted.",
"acronyms": {
"P1-P12": "The twelve ordered principle identifiers",
"DONE": "A completion claim or marker, not proof of completion",
"⚠": "The marker for assumed, deferred, or blocked work"
}
},
"README.md": {
"what": "This is the kit's orientation document for a newcomer. It explains that kernel/*.yaml is canonical, the Markdown files are human companions, the fleet method came from a live 29-app build, and the repository contains intake, lifecycle, skills, templates, tools, a terminal blueprint, and a Pi deployment profile.",
"example": "Its boot sequence starts by loading `kernel/principles.yaml` and `kernel/lessons.yaml`, then walking intake before instantiating project.env and the pipeline templates.",
"acronyms": {
"YAML": "A human-readable data-serialization format",
"MD": "Markdown document format",
"CLI": "Command-Line Interface",
"LLM": "Large Language Model",
"PyYAML": "Python's YAML parsing library",
"API": "Application Programming Interface",
"SSH": "Secure Shell",
"P": "Principle identifier",
"L": "Lesson/scar identifier",
"KB": "Knowledge-base pattern identifier",
"⚠": "The uncertainty marker"
}
},
"USAGE.md": {
"what": "This is the longer reference manual for operating a fleet from a populated build directory. It gives quick starts, environment variables, command examples, control-bus procedures, cap and machine fallbacks, terminal/Pi workflows, dogfood expectations, and the full multi-vendor side-task courier protocol.",
"example": "For a side-task it writes `.packet.md`, runs `./dispatch.sh start grok AUD-003 /path/to/workdir`, polls bounded `wait` calls, then normalizes the report and re-runs one cited command.",
"acronyms": {
"YAML": "The machine-readable format parsed for the control bus",
"JSON": "JavaScript Object Notation",
"SSH": "Secure Shell",
"CLI": "Command-Line Interface",
"API": "Application Programming Interface",
"PTY": "Pseudo-terminal",
"TUI": "Terminal User Interface",
"L": "Lesson/scar identifier",
"KB": "Knowledge-base pattern identifier",
"P12": "The ask-once intake principle",
"⚠": "The uncertainty/deferred marker"
}
},
"feature-map.md": {
"what": "This is the Markdown companion feature map: a compact, presentation-structured overview of doctrine, lifecycle 0–6, five-layer orchestra, model seats, seventeen headline tools, templates and control bus, integrity, terminal/Pi, and honesty. It is intended to be loaded with NOTEBOOKLM_SOURCE.md as the same-facts visual canon.",
"example": "Its model-seat table distinguishes NotebookLM as a verdict oracle rather than an executor and lists `validated / unverified / contradicted` as its outputs.",
"acronyms": {
"P1-P12": "Principle identifiers",
"L1-L119": "Lesson/scar identifiers",
"CT1-CT10": "Context-thrift identifiers",
"BC-*": "Behavioral-contract evaluation cases",
"KB-*": "Knowledge-base patterns",
"CLI": "Command-Line Interface",
"SSH": "Secure Shell",
"JSON": "JavaScript Object Notation",
"YAML": "The kit's machine-readable data format",
"⚠": "Uncertainty marker"
}
},
"build-fable-terminal/ARCHITECTURE.md": {
"what": "This is the human architecture narrative for fable-terminal, keyed to SPEC.yaml, TOOLS.yaml, BACKLOG.yaml, and EVAL.yaml. It describes the model/tool/permission/memory/compaction loop, maps the implementation to ai-spine layers L0–L7, defends Bun plus TypeScript and strict tool grammar, and states what v1 deliberately omits.",
"example": "The central loop is `user turn → system prompt + memory + transcript → model → permission gate → tool result → final text → budget check`, with compaction when needed.",
"acronyms": {
"L0-L7": "The eight AI-spine layers from base model through governance",
"LLM": "Large Language Model",
"TUI": "Terminal User Interface",
"REPL": "Read-Eval-Print Loop",
"API": "Application Programming Interface",
"HTTP": "HyperText Transfer Protocol",
"BC": "Behavioral contract",
"EVAL": "Evaluation suite",
"v1": "Version 1"
}
},
"build-fable-terminal/BACKLOG.yaml": {
"what": "This is the executable ticket queue for building fable-terminal under the kit's own pipeline. It groups FT-T tickets into epics covering the core loop, tools, constitution/memory/context, headless orchestration, REPL polish, evaluation, gated hardware seats, persona, and corpus portability, with acceptance conditions for each ticket.",
"example": "FT-T009 requires a router that visibly hops on a 429, parks a capped tier with a retry time, uses local fallback offline, and never silently swaps models.",
"acronyms": {
"YAML": "The agent-facing data format",
"FT-T": "Fable-terminal ticket identifier",
"REPL": "Read-Eval-Print Loop",
"API": "Application Programming Interface",
"NPU": "Neural Processing Unit",
"EVAL": "The evaluation/ship-gate suite",
"BC": "Behavioral contract",
"L7": "The governance layer of the AI spine",
"429": "HTTP status commonly used for rate limiting",
"PTY": "Pseudo-terminal"
}
},
"build-fable-terminal/EVAL.yaml": {
"what": "This is fable-terminal's canonical ship gate, split into model-independent conformance and reference-compared efficacy. It runs headless scenarios in disposable Git fixtures, checks behavioral-contract cases such as empirical verification, recovery, delegation, cascade honesty, offline Pi diagnosis, and product walks, then reports task-class scores against a Claude-Code shim.",
"example": "EV-PRODUCT-NOT-PROJECT makes a unit with green tests but a broken fresh-profile flow fail because the agent must perform a cold user walk and name the broken USER_FLOW.",
"acronyms": {
"EVAL": "Evaluation suite",
"BC": "Behavioral contract",
"EV-": "Conformance scenario identifier",
"EF-": "Efficacy task-class identifier",
"API": "Application Programming Interface",
"429": "HTTP rate-limit status",
"JSON": "JavaScript Object Notation",
"PTY": "Pseudo-terminal",
"L28": "The green-is-not-shippable lesson requiring a cold-user product walk",
"HTTP": "HyperText Transfer Protocol",
"Git": "Distributed version-control system"
}
},
"build-fable-terminal/README.md": {
"what": "This is the newcomer-facing README for the fable-terminal blueprint. It makes the key honesty split explicit: the operating layer is reproducible harness behavior, while the model's capability ceiling must be measured side by side against a reference, and it gives the read order and quickstart commands.",
"example": "After the backlog is built, the intended use is `./fable` for a REPL, `./fable -p \"fix the failing test\"` for a pool-launchable worker, and `./fable eval --model qwen3-coder-next` for the report.",
"acronyms": {
"README": "Repository orientation document",
"REPL": "Read-Eval-Print Loop",
"CLI": "Command-Line Interface",
"LLM": "Large Language Model",
"YAML": "The agent-facing data format",
"BC": "Behavioral contract",
"EVAL": "Evaluation suite",
"SSH": "Secure Shell",
"Pi": "Raspberry Pi single-board computer"
}
},
"build-fable-terminal/SPEC.yaml": {
"what": "This is the canonical machine-readable product and architecture specification for fable-terminal. It defines the Bun/TypeScript stack, tiered backend router, offline knowledge bundle, memory and context governor, tools and permission modes, headless/subagent orchestration, governance floor, parity targets, and explicit limits on efficacy claims.",
"example": "The router falls back from cloud tiers to local Ollama when offline, shows an OFFLINE badge, and requires `kb_lookup` before answering operations or domain questions from the bundled canon.",
"acronyms": {
"YAML": "The machine-readable data format",
"LLM": "Large Language Model",
"API": "Application Programming Interface",
"HTTP": "HyperText Transfer Protocol",
"NPU": "Neural Processing Unit",
"RAM": "Random-Access Memory",
"REPL": "Read-Eval-Print Loop",
"CLI": "Command-Line Interface",
"BC": "Behavioral contract",
"L0-L7": "AI-spine layer identifiers",
"GA-SPINE-LOCK": "Guardrail-admin rule preventing the agent from editing its own governance",
"Q4": "Four-bit model quantization",
"TTFT": "Time to first token",
"OOM": "Out of memory",
"TUI": "Terminal User Interface",
"G-DOCS": "The documentation-verification guard identifier"
}
},
"build-fable-terminal/TOOLS.yaml": {
"what": "This is the contract catalog for fable-terminal's model-visible tools. For each tool it defines parameters, safety class, behavior, path and error conventions, read/write/edit/bus/memory/agent operations, and the permission-gate modes that determine when actions prompt or are automatically allowed.",
"example": "The `edit` tool must fail loudly on zero or multiple matches unless `replace_all` is requested and must return a unified diff.",
"acronyms": {
"YAML": "The machine-readable tool-contract format",
"API": "Application Programming Interface",
"CT9": "The context-thrift rule that pushes bulk reading to cheaper subagents",
"BC": "Behavioral contract",
"REPL": "Read-Eval-Print Loop",
"OFFLINE": "The local-only operating mode with no cloud route",
"JSON": "JavaScript Object Notation"
}
},
"examples/fable-terminal-build/project.env": {
"what": "This is a worked project.env instance for building the fable-terminal blueprint with the kit. It supplies absolute roots, queue and done-file locations, Codex worker settings, atom-count commands, gate and completion contracts, and the paths needed for the example's single-unit pilot.",
"example": "It sets `PROJECT_NAME=FABLE-TERMINAL`, queues the single `fable-terminal` unit, and uses `bun run gate` as the unit's gate command.",
"acronyms": {
"ENV": "Environment-variable configuration",
"CLI": "Command-Line Interface",
"YAML": "The format used by the instantiated pipeline files",
"Git": "Distributed version-control system",
"JSON": "JavaScript Object Notation",
"L": "Lesson/scar identifier"
}
},
"examples/fable-terminal-build/worker-prompt.md": {
"what": "This is the worked agent-facing prompt for the fable-terminal build worker. It grounds the worker in the canonical spec, guardrails, a single unit workspace, one-shot execution, control-bus checkpoints, atom evidence, completion/product-walk requirements, and the local-model orientation needed for the terminal's own recursive build.",
"example": "It tells the worker to read `build-fable-terminal/SPEC.yaml`, implement FT-T atoms in order, run `bun run gate`, and record a PRODUCT WALK before claiming completion.",
"acronyms": {
"YAML": "The structured agent-facing format",
"FT-T": "Fable-terminal ticket identifier",
"BC": "Behavioral contract",
"KB": "Knowledge-base pattern",
"ACK": "Directive acknowledgement",
"Git": "Distributed version-control system",
"L": "Lesson/scar identifier",
"G-": "Build-failing guardrail identifier"
}
},
"kernel/ai-spine.yaml": {
"what": "This is the canonical framework for building an LLM-based reasoning core that behaves like a Fable-class orchestrator without claiming to reproduce proprietary model weights. It defines reproducible operating layers L0–L7, behavioral-contract cases, enforcement below a model capability floor, Track A wrapper and Track B distillation paths, trace-data schema, conformance scoring, recursive orchestration, and deny-by-default governance integration.",
"example": "BC-EMPIRICAL expects a system to cross-check a worker's DONE ledger against ground truth, while its negative case is accepting the ledger at face value.",
"acronyms": {
"YAML": "The canonical machine-readable format",
"LLM": "Large Language Model",
"L0-L7": "Layers from base model through governance integration",
"BC": "Behavioral contract",
"KB": "Knowledge-base pattern",
"API": "Application Programming Interface",
"PII": "Personally Identifiable Information",
"N": "A variable count used in repeated work",
"⚠": "Unproven or uncertain claim marker",
"L28": "The product-not-project lesson used in the enforcement floor"
}
},
"kernel/content-policy.yaml": {
"what": "This is the policy-routing kernel for preserving the human-authored register of a project. It distinguishes legitimate adult/security/persona work from absolute exclusions, routes the requested register to a policy-fit executor instead of coercing a refusal, and defines a human content-review gate for material that needs moderation.",
"example": "Its rule is that register is decided at intake and written into the spec; a worker that hedges below that register is a routing signal, not permission to jailbreak it.",
"acronyms": {
"YAML": "The canonical policy data format",
"LLM": "Large Language Model",
"L48": "The lesson that register belongs to the spec and should route executor choice",
"L61": "The vendor-refusal-is-not-the-project-ceiling lesson",
"L109": "The session-can-be-blocked-by-context lesson",
"L112": "The authorized dual-use work routing/framing lesson",
"G-ABSOLUTE-EXCLUSIONS": "The build-failing guardrail for non-negotiable exclusions",
"G": "Build-failing guardrail identifier"
}
},
"kernel/context-thrift.yaml": {
"what": "This is the machine-readable context-thrift kernel. Its ten rules control how the orchestrator delegates reading, uses monitors instead of polling, filters at the source, chooses cheap surveys versus deep audits, tiers models, stores state on disk, batches human communication, prevents append races, and instruments the physical context meter.",
"example": "CT4 sets an approximate steady-state ratio of twenty cheap one-line looks to one deep audit.",
"acronyms": {
"YAML": "The machine-readable format",
"CT1-CT10": "The ten context-thrift rule identifiers",
"KB": "Knowledge-base pattern identifier",
"RESUME.md": "On-disk state/handoff record",
"RAM": "Random-Access Memory",
"L94": "The lesson requiring action on an instrumented threshold",
"L100": "The stale detached-watcher lesson"
}
},
"kernel/domains.yaml": {
"what": "This is the domain-archetype kernel: a set of floors for app, game, agent_tool, spec_packet, writing, precision_review, data, and ops projects. Each profile adds intake questions, always-needed artifacts, gate additions, candidate guardrails, craft moves, and domain-specific blind spots that must be checked at every gate.",
"example": "The app profile makes authentication a first-slice, build-failing concern through G-AUTH, while the game profile warns that narrative intake must cover story, characters, tone, mechanics, topology, and rewards.",
"acronyms": {
"YAML": "The canonical domain-profile format",
"LLM": "Large Language Model",
"G-ID": "Named guardrail identifier",
"API": "Application Programming Interface",
"CLI": "Command-Line Interface",
"SSH": "Secure Shell",
"P1": "Empirical-over-claimed principle",
"L60": "The lesson that every project arrives as a kind",
"L67": "The lesson that the kit should suggest, not only guard",
"KB": "Knowledge-base pattern identifier"
}
},
"kernel/executors.yaml": {
"what": "This is the canonical roster and routing table for worker and side-task seats. It defines headless launch profiles, flags, models, grounding files, caps, authentication, gotchas, the L0–L4 orchestra layers, NotebookLM verification, dispatch preflight, task-shape routing, the escalation ladder, quota/machine fallbacks, and family-parity rules.",
"example": "The codex-cli profile uses `codex exec --sandbox workspace-write -o <file> -m <model>`, while the grok profile requires a PTY, JSON output, and `--always-approve` for detached tool use.",
"acronyms": {
"YAML": "The machine-readable executor format",
"CLI": "Command-Line Interface",
"PTY": "Pseudo-terminal",
"TTY": "Terminal device interface",
"API": "Application Programming Interface",
"SSH": "Secure Shell",
"L0-L4": "Conductor, in-family, external CLI, verification, and local-glue layers",
"L5": "Usage-cap lesson used in dispatch preparation",
"L29": "The pre-launch quota-probe lesson",
"L115": "The weak-before-strong cross-vendor lesson",
"L116": "The turnkey-enforced delegation-ladder lesson",
"KB": "Knowledge-base pattern identifier",
"JSON": "JavaScript Object Notation",
"HTTP": "HyperText Transfer Protocol",
"429": "HTTP rate-limit status",
"xAI": "The vendor family providing Grok",
"NPU": "Neural Processing Unit"
}
},
"kernel/guardrail-admin.yaml": {
"what": "This is the human-owned governance questionnaire for projects that build an LLM spine. It separates guardrail administration from the spine, asks who may approve, review, operate, or kill it, defines capability and tenant boundaries, deployment tiers, change/eval/incident procedures, and adds proportional friction for unrestricted mode while preserving an immovable accountability floor.",
"example": "GA-SPINE-LOCK requires a policy store outside the spine's writable surface and a guard test proving the spine cannot mutate it.",
"acronyms": {
"YAML": "The canonical governance-policy format",
"LLM": "Large Language Model",
"GA-": "Guardrail-admin questionnaire identifier",
"L7": "Governance-integration layer",
"PII": "Personally Identifiable Information",
"PR": "Pull Request",
"NPU": "Neural Processing Unit",
"Fable/Mythos": "The example of one model family with different guardrail tiers",
"API": "Application Programming Interface"
}
},
"kernel/intake.yaml": {
"what": "This is the machine-readable intake schema and conduct guide. It distinguishes spec-stage from idea-stage projects, supports catalog or rolling slicing, declares blocking versus defaulted questions, and emits project.env, pipeline.yaml, guardrails.yaml, and—when needed—a newly transcribed SPEC.md.",
"example": "Q-BACKUP is always asked and requires a backup target, cadence, and tested restore rather than a vague claim that data is safe.",
"acronyms": {
"YAML": "The canonical intake data format",
"Q-": "Intake-question identifier",
"G-ID": "Build-failing guardrail identifier",
"API": "Application Programming Interface",
"SSH": "Secure Shell",
"L30": "The idea-stage question-by-question intake lesson",
"L31": "The human's slicing choice lesson",
"L44": "The deadline-as-intake-answer lesson",
"L101": "The standing storage-question lesson",
"L102": "The rate-ceiling/concurrency lesson",
"L103": "The goal request is not consent to mutate the host lesson",
"KB": "Knowledge-base pattern identifier",
"SPEC.md": "A Markdown project specification"
}
},
"kernel/knowledge-base.yaml": {
"what": "This is the reusable pattern catalog that lets an agent inherit the kit's playbook without rereading every incident. It groups fable-native and session-adopted patterns for reasoning, orchestration, context management, resources, quality, honesty, routing, instrumentation, and derived kits, cross-linking each pattern to principles, lessons, tools, or examples.",
"example": "KB-LEDGER-GROUND-TRUTH-SPLIT says STATUS is a cheap human-readable oversight ledger, while progress and done decisions come from commits, files, or records.",
"acronyms": {
"YAML": "The canonical pattern-catalog format",
"KB": "Knowledge-base pattern identifier",
"P": "Principle identifier",
"L": "Lesson/scar identifier",
"CT": "Context-thrift rule identifier",
"BC": "Behavioral contract identifier",
"API": "Application Programming Interface",
"SSH": "Secure Shell",
"MV3": "Manifest Version 3 for browser extensions",
"TCC": "macOS Transparency, Consent, and Control",
"OOM": "Out of memory",
"ACK": "Directive acknowledgement",
"PROV": "Provisional scar prefix",
"EL": "Entabeni-kit scar prefix"
}
},
"kernel/lessons.yaml": {
"what": "This is the canonical append-only machine-readable scar log, currently carrying lessons L1 through L119. Each entry turns a lived incident into imperative rules and ties, covering stale ledgers, bus corruption, monitor floods, cap and machine failures, drift, product-walk gaps, hardware, observer scope, storage, concurrency, host mutation, policy routing, and delegation.",
"example": "L119 says a directive aimed at the human is itself a claim and must be verified against the installed version before the human is told to use it.",
"acronyms": {
"YAML": "The canonical scar-log format",
"L1-L119": "The numbered lesson/scar identifiers",
"PROV": "Provisional project-local scar prefix",
"EL": "Entabeni-kit scar prefix",
"KB": "Knowledge-base pattern identifier",
"P": "Principle identifier",
"CT": "Context-thrift rule identifier",
"BC": "Behavioral contract identifier",
"SIGABRT": "Process abort signal used in a browser failure example",
"API": "Application Programming Interface",
"SSH": "Secure Shell",
"OOM": "Out of memory",
"PTY": "Pseudo-terminal",
"NPU": "Neural Processing Unit"
}
},
"kernel/machines.yaml": {
"what": "This is the shareable machine-registry template, deliberately without real hostnames, users, IPs, or network details. It specifies a lookup ladder through a deployment registry, SSH aliases, Tailscale, mDNS, and finally the human, plus the fields every deployment-specific machine entry must contain.",
"example": "A deployment entry is shaped as a canonical name with aliases, `ssh <user>@<mdns-name>` access, network context, role, and last_verified date.",
"acronyms": {
"YAML": "The machine-registry data format",
"SSH": "Secure Shell",
"IP": "Internet Protocol address",
"mDNS": "Multicast Domain Name System",
"DHCP": "Dynamic Host Configuration Protocol"
}
},
"kernel/orchestration.yaml": {
"what": "This is the canonical machine lifecycle and recovery specification. It defines phases 0–7, pilot validations, fan-out and watch instruments, response classes, done-audit checks, deployment gates, cold_start and worker_stop recovery, structural self-correction, side-task courier rules, and live_testbed feedback for deployed kernel-bearing units.",
"example": "On a usage cap it requires notifying the human once, sweeping every other lane backed by that executor, probing before new launches, and using the fallback pool immediately.",
"acronyms": {
"YAML": "The canonical lifecycle format",
"P8": "The fix-the-class principle",
"L22": "The corrupt-control-bus lesson",
"L24": "The marker-is-a-claim lesson",
"L28": "The cold-user product-walk lesson",
"L29": "The lane-quota-probe lesson",
"L35": "The apparatus-stays-out-of-artifact lesson",
"L39": "The reviewer-minted-marker lesson",
"L94": "The actionable-threshold lesson",
"L115": "The weak-before-strong routing lesson",
"L116": "The turnkey delegation lesson",
"KB": "Knowledge-base pattern identifier",
"BC": "Behavioral contract identifier",
"SSH": "Secure Shell",
"API": "Application Programming Interface",
"ACK": "Directive acknowledgement",
"PROV": "Provisional scar prefix"
}
},
"kernel/principles.yaml": {
"what": "This is the ordered machine canon of the kit's twelve principles. Each principle has an identifier, rule, application or scar link, and lower IDs take precedence when principles conflict.",
"example": "P4-PILOT-FIRST requires one unit end to end before fan-out and widens concurrency from 1 to 3–4 only after the pilot works.",
"acronyms": {
"YAML": "The canonical principles format",
"P1-P12": "The twelve ordered principle identifiers",
"L1": "The fabricated-ledger scar linked to empirical verification",
"L4": "The pause/resume scar",
"L6": "The prior-art/fix-the-class scar",
"L9": "The spec-change propagation scar",
"L30": "The intake conduct scar"
}
},
"kernel/small-window.yaml": {
"what": "This is the command-activated tight-context operating mode. It defines SW1–SW7: work from a short activation card, act at roughly 50% context and add no new multi-step scope past 60%, keep the handoff current, delegate reading, size atoms to a session, know reset ceilings, and revalidate detached state on re-entry.",
"example": "SW5 says an atom larger than one worker lifetime should be split because it will otherwise restart-loop and never land.",
"acronyms": {
"YAML": "The machine-readable mode configuration",
"SW1-SW7": "The seven small-window operating rules",
"L94": "The lesson requiring action on context thresholds",
"L99": "The atom-must-fit-a-worker-lifetime lesson",
"L100": "The detached-watcher/session-id lesson",
"CT": "Context-thrift rule family",
"RESUME": "On-disk handoff/state record"
}
},
"pi-fable-terminal/FINISH_RUNBOOK.md": {
"what": "This is the self-contained recovery and completion runbook for the reference Pi deployment, written while the Pi was off-network. It begins with an audit of the repo, bus, commits, gate, and corpus state, then gives a clean-worktree ship procedure, bounded corpus ingest, post-deploy probes, live-testbed encoding, and the final owner ping.",
"example": "The runbook requires `MemoryMax=1G` for resumed ingest and says cataloging must reach all 71,051 books even if full-text extraction stops at the 20G budget.",
"acronyms": {
"Pi": "Raspberry Pi single-board computer",
"SSH": "Secure Shell",
"Git": "Distributed version-control system",
"ACK": "Directive acknowledgement",
"OOM": "Out of memory",
"RSS": "Resident set size",
"G": "Gigabyte unit in a corpus budget",
"BC": "Behavioral contract",
"EVAL": "Evaluation suite",
"KB": "Knowledge-base retrieval tool",
"L": "Lesson/scar identifier",
"d61-d63": "Deployment directive/round identifiers"
}
},
"pi-fable-terminal/PI_SPEC.yaml": {
"what": "This is the canonical deployment profile for running the same fable-terminal binary on an 8GB Raspberry Pi 5, with an expanded 16GB/Hailo profile described in the same file. It specifies hardware and OS envelopes, model presets, RAM/thermal management, watcher/hybrid/edge topologies, systemd service settings, hardware upgrades, honest evaluation expectations, and first-session conformance.",
"example": "The hybrid_offload topology keeps tools, memory, and ledgers on the Pi while borrowing a LAN model through `OLLAMA_HOST`, visibly degrading to a local model when the LAN box sleeps.",
"acronyms": {
"YAML": "The machine-readable deployment profile",
"Pi": "Raspberry Pi single-board computer",
"CPU": "Central Processing Unit",
"GPU": "Graphics Processing Unit",
"NPU": "Neural Processing Unit",
"RAM": "Random-Access Memory",
"LPDDR4X": "Low-Power Double Data Rate 4X memory",
"OS": "Operating System",
"LTS": "Long-Term Support",
"Q4": "Four-bit quantization",
"tok/s": "Tokens per second",
"OLLAMA_HOST": "Ollama server endpoint environment variable",
"TTFT": "Time to first token",
"OOM": "Out of memory",
"PCIe": "Peripheral Component Interconnect Express",
"NVMe": "Non-Volatile Memory Express storage",
"SD": "Secure Digital storage card",
"USB": "Universal Serial Bus",
"PSU": "Power Supply Unit",
"TOPS": "Tera Operations Per Second",
"INT4": "Four-bit integer inference format",
"L28": "Cold-user first-session conformance lesson",
"L21": "The duplicated-rules-drift lesson",
"EVAL": "Evaluation suite"
}
},
"pi-fable-terminal/RASPBIAN_KNOWLEDGE.yaml": {
"what": "This is the Pi-specific domain pack rendered into fable's constitution when `profile=pi`. It records Raspberry Pi OS identity, first-response diagnostics, power/thermal/throttle bitfields, boot and firmware paths, PCIe/device-tree, cgroups, GPIO, zram, systemd, Pironman fan behavior, common failures, and non-negotiable safety rules.",
"example": "It decodes `0x50005` as undervoltage and throttling happening now plus past undervoltage/throttle history, so benchmarking must stop and the PSU must be fixed first.",
"acronyms": {
"YAML": "The machine-readable Pi knowledge format",
"Pi": "Raspberry Pi single-board computer",
"OS": "Operating System",
"LTS": "Long-Term Support",
"CPU": "Central Processing Unit",
"PCIe": "Peripheral Component Interconnect Express",
"GPIO": "General-Purpose Input/Output",
"DSI": "Display Serial Interface",
"NVMe": "Non-Volatile Memory Express",
"SD": "Secure Digital storage card",
"PSU": "Power Supply Unit",
"USB": "Universal Serial Bus",
"OOM": "Out of memory",
"RAM": "Random-Access Memory",
"DRM": "Direct Rendering Manager",
"OLED": "Organic Light-Emitting Diode",
"Trixie": "Debian 13-based Raspberry Pi OS release",
"zram": "Compressed RAM-backed swap"
}
},
"pi-fable-terminal/README.md": {
"what": "This is the human introduction to the Raspberry Pi 5 deployment profile. It explains that the profile is not a fork, describes the honest watcher, hybrid, and edge-worker seats, points to the Pi constitution pack and setup runbook, and states why an 8GB CPU-only board is useful but not a coding workstation.",
"example": "The watcher seat runs a 1.7–4B local model headlessly under systemd to read STATUS, check Git ground truth, decode thermal/power state, and notify the expensive orchestrator.",
"acronyms": {
"Pi": "Raspberry Pi single-board computer",
"CPU": "Central Processing Unit",
"LAN": "Local Area Network",
"SSH": "Secure Shell",
"OS": "Operating System",
"YAML": "The agent-facing file format",
"L21": "The lesson against duplicating rules in a derived profile"
}
},
"pi-fable-terminal/SETUP.yaml": {
"what": "This is the ordered, agent-executable Pi provisioning runbook. Steps S1–S12 install and verify the OS, cooling/power, storage, zram, dependencies, Ollama, models, fable, the Pi profile, the watcher service, and the nightly eval gate; upgrade steps cover the 16GB/Hailo rig and a LAN hybrid.",
"example": "S2 requires a 27W PSU and a five-minute CPU stress test whose `vcgencmd get_throttled` result is exactly `0x0`.",
"acronyms": {
"YAML": "The machine-readable setup format",
"Pi": "Raspberry Pi single-board computer",
"OS": "Operating System",
"PSU": "Power Supply Unit",
"NVMe": "Non-Volatile Memory Express storage",
"PCIe": "Peripheral Component Interconnect Express",
"SSH": "Secure Shell",
"LAN": "Local Area Network",
"NPU": "Neural Processing Unit",
"HailoRT": "Hailo runtime library",
"EVAL": "Evaluation suite",
"RAM": "Random-Access Memory",
"zram": "Compressed RAM-backed swap",
"USB": "Universal Serial Bus"
}
},
"skills/begin/SKILL.md": {
"what": "This is the /begin skill for booting a new project into the think-like-fable method. It locates and freshness-checks the kit, activates domain and lesson guards, runs intake, prepares executor pools and OS posture, proves a representative pilot, fans out in waves, watches exceptions, and finishes with audited completion and provisional scar harvesting.",
"example": "Before fan-out it requires a routing table mapping every unit to its weakest-capable escalation rung and a probe dispatch for every named vendor pool.",
"acronyms": {
"SKILL": "An invocable agent workflow document",
"L30": "The lookup/intake lesson referenced by begin",
"L34": "The single-writer canonical-numbering lesson",
"L94": "The context-threshold lesson",
"L97": "The activate-the-kit lesson",
"L113": "The do-not-boot-deep-context lesson",
"L115": "The weak-before-strong routing lesson",
"L116": "The turnkey delegation lesson",
"PROV": "Provisional local scar prefix",
"SSH": "Secure Shell",
"YAML": "The agent-facing configuration format",
"ACK": "Directive acknowledgement"
}
},
"skills/continue/SKILL.md": {
"what": "[sensitive content omitted]",
"example": "For a fleet it distinguishes DONE+DIRECTIVES from DONE-MARKED and requires draining open bus directives before auditing a marker.",
"acronyms": {
"SKILL": "An invocable agent workflow document",
"L1": "The empirical verification/fabrication lesson",
"L97": "The activate-the-kit lesson",
"L100": "The detached watcher re-entry lesson",
"L110": "The shared-workspace bare-continue pollution lesson",
"CT1": "The delegate-reading context rule",
"YAML": "The machine-readable configuration format",
"DONE": "A completion claim or marker",
"PROV": "Provisional scar prefix"
}
},
"skills/dogfood-it/SKILL.md": {
"what": "This is the /dogfood-it skill for executing a previously written DOGFOOD.md plan autonomously against the real product. It uses the live browser, API, CLI, or device path, records evidence and verdicts per step, and explicitly treats green tests as insufficient; it fronts human review but never replaces it.",
"example": "A CLI product is driven through its actual command path and the response bodies or log lines are recorded for each planned step.",
"acronyms": {
"SKILL": "An invocable agent workflow document",
"API": "Application Programming Interface",
"CLI": "Command-Line Interface",
"L92": "The lesson that liveness or green tests are not quality",
"EL16": "An Entabeni lesson cited for verify-don't-trust",
"DOGFOOD.md": "The human-rerunnable manual product-walk plan"
}
},
"skills/dogfood/SKILL.md": {
"what": "This is the /dogfood skill for producing a concrete human-review plan after a unit, feature, or phase completes. It grounds the plan in the actual diff and surface, gives exact entry steps and expected results for every touched flow, adds edge probes, defines a pass bar, and specifies where breakage is reported.",
"example": "A step must say things like open an exact URL, click an exact label, or type exact data; `navigate to the relevant page` is explicitly not enough.",
"acronyms": {
"SKILL": "An invocable agent workflow document",
"L12": "The use-before-done lesson",
"L62": "The exact-courier-detail lesson",
"DOGFOOD.md": "The self-contained human product-walk document",
"URL": "Uniform Resource Locator",
"API": "Application Programming Interface",
"CLI": "Command-Line Interface"
}
},
"skills/drift/SKILL.md": {
"what": "This is the /drift skill for comparing canonical mirrors and derived kits and choosing the safe response by drift class. It distinguishes clean, behind, local-scar, and independent Entabeni drift, requiring harvest-before-resync when local scars exist and a rescan after action.",
"example": "A mirror with a PROV-* scar is classified LOCAL-SCARS and must be harvested into canonical before rsync can overwrite it.",
"acronyms": {
"SKILL": "An invocable agent workflow document",
"PROV": "Provisional local scar identifier",
"EL": "Entabeni-kit scar identifier",
"L34": "The canonical-numbering/clobber scar",
"L57": "The detectable-drift lesson",
"L96": "The single standing harvester lesson",
"rsync": "A file synchronization utility"
}
},
"skills/guardrails/SKILL.md": {
"what": "This is the /guardrails skill for turning an important rule into a build-failing project check. It names a falsifiable invariant, selects or mints a G-ID, proves the guard red and green, installs it into the project gate and worker packet, and refuses to disguise an advisory review as enforcement.",
"example": "It proposes a guard such as no privileged route answering an unauthenticated caller, then requires a deliberate red test before accepting the green gate.",
"acronyms": {
"SKILL": "An invocable agent workflow document",
"G-ID": "Build-failing guardrail identifier",
"G-NO-FABRICATION": "No-fabrication guardrail",
"P3/P6": "The gates-not-vibes and integrity/guardrail principles",
"YAML": "The machine-readable guardrail format",
"CI": "Continuous Integration"
}
},
"skills/handoff/SKILL.md": {
"what": "This is the /handoff skill for writing a small, scoped, resumable state card keyed by one word. It records the current project only, ground-truth marker and branch, in-flight work, exact next step, human decisions, detached apparatus, and the literal `/continue <token>` re-entry command.",
"example": "A handoff for a game thread ends with `resume: /continue game` so a shared workspace does not pull in sibling projects.",
"acronyms": {
"SKILL": "An invocable agent workflow document",
"L100": "The detached-apparatus re-entry lesson",
"L110": "The shared-workspace pollution lesson",
"RESUME": "A disk-backed resumable state record",
"Git": "Distributed version-control system"
}
},
"skills/harvest/SKILL.md": {
"what": "This is the /harvest skill for adding one verified lesson to the canonical scar log and encoding the fix into the apparatus. It enforces a single writer, a lived incident, installed-version verification, exact L-ID allocation, YAML parsing, structural repair, and eventual shipping.",
"example": "It finds the maximum existing `L<n>` in kernel/lessons.yaml, appends the next schema-shaped entry with incident, rules, and ties_to, then parse-checks it.",
"acronyms": {
"SKILL": "An invocable agent workflow document",
"L96": "The single-writer harvester rule",
"L34": "The canonical-owns-the-numbers rule",
"L119": "The installed-version verification rule",
"L-ID": "Numbered lesson/scar identifier",
"YAML": "The scar file format",
"PROV": "Provisional local scar identifier",
"EL": "Entabeni-kit scar identifier"
}
},
"skills/learn/SKILL.md": {
"what": "This is the /learn skill for running the standing observer and harvesting lessons from the whole loop across Claude, Codex, and other runtimes. It detects live transcripts, arms scoped watchers, filters noise, captures human dialogue plus agent outcomes, checks drift, reads context around signals, writes generic scars, repairs tools, and ships both kit editions.",
"example": "It requires `claude-all-watch.py --self <your-session-id>` and says the --self value must be re-armed after compaction or a new session ID.",
"acronyms": {
"SKILL": "An invocable agent workflow document",
"L8": "The monitor-flood lesson",
"L34": "The canonical drift/clobber lesson",
"L90": "The multi-runtime observer-scope lesson",
"L91": "The harvest-the-whole-loop lesson",
"L96": "The single-harvester rule",
"L100": "The stale watcher/session-id lesson",
"JSONL": "JSON Lines, one JSON record per line",
"PROV": "Provisional local scar prefix",
"EL": "Entabeni-kit scar prefix",
"CLI": "Command-Line Interface"
}
},
"skills/machines/SKILL.md": {
"what": "This is the /machines skill for resolving and empirically checking machines in the estate. It insists on the registry-first lookup ladder, host-grounded commands, explicit PATH checks for non-interactive SSH, and reporting an unreachable machine as a blind spot rather than a clean state.",
"example": "The health probe is `ssh -o ConnectTimeout=8 <host> 'echo ok; uptime'`, and a timeout is reported as a finding.",
"acronyms": {
"SKILL": "An invocable agent workflow document",
"SSH": "Secure Shell",
"PATH": "The shell's executable search path",
"mDNS": "Multicast Domain Name System",
"L93": "The host-grounding lesson",
"L108": "The registry lookup rather than hostname-hunt lesson",
"Pi": "Raspberry Pi machine seat"
}
},
"skills/pi/SKILL.md": {
"what": "This is the /pi skill for deploying and operating real Raspberry Pi hardware. It points to the Pi spec, setup, Raspbian knowledge, finish runbook, and machine registry, then requires host-grounded probes, small verified changes, no Mac installs, no orphaning with timeout, and device behavior as ground truth.",
"example": "Before depending on a display or storage capability it runs an on-device probe for the DRM card map, DSI panel, GPIO/OLED, or NVMe state.",
"acronyms": {
"SKILL": "An invocable agent workflow document",
"Pi": "Raspberry Pi single-board computer",
"SSH": "Secure Shell",
"DRM": "Direct Rendering Manager",
"DSI": "Display Serial Interface",
"GPIO": "General-Purpose Input/Output",
"OLED": "Organic Light-Emitting Diode",
"NVMe": "Non-Volatile Memory Express",
"L93": "The host-grounding lesson",
"L81": "The empirical capability-probe lesson",
"OS": "Operating System"
}
},
"skills/ship/SKILL.md": {
"what": "This is the /ship skill for propagating canonical kit changes to mirrors and zip editions. It validates YAML and scar counts, aborts on local-scar drift, mirrors the kit, rebuilds full and orchestration zips, spot-checks the result, and deploys changed live skills when needed.",
"example": "It runs `bash scripts/ship-kit.sh`, then checks that a changed artifact is byte-identical in a mirror and present inside each zip.",
"acronyms": {
"SKILL": "An invocable agent workflow document",
"YAML": "The canonical kernel format",
"L34": "The harvest-before-overwrite drift rule",
"L96": "The one-shipper-at-a-time rule",
"zip": "A compressed archive format",
"Git": "Distributed version-control system"
}
},
"skills/skin-it/SKILL.md": {
"what": "This is the /skin-it design-director workflow for selecting a complete, domain-matched visual identity rather than a generic theme. It grounds safe, bold, and wildcard proposals in the stored gallery corpus, specifying palette, typography, layout, signature motif, motion system, reduced-motion behavior, accessibility, and concrete reskin diffs.",
"example": "A scoped `/skin-it dashboard` run reads the dashboard surface pattern, keeps the site's family skin, and proposes count-up KPIs, chart draw-ons, or skeleton-to-content transitions that degrade under reduced motion.",
"acronyms": {
"SKILL": "An invocable agent workflow document",
"WCAG-AA": "Web Content Accessibility Guidelines, level AA",
"CSS": "Cascading Style Sheets",
"HTML": "HyperText Markup Language",
"60fps": "A target of sixty rendered frames per second",
"a11y": "Accessibility shorthand",
"URL": "Uniform Resource Locator",
"WebGL": "Web Graphics Library",
"Dribbble": "The referenced design-gallery site"
}
},
"skills/skin-it/references/envato-and-motion.md": {
"what": "This is the motion-grounding reference for skin-it, added after a dogfood finding that an early design pick was not engaging enough. It surveys Envato UI/UX templates and the 2026 animated-web canon, naming scroll sequences, parallax, kinetic type, micro-interactions, meaningful transitions, WebGL/3D, broken grids, 60fps discipline, and reduced-motion fallbacks.",
"example": "It treats a scroll-triggered sequence where the scroll itself becomes the narrative timeline as a grounded motion pattern, not as vague advice to add animation.",
"acronyms": {
"UI": "User Interface",
"UX": "User Experience",
"WebGL": "Web Graphics Library",
"3D": "Three-dimensional graphics",
"60fps": "Sixty rendered frames per second",
"CSS": "Cascading Style Sheets",
"Envato": "The referenced design-template marketplace",
"Figma": "The referenced interface-design tool"
}
},
"skills/skin-it/references/lovable-gallery.md": {
"what": "This is the raw provenance corpus behind skin-library.yaml. It lists roughly 130 named Lovable templates across SaaS/apps, internal tools, ecommerce, portfolios, landing pages, blogs, music, events, services, product management, developer tools, resumes, and luxury, with the recurring aesthetic descriptors that the library distills.",
"example": "The corpus names `Terminal Developer Portfolio` as a terminal/developer exemplar and `VOID Ecommerce` as a monochrome brutalist storefront exemplar.",
"acronyms": {
"SaaS": "Software as a Service",
"UI": "User Interface",
"UX": "User Experience",
"AI": "Artificial Intelligence",
"CRM": "Customer Relationship Management",
"ATS": "Applicant Tracking System",
"PDF": "Portable Document Format",
"Lovable": "The template-gallery source named by this corpus"
}
},
"skills/skin-it/references/surface-patterns.md": {
"what": "This is the surface-level design reference for skin-it when the user names a page or component instead of a whole site. It records login and dashboard archetypes, hierarchy rules, component sets, motion patterns, accessibility needs, Dribbble screenshot provenance, and a wider pattern list for pricing, onboarding, checkout, settings, empty states, data tables, chat, and orchestration-relevant surfaces.",
"example": "For B2B login, it makes email/SSO primary and social login secondary; for consumer login, social login is primary and email sits below.",
"acronyms": {
"UI": "User Interface",
"UX": "User Experience",
"B2B": "Business to Business",
"SSO": "Single Sign-On",
"OAuth": "An authorization protocol commonly used for social login",
"KPI": "Key Performance Indicator",
"CSS": "Cascading Style Sheets",
"Dribbble": "The referenced design-gallery source",
"AI": "Artificial Intelligence",
"⌘K": "The keyboard shortcut convention for a command palette",
"a11y": "Accessibility shorthand"
}
},
"skills/skin-it/skin-library.yaml": {
"what": "This is the structured design corpus consumed by /skin-it. It defines aesthetic families with vibes, palettes, type pairings, layout archetypes, motion motifs and intensities, best-fit domains and buyers, avoid lists, and exemplars, plus reusable motion vocabulary, category rankings, wildcard moves, and surface patterns.",
"example": "The `terminal-developer` family uses a near-black background, phosphor accent, monospace type, a console-window layout, and a typing-with-cursor motion motif.",
"acronyms": {
"YAML": "The structured corpus format",
"WCAG-AA": "Web Content Accessibility Guidelines, level AA",
"CSS": "Cascading Style Sheets",
"UI": "User Interface",
"UX": "User Experience",
"60fps": "Sixty rendered frames per second",
"a11y": "Accessibility shorthand",
"Lovable": "The gallery source used to distill the families",
"WebGL": "Web Graphics Library"
}
},
"skills/small-window/SKILL.md": {
"what": "This is the /small-window skill for entering or exiting the tight-context mode. It activates SW1–SW7, creates an activation card, states the roughly 50% and 60% gates, checks the handoff, and refuses to turn the mode off in a derived kit that pins it as a requirement.",
"example": "On activation it announces: `small-window mode ON — acting at 50%, no new scope past 60%.`",
"acronyms": {
"SKILL": "An invocable agent workflow document",
"SW1-SW7": "The seven small-window rules",
"RESUME": "On-disk resumable state record",
"L94": "The context-threshold lesson",
"TUI": "Terminal User Interface"
}
},
"skills/verdict/SKILL.md": {
"what": "This is the /verdict skill for independent claim-versus-canon adjudication. It freezes a decidable claim, checks NotebookLM source freshness, sends the claim through the verdict lane, records citations, and keeps empirical disk truth separate from what the canon says.",
"example": "A claim such as `the ladder says X` is sent to `tools/verdict.sh`; a source-less answer becomes unverified, while contradicted blocks the decision.",
"acronyms": {
"SKILL": "An invocable agent workflow document",
"L": "Lesson/scar identifier",
"YAML": "The canon's machine-readable format",
"NotebookLM": "The independent notebook-grounded verdict service",
"API": "Application Programming Interface",
"validated": "Verdict supported by a citation",
"unverified": "No loaded source speaks to the claim",
"contradicted": "A loaded source conflicts with the claim"
}
},
"templates/CONTROL.yaml": {
"what": "This is the per-unit YAML seed for the append-only reviewer command bus. It defines directive fields, the seven allowed types, worker acknowledgement expectations, and the open directive shape that inject.sh appends and workers consume at checkpoints.",
"example": "A `correct` directive targets an ATOM-ID, names an optional guardrail, carries an instruction, and stays `status: OPEN` until the worker ACKs it.",
"acronyms": {
"YAML": "The control-bus data format",
"ACK": "Acknowledgement that a worker executed a directive",
"ATOM-ID": "Identifier for a countable work atom",
"G-ID": "Build-failing guardrail identifier",
"ISO8601": "International date/time representation",
"L7": "The control-bus proof lesson"
}
},
"templates/STATUS.md": {
"what": "This is the per-unit Markdown ledger template. Workers overwrite its small header with the current unit, milestone, atom, gate, landed evidence, promotions, and blocker state, then append notes about assumptions, directives, self-dogfood, and anything a reviewer needs to trust.",
"example": "The header includes `last-gate: PASS|FAIL @ <ISO8601>` and `blockers: none|PAUSED|STOPPED|DONE`.",
"acronyms": {
"MD": "Markdown document format",
"ISO8601": "International date/time representation",
"G-STATUS-CURRENT": "Guardrail requiring the ledger header to reflect reality",
"DONE": "Completion claim/marker",
"PAUSED": "Worker parked for later resume",
"STOPPED": "Worker stopped by directive"
}
},
"templates/authorized-context-header.md": {
"what": "This is the honest context-framing template for authorized security work or a persistent authored persona. It supplies true facts that were missing, explicitly forbids using the header as a jailbreak or guardrail bypass, routes to a policy-fit lane first, and stops if the register remains outside every available lane.",
"example": "The security variant asks for the authorization basis, in-scope assets, out-of-scope assets, defensive goal, and disclosure path before a session starts.",
"acronyms": {
"MD": "Markdown document format",
"L109": "The context-blocked-session lesson",
"L112": "The authorized dual-use routing/framing lesson",
"TCC": "macOS Transparency, Consent, and Control",
"URL": "Uniform Resource Locator",
"API": "Application Programming Interface"
}
},
"templates/ctx-check.sh": {
"what": "This is the agent-side context meter for CT10. It reads the latest Claude transcript usage record, adds input, cache-read, and cache-creation tokens, compares them with CTX_WINDOW, and prints the physical window occupancy that should drive pause and handoff decisions.",
"example": "It reports a value like `~47% used (470,000 / 1,000,000 tokens)` from the latest usage record rather than trusting a harness percentage that may omit overhead.",
"acronyms": {
"CT10": "The know-your-meter context-thrift rule",
"JSONL": "JSON Lines transcript format",
"CTX_WINDOW": "Configured context-window size in tokens",
"JSON": "JavaScript Object Notation",
"Claude": "The model/runtime whose transcript is read",
"RAM": "Random-Access Memory"
}
},
"templates/guardrails.yaml": {
"what": "This is the project guardrail skeleton filled from intake. It names invariants such as no-touch-existing, standalone units, a nonempty gate, control-bus ordering, current status, and use-before-done, and pairs each with an enforcement mechanism or a placeholder for a project-specific failing check.",
"example": "G-USE-BEFORE-DONE requires realistic self-use and a cold user completing every core flow, and points the reviewer to done-audit evidence.",
"acronyms": {
"YAML": "The guardrail configuration format",
"G-": "Build-failing guardrail identifier",
"G-NO-TOUCH-EXISTING": "Guardrail limiting a worker to its own workspace",
"G-GATE": "Guardrail making gate.sh the definition of green",
"G-STATUS-CURRENT": "Guardrail requiring evidence-backed ledger state",
"G-USE-BEFORE-DONE": "Guardrail requiring self-use and cold-user completion"
}
},
"templates/handoff-packet.md": {
"what": "This is the packet template for a bounded vendor side-task. The orchestrator fills it before dispatch with task identity, objective, workdir, scope boundaries, context, an exact JSON evidence format, verification commands, stop conditions, and—on escalation—the prior report verbatim.",
"example": "It says `No packet, no dispatch` and requires the final message to be one JSON object matching report.schema.json with task_id, agent, model, status, workdir, files_touched, commands_run, evidence, and uncertainties.",
"acronyms": {
"MD": "Markdown document format",
"JSON": "JavaScript Object Notation",
"TASK-ID": "Side-task identifier",
"WORKDIR": "The worker's allowed working directory",
"IN-SCOPE": "Allowed files or surfaces",
"OUT-OF-SCOPE": "Explicitly forbidden files or surfaces",
"KB": "Knowledge-base pattern identifier",
"PRIOR-ATTEMPT": "Verbatim previous report used during escalation"
}
},
"templates/pipeline.yaml": {
"what": "This is the canonical per-project pipeline template. It defines paths, atoms and evidence, the worker loop, milestones, gate command, control-bus obligations, completion requirements including seed/self-use/product walk/runbook, and the integrity rule that an evidence-less ledger claim voids the build.",
"example": "Its work loop says a worker must re-read CONTROL.yaml, execute and ACK open directives, implement one atom, re-read before a checkpoint, run the gate, and land evidence only after PASS.",
"acronyms": {
"YAML": "The machine-readable pipeline format",
"Git": "Distributed version-control system",
"ATOM-ID": "Countable work-item identifier",
"ACK": "Directive acknowledgement",
"DOGFOOD": "Using the built artifact as a real user",
"PRODUCT WALK": "Cold-user completion of every core flow",
"G-ID": "Guardrail identifier",
"STATUS": "Per-unit ledger file",
"CONTROL": "Per-unit directive-bus file"
}
},
"templates/project.env": {
"what": "This is the environment template that parameterizes every fleet tool. It holds project paths, executor and model settings, quota probes, atom ground-truth commands, per-unit ledger names, vendor side-task options, SSH offload settings, and the done-audit contract.",
"example": "It defines `ATOMS_DONE_CMD` as a command that must count real commits/files rather than ledger claims and warns that `{unit}` and `{slug}` are literal substitution tokens.",
"acronyms": {
"ENV": "Environment-variable configuration",
"YAML": "The format used by pipeline and control files",
"SSH": "Secure Shell",
"CLI": "Command-Line Interface",
"API": "Application Programming Interface",
"JSON": "JavaScript Object Notation",
"G-ID": "Guardrail identifier",
"ATOM": "Countable work item",
"OS": "Operating System",
"L5": "Usage-cap lesson",
"L29": "Pre-launch quota-probe lesson",
"F12": "Worker OS-sandbox guard identifier",
"KB": "Knowledge-base pattern identifier"
}
},
"templates/report.schema.json": {
"what": "This is the JSON Schema for the single report object returned by every dispatched side-task. It requires task, agent, model, status, workdir, touched files, commands with exit codes, evidence, and uncertainties, allows a nullable stop condition, and forbids extra properties.",
"example": "The status enum is exactly `done`, `blocked`, `failed`, or `partial`, and each commands_run item must contain `cmd` and integer `exit`.",
"acronyms": {
"JSON": "JavaScript Object Notation",
"SCHEMA": "A formal structure and validation contract",
"HTTP": "HyperText Transfer Protocol",
"API": "Application Programming Interface",
"KB": "Knowledge-base pattern identifier"
}
},
"templates/sandboxed-claude.sh": {
"what": "This is the launcher wrapper that runs a Claude worker under the rendered macOS Seatbelt profile. It disables auto-updates and delegates the actual boundary to worker-sandbox.sb, confining writes and denying sensitive UI, TCC, settings, sudo, and remote-access paths.",
"example": "It executes the sandbox-exec wrapper with worker-sandbox.sb and the configured Claude binary.",
"acronyms": {
"OS": "Operating System",
"TCC": "macOS Transparency, Consent, and Control",
"SSH": "Secure Shell",
"CLI": "Command-Line Interface",
"SBPL": "Sandbox Profile Language used by Seatbelt"
}
},
"templates/statusline-context.sh": {
"what": "This is a Claude Code statusline renderer for human-visible context occupancy. It reads JSON from stdin, uses native percentages when available, estimates from raw token counts when necessary, colors a ten-segment bar by threshold, honors NO_COLOR, and falls back to the model name when no context data exists.",
"example": "It renders a line such as `Claude · ctx ▓▓▓▓▓░░░░░ 47% used (53% free)`.",
"acronyms": {
"JSON": "JavaScript Object Notation",
"NO_COLOR": "Environment convention requesting no ANSI color",
"ANSI": "American National Standards Institute terminal escape-code convention",
"CLI": "Command-Line Interface",
"ctx": "Context-window usage shorthand"
}
},
"templates/worker-prompt.md": {
"what": "This is the agent-facing worker contract rendered by pool.sh for each unit. It binds the worker to the canonical spec, human register, one workspace and branch, one-shot foreground verification, control-bus checkpoints, evidence-backed atoms and milestones, cold-start product walks, shared-machine limits, and a parseable-bus stop rule.",
"example": "It explicitly says the worker must not write DONE_FILE; the orchestrator mints the shared marker only after done-audit passes.",
"acronyms": {
"MD": "Markdown document format",
"YAML": "The structured prompt format after its title line is stripped",
"ACK": "Directive acknowledgement",
"VCS": "Version Control System",
"Git": "Distributed version-control system",
"BC": "Behavioral contract",
"KB": "Knowledge-base pattern",
"G-NO-TOUCH-EXISTING": "Own-workspace boundary guardrail",
"L39": "Reviewer-minted markers lesson",
"L53": "One-shot worker cannot wait lesson",
"L63": "No blind windows lesson",
"G-": "Guardrail identifier"
}
},
"templates/worker-sandbox.sb": {
"what": "This is the macOS Seatbelt policy rendered for a worker workspace. It denies file writes by default, allows the unit workspace and selected caches, makes most of the home directory unreadable, and hard-denies screen capture, UI control, settings changes, sudo, launch control, and SSH/scp/sftp.",
"example": "The profile allows writes under `{WORKSPACE}` and `/private/tmp` but denies process execution of `/usr/bin/osascript`, `/usr/bin/sudo`, and `/usr/bin/ssh`.",
"acronyms": {
"SBPL": "Sandbox Profile Language",
"OS": "Operating System",
"TCC": "macOS Transparency, Consent, and Control",
"SSH": "Secure Shell",
"UI": "User Interface",
"CLI": "Command-Line Interface",
"L37": "The browser/headless sandbox lesson",
"L33": "The shared live desktop window lesson"
}
},
"tools/assess.sh": {
"what": "This is the read-only fleet state classifier used by /continue. It combines progress, done markers, process liveness, unit ledgers, open CONTROL directives, ground-truth atom totals, and blockers to classify each unit as RUNNING, DEAD, PAUSED, STOPPED, BLOCKED, DONE-CLAIMED, DONE-MARKED, or a directive-conflicted state with a suggested action.",
"example": "It checks liveness before pending directives so an alive worker is reported RUNNING rather than incorrectly suggested for relaunch.",
"acronyms": {
"sh": "Shell script file suffix",
"CONTROL": "Per-unit command bus",
"STATUS": "Per-unit ledger",
"DONE": "Completion claim or marker",
"L18": "The lesson fixing classifier ordering and scope measurement",
"F8": "Ground-truth substitution/configuration fix",
"F13": "Single-worker lease guard identifier",
"Git": "Distributed version-control system",
"PID": "Process identifier"
}
},
"tools/audit-done.sh": {
"what": "This is the integrity gate for a unit's DONE claim. It compares ledger atom claims with ground-truth counts and spec totals, checks substantive completion files, requires a structural PRODUCT WALK section with per-flow PASS/FAIL evidence, and exits nonzero when the claim is incomplete, fabricated, or un-auditable.",
"example": "A line such as `F1 — PASS (evidence: screenshot.png)` satisfies the product-walk shape, while a bare word like `dogfood` does not.",
"acronyms": {
"sh": "Shell script file suffix",
"DONE": "Completion claim or marker",
"STATUS": "Per-unit ledger",
"DOGFOOD": "Using the product as a real user",
"PRODUCT WALK": "Cold-user flow verification",
"PASS/FAIL": "The required per-flow verdict form",
"ATOM-ID": "Countable work-item identifier",
"F7": "The product-walk format synchronization fix",
"F8": "The unit/slug ground-truth substitution fix",
"L28": "The product-walk integrity lesson",
"YAML": "The control-bus/config format"
}
},
"tools/bus-sweep.sh": {
"what": "This is the fleet-wide control-bus parser check used after unattended windows or injector repairs. It requires Python and PyYAML before judging parse state, loads every unit CONTROL.yaml, prints corrupt paths, and exits nonzero if any bus fails to parse.",
"example": "Its clean result is `bus sweep clean (N buses parse)`; a malformed unit bus prints `CORRUPT: <path>`.",
"acronyms": {
"sh": "Shell script file suffix",
"YAML": "The control-bus data format",
"PyYAML": "Python's YAML parser library",
"CONTROL": "Per-unit directive bus",
"L22": "The bus-can-be-the-fault lesson",
"L7": "The prove-the-bus lesson",
"L": "Lesson/scar identifier"
}
},
"tools/claude-all-watch.py": {
"what": "This is the Claude Code transcript observer used by /learn. It adopts existing JSONL sessions at EOF, follows new sessions from byte zero, skips its own session with a required --self ID, filters markup and re-render noise, and emits human messages plus declaration-shaped outcomes such as gates, exits, caps, shipping, markers, and audits.",
"example": "An assistant line containing `GATE FAIL` becomes an OUTCOME event, while a bare prose word `failed` is ignored to avoid monitor floods.",
"acronyms": {
"py": "Python source file suffix",
"JSONL": "JSON Lines transcript format",
"JSON": "JavaScript Object Notation",
"APIERROR": "An emitted application-programming-interface error event",
"EXIT_CODE": "Process exit status marker",
"L8": "Monitor-flood lesson",
"L17": "Domain-vocabulary false-positive lesson",
"L41": "Adopt-existing-session-at-EOF lesson",
"L91": "Harvest-the-whole-loop lesson",
"L109": "Context-blocked session lesson",
"PTY": "Pseudo-terminal"
}
},
"tools/codex-all-watch.py": {
"what": "This is the Codex-session edition of the /learn observer. It reads rollout JSONL files, distinguishes interactive sessions from codex_exec workers, follows human and final agent messages for interactive sessions, emits worker failures and caps without a reasoning firehose, and adopts existing rollouts at EOF.",
"example": "A worker quota event is emitted as `[codex <sid8>] CAP usage-limit: ...`, while routine worker task_complete events are suppressed.",
"acronyms": {
"py": "Python source file suffix",
"JSONL": "JSON Lines transcript format",
"JSON": "JavaScript Object Notation",
"CAP": "Usage-cap event label",
"cwd": "Current working directory",
"L8": "Monitor-noise lesson",
"L41": "Adopt-existing-session-at-EOF lesson",
"L90": "Multi-runtime observer-scope lesson",
"L91": "Harvest-the-whole-loop lesson",
"429": "HTTP rate-limit status",
"Codex": "The external coding-agent runtime"
}
},
"tools/dashboard.sh": {
"what": "This is the human-facing one-shot live dashboard for workers. It prints one block per queued unit with an alive marker, current atom, last gate, blockers, and the last meaningful narration line after stripping diffs and execution noise; it is meant for repeated `watch` display, not raw log tailing.",
"example": "A row looks like `● unit | current-atom | last-gate | blockers`, followed by a single concise narration line.",
"acronyms": {
"sh": "Shell script file suffix",
"STATUS": "Per-unit ledger",
"CT1": "The delegate-reading context rule",
"Git": "Distributed version-control system",
"PID": "Process identifier"
}
},
"tools/dispatch.sh": {
"what": "This is the detached multi-vendor side-task courier. It requires a packet, enforces one live vendor run per task, starts codex/claude/agy/grok/ollama with their headless postures, records raw output and exit state, provides bounded wait and nonblocking status, and leaves normalization to normalize-report.sh.",
"example": "`dispatch.sh wait AUD-003` returns `RUNNING` with exit 10 after its bounded chunk, so the caller can poll again without exceeding the harness shell cap.",
"acronyms": {
"sh": "Shell script file suffix",
"CLI": "Command-Line Interface",
"PTY": "Pseudo-terminal",
"JSON": "JavaScript Object Notation",
"SSH": "Secure Shell",
"KB": "Knowledge-base pattern identifier",
"L5": "Usage-cap lesson",
"L116": "Turnkey delegation lesson",
"API": "Application Programming Interface",
"REPORT_SCHEMA": "Path to the side-task report schema",
"VENDOR_WAIT_S": "Bounded wait interval setting",
"VENDOR_MAX_S": "Detached-run deadline setting"
}
},
"tools/dogfood-verify.sh": {
"what": "This is the machine-runnable half of a unit dogfood check. It runs the unit's own tests, seed twice for idempotency, the same gate reviewers use, service boot and health probes when configured, and a comparison of spec flow IDs with DOGFOOD.md coverage; human walkthroughs remain separate.",
"example": "If a package declares a `seed` script, it runs it twice and reports `seed x2 (idempotent) PASS` only when the second run also succeeds.",
"acronyms": {
"sh": "Shell script file suffix",
"DOGFOOD": "Real use of the built artifact",
"API": "Application Programming Interface",
"HTTP": "HyperText Transfer Protocol",
"L15": "Verify through the unit's own command lesson",
"L16": "Dogfood is run, not merely documented",
"F": "User-flow identifier",
"JSON": "JavaScript Object Notation",
"PID": "Process identifier"
}
},
"tools/gate.sh": {
"what": "This is the per-unit merge gate and the single definition of green. It loads project.env, runs the configured project gate or package gate, refuses an empty gate as a lie, prints each check, and exits nonzero with GATE FAIL when any check fails.",
"example": "With no GATE_CMD, no package `gate` script, and no uncommented checks, it emits `GATE FAIL: no checks defined` instead of passing vacuously.",
"acronyms": {
"sh": "Shell script file suffix",
"GATE_CMD": "Configured command used as the unit gate",
"PASS/FAIL": "Gate result states",
"CI": "Continuous Integration",
"L15": "The verify-via-own-command lesson",
"WF-4": "The empty-gate failure class",
"Git": "Distributed version-control system"
}
},
"tools/inject.sh": {
"what": "This is the append-only control-bus writer. It validates directive type and argument shape, requires a YAML parser, normalizes inline directives, guarantees a trailing newline, emits multiline instructions as a block scalar, parse-checks the whole file, and rolls back a poisoning append.",
"example": "`inject.sh <unit> pause general \"stop after checkpoint\"` appends a numbered OPEN directive and reports `parse-verified`.",
"acronyms": {
"sh": "Shell script file suffix",
"YAML": "The control-bus data format",
"PyYAML": "Python's YAML parser library",
"OPEN": "Directive status awaiting execution and acknowledgement",
"ACK": "Worker acknowledgement",
"L7": "The bus liveness lesson",
"L22": "The corrupt-bus lesson",
"KB": "Knowledge-base pattern identifier",
"ISO8601": "International date/time format"
}
},
"…": "(9 more keys)"
}