I'm the fractional AI CTO who still writes the code.

# compact context pack, not a raw dump
ctx = pack(repo)        # ~3k chars, not 50k
ctx += adrs + conventions + dep_graph
ctx += symbol_index(treesitter_parse(repo))
prompt = user_intent + ctx
agent.run(prompt, budget=Budget(steps, tokens))

while not done and budget.ok():
    plan = llm(ctx)              # reason over state
    call = select_tool(plan)     # next action
    call = pre_tool(call)        # mediated ↓
    obs  = run(call)             # sandboxed
    ctx += obs + post_tool(obs)  # gate report
    done = plan.is_complete or budget.spent()

# intercept BEFORE execution — deny or rewrite
def pre_tool(call):
    assert call.path in scope        # path/scope guard
    assert call.tool in allowlist    # policy allowlist
    assert not secrets(call.args)    # no creds leak
    call = policy.rewrite(call)      # Cursor .cursor/rules
    return call                      # or raise Deny

# edit / exec inside the isolated worktree
before = read(call.path)
apply(call, cwd=wt)              # write file / run cmd
after  = read(call.path)
diff   = unified(before, after) # captured change
return Observation(diff, stdout, exit_code)

# Claude Code PostToolUse hook → 30 compiled rules
def post_tool(diff):
    checks = [lint, types, tests, ast_diff,
              secret_scan, no_stub, no_phantom_ref,
              import_exists]          # 6 categories
    gate = all(rule(diff) for rule in RULES)  # 30, parallel
    if not gate: rollback(diff)       # revert in ms
    return Report(gate, failures)     # Codex AGENTS.md

wt    = worktree(repo)           # isolated checkout
apply(diff, wt)
graph = code_graph(treesitter, wt)
ok    = graph.resolve_refs(diff) # no phantom symbols
ok   &= symbol_search(diff.new_imports).exist()
build(wt)                        # self-contained binary
return ok                        # OpenCode .opencode/

if report.pass:
    ctx += "✓ gate green"; continue   # keep going
else:
    ctx += report.failures            # actionable
    retries += 1
    if retries > MAX: escalate(human) # bounded
    # agent re-plans against the failures →