get-fable

Evaluate project specifications at inception (Step One), deterministically assess Scale & Load, Domain Decoupling, and Resource Intensity vectors, and automatically enforce a distributed Microservices Architecture when warranted, preventing monolith scaffolding.

Design and author structured technical proposals, responsive artifacts, architecture diagrams, Mermaid charts, and interactive components. Use when creating standalone markdown reports, architectural specifications, Mermaid diagrams, or interactive artifact widgets — even if the user does not explicitly say "fable-artifact" (e.g. "create an artifact", "draw an architecture diagram", "write a technical proposal", "generate a mermaid flowchart"). Do NOT use for quick one-line conversational answers.

Configure and audit AI agent harness settings, permissions allowlists, environment variables, editor keybindings, and lifecycle hook integrations. Use when modifying settings.json, adjusting tool permissions, setting up environment variables, or configuring agent lifecycle hooks — even if the user does not explicitly say "fable-config" (e.g. "update settings", "allow command permissions", "configure agent hooks", "setup environment variables"). Do NOT use for application-level business configuration.

Use at the start of any multi-step task and during exploration — before reading files, searching, or re-checking completed work, especially when tempted to read whole files, re-verify known facts, or run independent lookups one at a time.

Execute autonomous multi-step cowork sessions with silent tool chaining, outcome-first progress reporting, and strict safety boundary enforcement. Use when executing complex background tasks autonomously, running multi-tool refactoring workflows without conversational noise, or performing deep automated passes — even if the user does not explicitly say "fable-cowork" (e.g. "run autonomously in background", "cowork mode", "execute quietly and report results", "silent refactor pass"). Do NOT use when active user dialogue or step-by-step confirmation is required.

Design and generate accessible, cohesive data visualizations, SVG charts, metric cards, and dashboard tiles with theme-adaptive styling and verified viewports. Use when creating SVG charts, rendering metrics plots, designing dashboard visuals, or visualizing performance trends — even if the user does not explicitly say "fable-dataviz" (e.g. "make a chart of this data", "plot these benchmarks", "create an SVG graph", "visualize these metrics"). Do NOT use for non-visual text-only data summaries or generic code edits.

Delegate independent subtasks to parallel workers or subagents with strict disjoint ownership, bounded scope, and explicit acceptance contracts. Use when coordinating multiple independent tasks, parallelizing multi-file work without merge conflicts, or managing subagent task assignments — even if the user does not explicitly say "fable-delegate" (e.g. "split this work among workers", "delegate these subtasks", "run parallel agents", "assign independent pieces"). Do NOT use for tightly coupled sequential tasks or when shared mutable state causes edit collisions.

Gather the smallest set of repository, environment, documentation, and runtime evidence needed before planning or changing code. Use when load-bearing facts are unknown, tracing execution paths, inspecting unfamiliar packages, or resolving codebase contradictions — even if the user does not explicitly say "fable-discover" (e.g. "explore the codebase", "how does this work", "where is this implemented", "find where this route is handled"). Do NOT use when the bounded edit is already known (use fable-execute), for external API/version research (use fable-research), or for running existing test suites (use fable-verify).

Discuss a domain with the user, research it from real sources, then generate a trusted skill bundle for it - a step-by-step workflow with a flowchart, a domain adapter, a trap fixture, and a smoke eval. Use when the user says "/fable-domain <sector>", "make a skill for <domain>", "add a domain to the fable method", or "give a lesser model Fable's workflow for <domain>". The bundle is the deliverable; a workflow without its flowchart, sources, and trap is not done.

Provision curated capabilities, manage reproducible capability locks, verify host integrations, and compile capability execution contracts for routed get-fable work. Use when discovering machine capabilities, managing eco profiles, planning capability installations, repairing ecosystem health, or preparing capability-aware execution contracts — even if the user does not explicitly say "fable-eco" (e.g. "install eco capabilities", "run eco discover", "repair ecosystem", "explain capability run"). Do NOT use as an independent task router (use get-fable).

Evaluate changes to agent prompts, skills, routing policies, and harnesses against reproducible baselines, held-out suites, and regression benchmarks. Use when optimizing agent system prompts, measuring skill triggering accuracy, evaluating routing changes, or running benchmark regressions — even if the user does not explicitly say "fable-eval" (e.g. "benchmark this prompt", "evaluate agent behavior", "test skill performance", "run the eval suite"). Do NOT use for routine application unit tests (use fable-verify).

Implement one accepted, bounded work card with immediate local verification, invariant preservation, and zero scope drift. Use when executing a planned work card, applying a well-defined code change, implementing an isolated function, or performing targeted single-scope edits — even if the user does not explicitly say "fable-execute" (e.g. "implement this card", "write the code for this step", "apply the agreed changes", "build this component"). Do NOT use when new architectural decisions are required (use fable-plan) or when tests are repeatedly failing (use fable-recover).

Use before ending any turn that used tools or produced a deliverable — when tempted to ask "Want me to…?", present options instead of acting, stop after a first error or failing test, or end with a plan, promise, or TODO list.

Compact session decisions, durable evidence, open blockers, and exact next actions into structured continuation state for cross-session resumption. Use when pausing a coding session, transferring context to another agent, summarizing long-running work, or creating durable continuation checkpoints — even if the user does not explicitly say "fable-handoff" (e.g. "save context for next session", "create a handoff", "pause work here", "summarize where we left off"). Do NOT use as a substitute for verifying code changes (use fable-verify).

Automatically synthesize, apply, and verify security remediations for vulnerabilities identified by fable-redteam. Generates surgical AST and code patches, creates continuous TDD regression test guards, performs atomic workspace mutations with automated rollback circuit breakers, and seals cryptographic healing attestations.

Adversarial verification of finished work. Treats any "done" as a set of claims, then re-runs the claimed verifications, diffs what actually changed, detects weakened tests and false completion claims, and delivers an evidence-based verdict (VERIFIED / VERIFIED WITH CAVEATS / REFUTED). Use after any agent or model claims work is complete - "/fable-judge", "judge this work", "verify what it did", "did that actually work?". Also runs the fable-method trap suite against a skill or model via "/fable-judge suite <target>".

Convert sessions and trajectories into durable project engineering knowledge and failure lessons under Failure-lessons/, agent-kernel, and gbrain. Use when extracting session learnings, synthesizing knowledge from conversations, capturing root causes, documenting failure lessons, or recording durable engineering invariants — even if the user does not explicitly say "fable-learning" (e.g. "what did we learn", "convo-learn", "failure lessons", "extract learnings", "save what we learned", "rules we now enforce"). Do NOT use for general code review or diff audits (use fable-review).

Execute bounded recurring polling loops, CI build babysitting, interval-based status monitors, and self-paced test cycles with explicit timeouts and backoff. Use when monitoring async CI/CD pipelines, polling external service status, running interval test watches, or tracking long-running jobs — even if the user does not explicitly say "fable-loop" (e.g. "babysit this build", "poll until completed", "watch CI status", "wait for deployment"). Do NOT use for synchronous one-shot commands or unbounded infinite polling loops.

Manage persistent file-based memory, indexing cross-session user preferences, feedback, and architectural constraints in structured MEMORY.md stores. Use when recording user feedback, storing project conventions, recalling cross-session architectural constraints, or indexing durable project memory — even if the user does not explicitly say "fable-memory" (e.g. "remember this preference", "save to memory", "what are my project rules", "recall user feedback"). Do NOT use for volatile task state stored in .fable/state.json.

A step-by-step problem-solving loop (classify the ask, define done, gather evidence, decide, act surgically, verify by observation, report outcome-first). Use when the user says "/fable-method", "use the fable method", or "approach this like Fable", or proactively when starting any multi-step task that no task-specific skill covers. Subcommands - plan (stop after the plan), audit (grade finished work against the loop), report (rewrite an answer outcome-first).

Use when writing or editing code in an existing codebase — before adding comments, docstrings, try/catch blocks, validation, logging, or TODOs the surrounding file doesn't have, and before explaining your style choices in the reply.

Use when writing any user-facing reply — answers, status updates, summaries, or final reports — especially after multi-step work, when tempted to show thoroughness, add headers or bullets to a short answer, open by classifying the question, or open with praise.

Convert discovery evidence into bounded, testable work cards with explicit acceptance criteria and architectural invariants. Use when designing multi-file features, planning complex refactors, decomposing architectural migrations, or structuring multi-step implementation tasks — even if the user does not explicitly say "fable-plan" (e.g. "plan this feature", "design the architecture", "break this task down", "create an implementation plan"). Do NOT use when load-bearing facts remain unknown (use fable-discover first) or for trivial single-scope bug fixes (use fable-tdd or fable-execute).

Use before claiming anything works, is fixed, is done, or passes; before status updates on changes you haven't run; before agreeing with someone else's claim about your work; and before state-changing commands like restarts, deletes, or config edits.

Diagnose repeated command failures, stale build caches, branch drift, or contradictory evidence before attempting further code edits. Use when commands fail repeatedly, tests stay red after attempted fixes, build output contradicts source code, or the execution path is confused — even if the user does not explicitly say "fable-recover" (e.g. "still failing", "why did this fail again", "stuck in a failure loop", "diagnose this error"). Do NOT use for routine first-time test failures in fresh TDD (use fable-tdd).

Execute native agentic ethical penetration testing and automated security audits against staging or authorized application targets. Discovers API logic flaws, BOLA/IDOR vulnerabilities, missing authentication, sensitive file exposures, and security misconfigurations within bounded scope. Produces verified security findings with reproduction PoCs and automatic Fable remediation work cards.

Audit and certify repository merge and release readiness against required quality gates, clean git working trees, and verified distribution artifacts. Use when preparing a release tag, validating release checklist criteria, publishing npm/PyPI packages, or certifying a branch for merge — even if the user does not explicitly say "fable-release" (e.g. "prepare the release", "is this ready to merge", "ship to production", "publish the package"). Do NOT use when verification is stale, failing, or missing (use fable-verify first).

Resolve current external facts, official documentation, library behaviors, and API contracts against primary sources before implementation. Use when consulting library documentation, checking breaking changes, investigating external APIs, or verifying framework versions — even if the user does not explicitly say "fable-research" (e.g. "check the latest docs", "what is the API for X in version Y", "look up SDK specs", "verify library support"). Do NOT use for repository-local code exploration (use fable-discover) or for writing implementation code directly (use fable-tdd or fable-execute).

Perform an independent, evidence-grounded review of git diffs against requested specifications, architectural invariants, and code standards. Use when reviewing pull requests, inspecting code changes before merge, auditing diffs for regressions, or performing pre-commit sanity reviews — even if the user does not explicitly say "fable-review" (e.g. "review this diff", "check this PR", "critique my changes", "code review this branch"). Do NOT use for implementing fixes directly (use fable-tdd/fable-execute) or executing tests (use fable-verify).

Launch, manage, and verify live applications across CLI binaries, web servers, TUIs, Electron apps, and background daemons with readiness probes and clean teardown. Use when starting development servers, executing live smoke tests, testing interactive CLI binaries, or driving runtime smoke verification — even if the user does not explicitly say "fable-run" (e.g. "start the dev server", "launch the app", "test the running CLI", "smoke test the web app"). Do NOT use for static analysis or unit testing without a running process (use fable-verify).

Use when implementing any change in existing code — when tempted to clean up nearby code, add unrequested validation or options, fix something "arguably in scope", or when the diff is growing past what was asked.

Conduct threat modeling, vulnerability assessments, secret sanitization, and security reviews across trust boundaries, auth flows, and untrusted inputs. Use when auditing authentication/authorization logic, inspecting APIs for injection/CORS/CSRF risks, checking for hardcoded credentials, or reviewing security-sensitive diffs — even if the user does not explicitly say "fable-security" (e.g. "security audit this code", "check for vulnerabilities", "verify auth logic", "scan for leaked secrets"). Do NOT use for general style reviews (use fable-review) or non-security bug fixes (use fable-tdd).

Refactor and simplify settled, recently modified code to improve readability, remove dead branches, flatten deeply nested logic, and reduce duplication while preserving behavior. Use when cleaning up complex functions, eliminating boilerplate, deduplicating logic, or improving code altitude after tests pass — even if the user does not explicitly say "fable-simplify" (e.g. "simplify this code", "clean up this function", "refactor this logic", "make this cleaner"). Do NOT use when tests are failing (use fable-recover) or for speculative architectural rewrites (use fable-plan).

Verify complex code changes against independent mathematical oracles, derived specifications, headless browser environments, and isolated sandbox states. Use when deriving independent verification oracles, testing algorithms against reference models, verifying UI with headless browsers, or testing state transitions in sandboxes — even if the user does not explicitly say "fable-simulator" (e.g. "simulate this workflow", "verify with an independent oracle", "headless browser check", "derive a test oracle"). Do NOT use for simple unit test runs (use fable-verify).

Author, evaluate, refine, optimize, and package autonomous AI agent skills across multi-agent ecosystems with BinEval scoring and description tuning. Use when creating a new skill from scratch, editing an existing skill that misfires or undertriggers, authoring test suites for skills, optimizing skill descriptions, or packaging skills for distribution — even if the user does not explicitly say "fable-skill-creator" (e.g. "create a skill", "build a new skill", "optimize skill description", "package this skill", "teach the agent to do X"). Do NOT use for general application code changes or non-skill tasks.

Predict the smallest atomic next engineering action from current workspace state, evidence gates, and mutation freshness with situational silence. Use when evaluating what immediate atomic step to take next, checking situational awareness, or determining if the current state requires action or silence — even if the user does not explicitly say "fable-spark" (e.g. "what is my next move", "spark hint", "check next action", "what should I do now"). Do NOT use as a substitute for broad architectural planning (use fable-plan).

Drive testable behavior changes and bug fixes through disciplined red-green-refactor cycles with observable regression tests. Use when implementing new features with unit/integration tests, fixing reproducible bugs, modifying business logic, or writing test-first behavior contracts — even if the user does not explicitly say "fable-tdd" (e.g. "fix this bug test-first", "write a test and make it pass", "add this feature with tests", "TDD this logic"). Do NOT use for broad exploratory prototyping without clear assertions (use fable-discover or fable-plan) or for post-implementation reviews (use fable-review).

Autonomous dutiful junior maintainer for software repositories. Automates CI troubleshooting, PR conflict resolution, automated code review, issue triage, nightly codebase sweeps, and weekly dependency maintenance. Use when managing automated repository health, investigating failing CI workflows, resolving merge conflicts on open PRs, or conducting proactive maintenance sweeps.

Falsify software implementations and gather fresh, machine-checked acceptance proof across tests, builds, typechecks, and runtime smoke checks before completion. Use when running test suites, checking type correctness, validating acceptance criteria, or verifying post-mutation code integrity — even if the user does not explicitly say "fable-verify" (e.g. "verify my changes", "run all tests and typecheck", "check if everything passes", "prove this works"). Do NOT use for planning (use fable-plan) or diff code review (use fable-review).

Low-level agentic design patterns and cognitive reflexes across Depth, Breadth, Coil, and Mesh. Turns senior engineering wisdom into reflexes that remove bloat, preserve truth, prevent drift, and compound learning (re0, readchk, autobahn, ssotize, detool, feynman, debloat, sip, hate, macrothink, prism). Use when refactoring complex systems, stripping AI slop, rewriting drifted artifacts from clean v0, consolidating truth into single sources, or evaluating architectural decisions against contrarian counter-arguments.

Portable coding lifecycle and continuous situational awareness for AI agents across 25 specialist skills and canonical packs.