Codd Fable Consult

# 1. Write the prompt (see template below) to a file.
#    Use the Write tool for this, not a heredoc in the same command.

# 2. Launch detached, capturing stdout/stderr separately:
nohup claude --print --model claude-fable-5 --effort max "$(cat /path/to/prompt.md)" \
  > /path/to/design_output.md \
  2> /path/to/design_output.stderr &
disown
echo "launched pid=$!"

# 3. There is no automatic completion notification for a nohup'd process —
#    you must poll. Check both that the process has actually exited AND that
#    the output file has real content before treating it as done:
ps aux | grep "claude.*fable-5" | grep -v grep   # empty = finished (or never started — check stderr too)
wc -l /path/to/design_output.md

You are being consulted specifically because this is a genuinely hard, novel
architectural design problem in CoDD (a context-driven/coherence-driven
development tool) at [REPO: https://github.com/<owner>/codd-dev — grounded
reasoning only; if you cannot reach the local filesystem, read the actual
current code from this GitHub repo (origin/main) via whatever web-access
tools you have, and disclose which access path you actually used]. This is
NOT a "find and fix a bug" task — diagnosis is already done. This is a
"design the right generalizable solution" task.

## CoDD's non-negotiable invariants (violating any of these defeats the point of asking you)

- **Generality-first**: the language-free CORE never branches on
  `language == "python"` etc. Per-language behavior lives entirely in
  declarative YAML profiles (`codd/languages/profiles/*.yaml`) plus small,
  isolated adapter classes registered per language. Any fix you design MUST
  fit this shape — verify by grepping the actual code, don't assume.
- **Anti-false-green**: when an AI autonomously writes both source code and
  its own tests, nothing may let it certify its own homework. Gates exist to
  independently verify claims, never to trust self-report.
- **Anti-false-red**: a gate must not fail something that is actually fine —
  a standing false-red trains operators toward disabling the gate entirely,
  which is a worse outcome than the false-red itself.
- **Owner-is-not-a-bottleneck**: prefer designs where extending coverage
  (a new language, a new library, a new edge case) is a data/config edit
  reachable by anyone, not a core-code change requiring the maintainer.

## The specific gap (concrete, evidence-based — not hypothetical)

[DESCRIBE: the exact failure, with real file paths, function names, and
live evidence — what broke, on what real input, with what exact error
text. Cite the specific files/functions you've already read so Fable 5
grounds itself immediately rather than re-discovering them.]

[STATE: why a quick patch is wrong — what got tried or considered and
rejected already, and specifically what overfit/generality risk a naive
fix would create. If a prior investigation flagged this as a design
fork rather than a bug, quote that flag.]

## What I need from you

A concrete, opinionated, implementable design — not a survey of options with
no conclusion.

1. [The core mechanism question — e.g., "should this be N per-language
   implementations or a shared primitive with per-language plug-ins, and
   why, grounded in what's already in the code?"]
2. [Any depth/bound/stopping-rule question the design needs to answer
   honestly, not just practically.]
3. [The hardest sub-problem — usually "how do we handle the
   framework/instance-specific case generically without hardcoding it,"
   with the overfit risk stated explicitly and NOT to be dodged.]
4. **Anti-false-green integrity**: for anything you propose, give at least
   one adversarial example your design correctly REJECTS, alongside the
   real motivating example(s) it correctly ACCEPTS.
5. **Scope call**: should this ship as one unit, or is there a safe, smaller
   first increment that de-risks the rollout, gated by a LIVE rerun of the
   actual failing case (not just unit tests) before the next increment?
   Weigh in using CoDD's own stated invariants explicitly.

## Constraints

- Do not write or edit any code yet — sketch signatures/pseudocode if
  confident, but this is a design pass.
- Do not propose disabling or weakening the affected gate/check — that was
  already considered and rejected.
- Ground everything in the actual code. Read the real files; don't assume.

## Output

A design document, written directly in your response. Structure it however
best serves clarity, but it MUST end with a single clear recommended path
(not a menu with no pick) and an explicit, ordered implementation task list
for a follow-up task to execute against.