go-wiring-dead-pipeline-activation

Answer

Diagnosis (U-GAP-012). The 414-line JIT CoderLLM conversion stage was dead code: nothing constructed it (zero production call sites), no hook routed oracle verdicts into it, and the oracle ticker never ran. The pipeline "stopped at the oracle" — verdicts were emitted, then dropped. Four wiring gaps, four fixes:

1. Instantiate at composition root — framework.New now constructs coderllm.New(...) and holds it in the Pipeline.
2. Adapt interface gaps locally — the legacy LocalSandbox lacks Execute; sandbox.Adapter forwards Acquire/Release and returns a clear ErrNotImplemented from Execute (loud, never a silent zero-value success).
3. Start oracle ticker on existing config period — Start launches oracle.New(cfg.OraclePeriod, ...) using the pre-existing Config.OraclePeriod.
4. Register conversion hook — ConversionHook func(oracle.Verdict) bool decides convert (forward to CoderLLM) vs keep (no-op).

// framework/framework.go — composition root
type ConversionHook func(oracle.Verdict) bool

type Config struct {
    OraclePeriod time.Duration // pre-existing config field the ticker must use
}

type Pipeline struct {
    cfg    Config
    oracle *oracle.Oracle
    llm    *coderllm.CoderLLM // was never populated before the fix
    hook   ConversionHook
}

// New instantiates every stage, wraps the legacy sandbox in the adapter,
// registers the conversion hook, and returns a live pipeline.
func New(cfg Config, sb *sandbox.LocalSandbox, hook ConversionHook) *Pipeline {
    adapter := sandbox.NewAdapter(sb)      // interface-gap adaptation
    llm := coderllm.New(adapter)           // CoderLLM gets a real call site
    p := &Pipeline{cfg: cfg, llm: llm, hook: hook}
    p.oracle = oracle.New(cfg.OraclePeriod, p.OnVerdict) // ticker on config period
    return p
}

// Start launches the oracle ticker — the missing wiring that makes the
// pipeline flow all the way through instead of stopping at the oracle.
func (p *Pipeline) Start(ctx context.Context) { p.oracle.Start(ctx) }

// OnVerdict routes verdicts: hook fires → convert (CoderLLM runs);
// hook does not → keep (stage untouched).
func (p *Pipeline) OnVerdict(v oracle.Verdict) {
    if p.hook != nil && p.hook(v) {
        _, _ = p.llm.Execute(context.Background(), v.File)
    }
}

// sandbox/adapter.go — closes the interface gap
var ErrNotImplemented = errors.New("sandbox: Execute not implemented by legacy sandbox")

type Adapter struct{ inner *LocalSandbox }

func NewAdapter(inner *LocalSandbox) *Adapter { return &Adapter{inner: inner} }

func (a *Adapter) Acquire(ctx context.Context) (*Session, error) { return a.inner.Acquire(ctx) }
func (a *Adapter) Release(s *Session)                            { a.inner.Release(s) }
func (a *Adapter) Execute(context.Context, *Session, string) (string, error) {
    return "", ErrNotImplemented // explicit, debuggable — not a silent no-op
}

// coderllm/coderllm.go — the stage that previously had zero call sites
func (c *CoderLLM) Execute(ctx context.Context, artifact string) (string, error) {
    c.mu.Lock(); c.calls++; c.last = artifact; c.mu.Unlock() // observable activation
    s, err := c.sandbox.Acquire(ctx)
    if err != nil { return "", fmt.Errorf("acquire session: %w", err) }
    defer c.sandbox.Release(s)
    return c.sandbox.Execute(ctx, s, artifact)
}

// oracle/oracle.go — ticker honors the existing config period
func (o *Oracle) Start(ctx context.Context) {
    if o == nil || o.period <= 0 { return }
    t := time.NewTicker(o.period) // set from Config.OraclePeriod at composition root
    defer t.Stop()
    for {
        select {
        case <-ctx.Done(): return
        case <-t.C: if o.emit != nil { o.emit(Verdict{File: "next.bin", Convert: true}) }
        }
    }
}