# User session report — v1.12.0 (the OpenCode 2.0 release)

```
topic: why the Chandrasekhar limit is ~1.4 solar masses      mode: standard
platform: opencode2 v0.0.0-next-17444 (standalone), free bundled models
real minutes: ~35 across 8 turns (transport retries included)
nodes encoded: 0 (see the verdict — the architect spawn is where the free tier dies)
reviews cleared: 0
```

This session ran on the actual `opencode2` beta binary against the release tree staged as
an npm install, with a throwaway `ENGRAM_HOME`. It is the first Engram session ever run on
the V2 runtime. Earlier turns ran mid-hardening; the final turns ran on the shipping tree.

## WHAT WORKED

- `/learn` resolved from the V2-extracted command surface on the first boot — no restart,
  no config. The skill loaded, ran the engine (`init`, due queue, stash — correct
  empty-state behavior), and opened intake exactly as on the six incumbent platforms.
- Re-anchoring on continuation: a fresh `run --continue` turn re-read learner state from
  disk, saw "no topics yet, goal on file", and did not trust conversational memory. The
  dialogue grammar held on a free third-party model.
- The engine resolved to the **extracted** copy (`.opencode/scripts/engram.py`) — the
  shell-env hook works.
- The whole update lifecycle, live: upgrading the sandbox's older extraction produced a
  real version-bump manifest; the notification file and the `engram_update` tool surfaced;
  a direct tool call returned `[engram] Update deferred. State: pending. 3 categories
  remaining.` verbatim. Two runtime behaviors no docs carry were caught only because this
  was run for real: default-options tools are not callable by name (`codemode: false`
  required), and a result declaring `output` without an output schema is rejected.
- Three cold-boot install passes: extraction lands in the project, `AGENTS.md` written,
  nothing outside the workspace. The middle pass caught the release's worst bug — a
  service-scope plugin instance extracting into the real `~/.config/opencode/` — which is
  why the extraction-scope guard exists.

## WHAT CONFUSED ME

- The model glob'd `.opencode/**/*.md`, got 0 matches (glob scoped elsewhere), and had to
  shell out with `find` to locate the agent spec. It recovered on its own, but a weaker
  model might not. The skills' engine-resolution block survived the port; the *agent-spec
  discovery* path is the wobblier half on V2.
- One early turn called `experiment` with wrong args and got argparse usage dumped into
  the transcript before self-correcting.

## WHAT ANNOYED ME — and what I would have quit over

- **The free bundled models drop the connection at the architect spawn — three times out
  of three, on two different models (`big-pickle`, `deepseek-v4-flash-free`), always at
  the same boundary, with a bare `Error: Transport`.** Everything Engram controls had
  already worked by that point; the spawn is a heavier nested model call and the free
  tier does not survive it. A stranger on the free tier would quit here, and nothing
  tells them it isn't Engram. This is recorded in INSTALL-OPENCODE-V2.md: use a
  configured provider for `/learn`'s architect step while V2 is beta.
- The one-shot `run` CLI ends the turn at the intake question tool ("The user dismissed
  this question") — fine for scripted probes, but intake flows want the TUI.

## WHAT IT TOLD ME vs WHAT WAS TRUE

- Every number the engine showed was checked against the state on disk: due `[]`, stash
  `pending: 0`, profile defaults — all true (fresh home). The update tool's "3 categories
  remaining" matched the manifest's `remaining` array exactly.
- No retention/decay numbers were produced (nothing encoded), so the §4.8 side-by-side
  ran vacuously here; the engine is byte-identical to v1.11.2, whose own release ran it.

## WOULD A STRANGER GET THROUGH THIS?

On a configured provider: **yes** — install is one config line, `/learn` works first boot,
and the failure that stopped this session is the free tier's, not Engram's, with the
caveat now printed where they'll read it. On the free bundled models: **no** — they cannot
carry the architect spawn, and that limit is OpenCode-beta territory Engram cannot fix.

## VERDICT: **ship**

The release's own surface — install, extraction, commands, nudge plumbing, shell env,
update lifecycle, tool round-trip — is live-verified end to end on the real runtime. The
learning loop above it (skills + engine) is byte-identical to v1.11.2, which shipped
through the full protocol including its own user session. The one unresolved failure is
the beta platform's free tier, documented at the point of install. The V1 OpenCode
experience is untouched.

Honest debt, carried forward per protocol: the first full learn→review loop ON the V2
runtime with a real provider still hasn't happened — run one before the release that
next touches the OpenCode adapters or the retention loop.