FILEkernel/INDEX.tsv
INDEX.tsv — the kit's card catalog (GENERATED by tools/build-index.py — DO NOT EDIT).
The deployable edition — not a fork. Regenerated from the god kit by build-kit-v2.sh on every ship; never edited directly, so it cannot drift. Strips the Holt narrative, NotebookLM sources, and sub-kits down to kernel + skills + tools + templates: what a fresh engagement needs to boot a fleet. Carries 28 commands after the 13 GOD-KIT ONLY commands are excluded; same scars, same doctrine.
Give a product an in-app guided tour that WALKS A WORKING DEMO of itself — every feature covered, driven from real components fed seeded data, understandable by someone who has never seen a terminal.
Push CSS to its maximum to build OUTSTANDING animations for a target (component, page, app): pick the motion moments, choose techniques from a real technique library (keyframes, 3D transforms, clip-path, SVG stroke-draw, conic/mask shine, :has() proximity, scroll-driven), and ship copy-paste CSS that hits 60fps and honors reduced-motion.
Show Wolf's computer-wide project backlog (~/Projects/BACKLOG.md) — in progress, paused, blocked, queued — and refresh it when stale.
Boot a fleet-orchestrated project of any kind (apps, writing, inventory, migrations) with the think-like-fable method: intake, apparatus, single-unit pilot, integrity-hardened fan-out, exception watching, done-audits.
Report THIS session's boot cost — call-1 token usage read from its own transcript — and compare against the workspace's boot-cost ledger (_handoff/boot-costs.tsv).
Audit a project's documentation against REALITY and fix the drift — verify every command, path, port, count, and dated claim the docs make; annotate superseded policy instead of deleting it; and create the missing minimum when a project has no docs at all.
Gracefully close the CURRENT window so nothing is lost and its token cost stops (a long-lived window is the fleet's biggest token sink, L149): capture state to disk, flush the session log, report what survives vs dies, give a SAFE-TO-CLOSE verdict.
Assess a project already in progress: reconstruct its state empirically from disk, diagnose, ask only what disk can't answer, propose next steps.
Reclaim disk from Docker without breaking live work: survey what's eating space, then clear stopped containers, dangling + unused task images, and stale build cache — running containers and their images always protected, volumes never touched by default.
Produce a DOGFOOD PLAN for human review after a unit/phase/feature completes — a concrete, self-contained manual walk of the shipped thing; the bridge from "gate green" to "a human used it" (L12).
Execute the manual dogfood YOURSELF in auto mode — drive the completed product as a real user (browser, CLI, API, device sim) step by step through DOGFOOD.md and report evidence-backed verdicts.
Assess time remaining for every running task — background agents, bash tasks, monitors, workflows, remote/detached work — with honest per-task estimates (rate-based where a progress signal exists, calibrated ranges where not) plus soonest-completion and all-done times.
Walk a human through a fix or procedure ONE STEP AT A TIME, each step gated on the human's own returned evidence (screenshot / pasted output) before the next step is revealed.
Ground yourself in a project's ACTUAL documentation AND its activity logs before proposing or making ANY change to a project you are NOT currently conducting.
Prep a SCOPED, resumable handoff: write THIS project's state to _handoff/<token>.md, ending with the literal re-entry command /continue <token>.
Estimate tokens and USD to COMPLETE a given prompt as an agentic run — calibrated on empirical session logs, not vibes.
Arm the standing lesson-harvest observer: watch every other live agentic session across runtimes (Claude Code windows, Codex/other executors, headless workers), learn from the human's redirections and the agents' successes, failures, and tool defects, and encode it back into the think-like-fable kit as scars, shipping both editions.
Run unattended while the human sleeps — set the safety envelope, make every result durable past the window, verify instead of assert, queue decisions instead of guessing, and leave a MORNING REPORT that can be audited cold.
Polish code to a clean-code bar without changing behavior — against Clean Code, an optional named style guide (Google, Airbnb, Standard, PEP 8, …) passed as argument, and the repo's own conventions, after a short questionnaire (modularity, functional-expressions, naming, comments, error handling, dead code).
Read the canon before doing the work — the MANDATORY session-start scar/lesson read for any session with a kit.
Show how to RUN a project LOCALLY — derive its real run lane from its own docs and config, preflight it (every port proven clear, holders identified), present a copy-paste runbook (start · health check · logs · stop), then offer to start it and verify it is genuinely up with real data.
Wipe ephemeral per-session /private/tmp scratchpad dirs (copied tools, filter files, feed dumps, debug logs) that pile up over time, protecting the live local watch (~/.observer-watch) and every session's tasks/ output dir.
Design a maximally-influential, STRICTLY SFW virtual-influencer persona for an app or brand: name, backstory, visual identity, voice, content pillars, per-platform growth plan (Instagram, TikTok, Reddit, Patreon, Telegram), KPIs — grounded in a stored playbook, with build-failing transparency/brand-safety guardrails.
Suggest innovative, domain-matched, MOTION-FORWARD design skins for a site or app — palette, type, layout archetype, signature motif, named motion system — grounded in a stored library of real shipping templates + the 2026 animated-web canon.
The anti-slop design GATE: critique a UI against the AI-slop uniform (purple/violet gradients, one generic thick sans, centered card-stacks, pillow buttons, soft-shadow-everything, blob backgrounds) and enforce craft — a planted stake, the generic cut, one deliberate human detail.
Enter (or exit) the small-window operating mode — the tight-context discipline for sessions on a small window or fast-capping plan.
Lay out the complete USER TESTING plan for a project or application — every user flow enumerated, each with numbered step-by-step instructions a human tester can follow cold, the expected result at every step, and a pass/fail record to fill in.
Arm the observer pattern on the FREE local model — 6 session watchers feeding the local gpt-oss router, fully detached and idempotent, $0/idle, no long-lived Claude window.
INDEX.tsv — the kit's card catalog (GENERATED by tools/build-index.py — DO NOT EDIT).
company.yaml — CANONICAL model org chart: the standing company structure.
version: "1.3.0
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.
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.
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.
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.
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.
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.
THE SCAR FILE — 218 canonical lessons (incident + rules + ties), append-only and single-writer.
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.
models.yaml — CANONICAL model registry for the think-like-fable kit.
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.
P1–P12 — the canonical ordered doctrine; lower id wins on conflict.
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.
version_proven: "2026.7.15
Give a product an in-app guided tour that WALKS A WORKING DEMO of itself — every feature covered, driven from real components fed seeded data, understandable by someone who has never seen a terminal. The cold-start user path is part of done (L28), not polish. Use on /add-tour, "add a tutorial", "onboard new users", "nobody knows how to use this", or when a product has grown many features and no first-run story.
Push CSS to its maximum to build OUTSTANDING animations for a target (component, page, app): pick the motion moments, choose techniques from a real technique library (keyframes, 3D transforms, clip-path, SVG stroke-draw, conic/mask shine, :has() proximity, scroll-driven), and ship copy-paste CSS that hits 60fps and honors reduced-motion. Use on /animate-it, "animate this", "add animations", "make it move", "this feels static". Pairs with /skin-it (which PICKS the design + motion direction) and /slopless (which GUARDS taste) — animate-it BUILDS the motion.
display_name: "Animate It
Show Wolf's computer-wide project backlog (~/Projects/BACKLOG.md) — in progress, paused, blocked, queued — and refresh it when stale. Use when the user says /backlog, "what projects are in progress", or "what should I work on".
display_name: "Project Backlog
Boot a fleet-orchestrated project of any kind (apps, writing, inventory, migrations) with the think-like-fable method: intake, apparatus, single-unit pilot, integrity-hardened fan-out, exception watching, done-audits. Use on /begin, /start, /ready, or "orchestrate / kick off a multi-unit project".
display_name: "Begin Project
Report THIS session's boot cost — call-1 token usage read from its own transcript — and compare against the workspace's boot-cost ledger (_handoff/boot-costs.tsv). Use on /boot-cost in a fresh window (or anytime later: call-1 is locked at boot), and after any prompt-diet, CLAUDE.md, memory, or skill-listing change to verify the delta actually landed.
display_name: "Boot Cost
Audit a project's documentation against REALITY and fix the drift — verify every command, path, port, count, and dated claim the docs make; annotate superseded policy instead of deleting it; and create the missing minimum when a project has no docs at all. Use on /check-docs, "are the docs current", "update the docs", before handing a project to anyone, or after any policy/infra change.
Gracefully close the CURRENT window so nothing is lost and its token cost stops (a long-lived window is the fleet's biggest token sink, L149): capture state to disk, flush the session log, report what survives vs dies, give a SAFE-TO-CLOSE verdict. Use on /close-it, "close this window", "safe to close?", "wind this down".
display_name: "Close It
Assess a project already in progress: reconstruct its state empirically from disk, diagnose, ask only what disk can't answer, propose next steps. Works for kit-managed fleets AND ordinary projects (codebase, manuscript, dataset). Use on /continue, "pick up where we left off", "what's the state", "what's next". Counterpart to /begin.
display_name: "Continue Project
Reclaim disk from Docker without breaking live work: survey what's eating space, then clear stopped containers, dangling + unused task images, and stale build cache — running containers and their images always protected, volumes never touched by default. Use on /docker-purge, "clear the docker cache/builds", "docker is eating my disk", after terminus eval runs.
display_name: "Docker Purge
Execute the manual dogfood YOURSELF in auto mode — drive the completed product as a real user (browser, CLI, API, device sim) step by step through DOGFOOD.md and report evidence-backed verdicts. Use on /dogfood-it after a completion (or right after /dogfood). Front-runs human review; never replaces it.
display_name: "Dogfood It
Produce a DOGFOOD PLAN for human review after a unit/phase/feature completes — a concrete, self-contained manual walk of the shipped thing; the bridge from "gate green" to "a human used it" (L12). Use on /dogfood or when handing a completion over for review ("ready to test", "up for your click-through").
display_name: "Dogfood Plan
Assess time remaining for every running task — background agents, bash tasks, monitors, workflows, remote/detached work — with honest per-task estimates (rate-based where a progress signal exists, calibrated ranges where not) plus soonest-completion and all-done times. Use on /eta, "how long", "time remaining", "when will it be done".
display_name: "ETA
Walk a human through a fix or procedure ONE STEP AT A TIME, each step gated on the human's own returned evidence (screenshot / pasted output) before the next step is revealed. Use on /explain <goal>, "walk me through this", "step by step", "guide me through it", or whenever the remedy lives on a surface only the human can drive — a vendor dashboard, a phone, a physical device, a privileged shell.
Ground yourself in a project's ACTUAL documentation AND its activity logs before proposing or making ANY change to a project you are NOT currently conducting. Reads its docs, real state, and logs empirically (CLAUDE.md, README, docs/, DEPLOYMENT, BACKLOG, NOTES, _handoff, git, AND the observer log + the project's own logs) and reports what governs it and what's been happening — so a suggestion comes from the project's truth, not from memory or its name. Use on /ground <project> [path], or BEFORE suggesting changes to any project you have not been actively conducting this session.
display_name: "Ground
Prep a SCOPED, resumable handoff: write THIS project's state to _handoff/<token>.md, ending with the literal re-entry command /continue <token>. Use /handoff <token> when pausing, nearing the context threshold, or handing to a fresh window — essential in a shared workspace where a bare /continue drags in sibling projects.
display_name: "Handoff
Estimate tokens and USD to COMPLETE a given prompt as an agentic run — calibrated on empirical session logs, not vibes. Use on /how-much, "how much will this cost", or any pre-run cost/budget estimate.
display_name: "How Much
how-much.py — empirically-calibrated token/cost estimator for a Claude agentic run.
source": "claude-api skill bundled model table (\"Current Models\", cached 2026-06-24) + shared/prompt-caching.md §Economics cache multipliers",
Arm the standing lesson-harvest observer: watch every other live agentic session across runtimes (Claude Code windows, Codex/other executors, headless workers), learn from the human's redirections and the agents' successes, failures, and tool defects, and encode it back into the think-like-fable kit as scars, shipping both editions. Use on /learn, "watch the other window/session", "harvest lessons".
display_name: "Learn (observer)
Run unattended while the human sleeps — set the safety envelope, make every result durable past the window, verify instead of assert, queue decisions instead of guessing, and leave a MORNING REPORT that can be audited cold. Use on /overnight, "going to bed", "keep working while I sleep", "check it when I wake up", or before any long run the human will not be watching.
Polish code to a clean-code bar without changing behavior — against Clean Code, an optional named style guide (Google, Airbnb, Standard, PEP 8, …) passed as argument, and the repo's own conventions, after a short questionnaire (modularity, functional-expressions, naming, comments, error handling, dead code). Use on /refactor or "clean up / polish / tidy / restructure this code".
display_name: "Refactor
Read the canon before doing the work — the MANDATORY session-start scar/lesson read for any session with a kit. Loads EVERY scar title (complete coverage), expands the full rules of the ones this session can actually trip, states them back as active guards, and names honestly what it did NOT read. Use on /remember, at the start of every kit session, and whenever you are about to touch a surface you have not bound guards for.
Show how to RUN a project LOCALLY — derive its real run lane from its own docs and config, preflight it (every port proven clear, holders identified), present a copy-paste runbook (start · health check · logs · stop), then offer to start it and verify it is genuinely up with real data. Use on /run-it, "how do I run this", "start the app", "spin it up", or before dogfooding anything.
Wipe ephemeral per-session /private/tmp scratchpad dirs (copied tools, filter files, feed dumps, debug logs) that pile up over time, protecting the live local watch (~/.observer-watch) and every session's tasks/ output dir. Use on /scratch-ass, "wipe the scratch folder", "clean the scratchpad".
display_name: "Scratch Ass
scratch-ass.sh — wipe Claude session SCRATCHPAD junk clean, safely.
Suggest innovative, domain-matched, MOTION-FORWARD design skins for a site or app — palette, type, layout archetype, signature motif, named motion system — grounded in a stored library of real shipping templates + the 2026 animated-web canon. Proposes a safe-fit, a bold, and a wildcard skin, each with copy-paste :root tokens. Use on /skin-it or any design-direction, aesthetic, look-and-feel, animation/motion, "make it more engaging", or moodboard request.
display_name: "Skin It
Design-corrections log — real skin corrections as skin-it grounding
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.
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.
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.
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.
The anti-slop design GATE: critique a UI against the AI-slop uniform (purple/violet gradients, one generic thick sans, centered card-stacks, pillow buttons, soft-shadow-everything, blob backgrounds) and enforce craft — a planted stake, the generic cut, one deliberate human detail. Pairs with /skin-it (it PICKS the direction; slopless GUARDS the build). Use on /slopless, "does this look AI-generated / generic", or any pre-ship UI taste check.
display_name: "Slopless
Enter (or exit) the small-window operating mode — the tight-context discipline for sessions on a small window or fast-capping plan. Invoke with /small-window (or /small-window off to exit). God-kit privilege: in derived kits that pin the mode (e.g. entabeni) it is a REQUIREMENT and cannot be turned off.
display_name: "Small Window
Lay out the complete USER TESTING plan for a project or application — every user flow enumerated, each with numbered step-by-step instructions a human tester can follow cold, the expected result at every step, and a pass/fail record to fill in. Use on /test-it, "write the test plan", "how do I user-test this", after a build completes, or before handing anything to a human tester.
Arm the observer pattern on the FREE local model — 6 session watchers feeding the local gpt-oss router, fully detached and idempotent, $0/idle, no long-lived Claude window. Use on /watch-local, "start the local watch/observer", "arm the free watcher". The cheap counterpart to /continue observer.
display_name: "Watch Local
Watch the Antigravity CLI (agy); emit new human messages and error lines for the observer
GENERATED FROM tools/claude-all-watch.py — DO NOT EDIT (regenerate: python3 tools/generate-watch-payload.py)
GENERATED FROM tools/codex-all-watch.py — DO NOT EDIT (regenerate: python3 tools/generate-watch-payload.py)
Watch grok CLI sessions; emit new human messages and error lines for the observer router.
as expected
cap[- ]?death
Local, free, always-on observer/router for Wolf's agent fleet.
Observer Routing Rubric
GENERATED FROM tools/observify-inbox-watch.py — DO NOT EDIT (regenerate: python3 tools/generate-watch-payload.py)
remote-loop.sh HOST REMOTE_CMD LABEL — one self-healing SSH watcher loop for a remote machine.
Regression gate for the watch-local payload (L154-L157 + L129/L155 counter/burst/wake/feed-health behaviors) -- run: python3 verify-payload.py
watch-local.sh — arm the LOCAL-MODEL observer pattern: 6 session watchers feeding the free
Claude Code PreToolUse enforcement for Constitution Article I.
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.
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.
book-it: curate a read-only reMarkable library into EPUB editions.
Observify kanban board lens for book-it.
Command-line entry point for book-it.
Read-only cataloguing of the reMarkable Desktop content store.
EPUB3 compiler for an approved book-it manifest.
G4 — the CONSUMER-SIMULATION RENDER gate (L202, L201).
delete_verify.py — L205: a delete at one replica is a change the other replica will undo.
Primary, direct-to-device delivery through rmapi.
The OPERATION print design system — the device format book-it renders into.
Device geometry, derived — not asserted.
% =====================================================================
The edition's colour system, and the Pygments theme built on it.
Edition ledger and deliberately conservative curation proposals.
Selection lenses and manifest construction for book-it.
Opt-in Pi backup and Google Drive delivery lane.
The PRIMARY renderer: an OPERATION field manual PDF, sized to the panel 1:1.
from pathlib import Path
from pathlib import Path
from collections import Counter
from collections import Counter
from pathlib import Path
from pathlib import Path
build-index.py — regenerate kernel/INDEX.tsv, the kit's card catalog.
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.
Usage: python3 tools/check-canon-reads.py <session-transcript.jsonl>
Usage: bash tools/check-generated.sh
Usage: python3 tools/check-install-lane.py <session-transcript.jsonl>
check-workflow-args.py — G-ARGS-COERCED (L208): `args` crosses the Workflow boundary as a
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.
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.
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.
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.
Multi-vendor side-task dispatch (executors.yaml `layers` + `routing`).
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.
fanout-census.py — L203: when N workers fill the same field, that field's SHAPE is a spec.
export const meta = {
export const meta = {
export const meta = {
export const meta = {
export const meta = {
export const meta = {
frontmatter.py — the kit's ONE loader for `---`-delimited YAML front matter.
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.
Render the constitution and its role-scoped instruction surfaces from YAML.
generate-watch-payload.py
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.
install-hooks.py — keep the fleet's project-local SessionStart hook config current (hooks-local-0731).
install-surfaces.py — install refreshed constitution surfaces into fleet workspaces.
This is the supervisor loop that repeatedly relaunches one-shot workers until audited done markers cover all requested slugs or a safe stop condition occurs. It audits fresh markers, compares Git HEAD fingerprints for progress, stops on pool failure, no-progress rounds, maximum rounds, or a competing supervisor lock.
kit_session_start.py — Codex CLI SessionStart hook: a Codex session that has a kit STARTS
kit-remember.sh — SessionStart hook: a session that has a kit STARTS with the canon (L161).
This is the shared shell helper library for recurring structural fixes. It provides safe numeric grep counts, trailing-newline repair, and a distinct PyYAML/python3 dependency preflight so injectors and bus sweeps do not confuse a missing parser with a corrupt bus.
This is the report normalizer for vendor side-task runs. It unwraps Grok envelopes, accepts deterministic Codex last-message or raw JSON first, uses brace-aware extraction, optionally asks free local Ollama glue to coerce a transcript, validates required fields with jq, and treats invalid normalization as a failed run.
This is the opt-in receiver that closes the loop between the Observify dashboard and a running session. It tails the current session's JSONL inbox, emits queued and newly written interjections as task notifications, and intentionally watches only the session ID passed at startup.
This is the SSH machine-fallback tool for moving compute when the current host is under memory pressure. It measures free memory on macOS or Linux, bootstraps a remote kit and adapted environment with rsync, verifies remote git and executor access, launches a detached remote pool, and preserves the distinction that offload moves compute, not provider quota.
packet-lint.sh — Constitution Article VIII: the packet is the contract.
This is the concurrent one-shot worker launcher. It reads project.env, probes the actual executor pool, resolves per-slug executors and models, renders worker-prompt.md, refuses unresolved placeholders or missing workspaces, enforces a per-unit lease, detaches the worker from the caller's process group, logs the real exit code, and waits for up to K workers.
This is the fleet progress calculator. For each queued slug it substitutes unit and slug paths into configured total/done commands, counts ground-truth atoms rather than ledgers, loudly excludes a misconfigured zero total, floors the denominator when scope grows, and prints one percentage line suitable for change-triggered monitoring.
remember.py — the session-start canon read, made affordable and COMPLETE.
tools-gate.sh — Constitution Article VII: headless proof & first output.
Normalize supported Claude Code and Codex JSONL transcripts for kit checks.
This is the shell wrapper for the NotebookLM layer-3 verdict oracle. It checks for notebooklm and jq, asks the notebook to grade a claim strictly against loaded sources with citations, extracts the last parseable JSON object, defaults source-less responses to unverified, and emits a JSON result for human finalization.
verify-conductor.py — Constitution Article I enforcement on a session transcript.
This is the cheapest cross-unit survey tool. It prints one block per unit with the count of open control directives and the compact STATUS fields for milestone, current atom/ticket, last gate, and blockers, making it suitable for a heartbeat instead of raw log reading.
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.
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.
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.
<!-- >>> think-like-fable codex bridge — managed by ship-kit.sh; edit canonical: think-like-fable/templates/codex-agents-block.md >>> -->
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.
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.
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.
God-kit instance rollout — the five parts (L188)
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.
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.
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.
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.
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.
<!-- >>> think-like-fable vendor bridge — managed by ship-kit.sh (not yet wired, see GROK.md/AGY.md TASK-3 note); edit canonical: think-like-fable/templates/vendor-agents-block.md
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.
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.
AGY.md — running the kit under Google agy CLI (Antigravity)
CODEX.md — running the kit's skills under Codex CLI
<!-- GENERATED FROM kernel/constitution.yaml by tools/gen-surfaces.py — DO NOT EDIT (Art. X) -->
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.
GROK.md — running the kit under xAI Grok Build (grok-cli)
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.
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.
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.
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.
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.
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.