Does the little prompt injection work that the CLI has on trails? Investigate

Yes — at the CLI/hook layer it works.

What I found:

• Injection text lives in cmd/entire/cli/lifecycle.go:
  • A trail ties together the context for a branch. Use \entire trail` to view, create, update, or watch it.`
• It emits once per normal session on TurnStart, gated by clone-local .git/entire/preferences.json having "trails_enabled": true.
• Agents render it as:
  • Claude/Codex/Gemini: hookSpecificOutput.additionalContext
  • Pi/OpenCode: {"inject_context": "..."} which their extension/plugin parses and injects.

I verified:

• Targeted tests pass:
  • ContextInjector
  • TrailsEnabledForRepo
  • OpenCode plugin injection test
• Manual hook simulation in a temp repo with trails_enabled:true produced the expected stdout payload for Claude, Codex, Gemini, Pi, and OpenCode.
• Second turn emits nothing, as intended.
• With trails_enabled:false, emits nothing and marks the session decided.

Caveats:

• I did not run real-agent E2E; that would cost tokens.
• It only works if the local trails-enabled cache exists and is true. That cache is only refreshed during entire enable; already-enabled clones or stale false/nil caches won’t get the injection until re-enable or another cache refresh path is added.

How about in THIS repo?

For this repo/session: no, not effectively.

Findings:

• Entire is enabled: .entire/settings.json has "enabled": true.
• Pi extension is installed and has the injection plumbing.
• Current Pi session state has context_injection_decided: true.
• But the local trail enablement cache is missing:
  • expected: .git/entire/preferences.json
  • actual: missing
• Since the code fails closed on missing cache, the hook marks injection “decided” but emits nothing.
• I checked the current Pi transcript: no hidden entire-context injected message was present.

Also: .opencode/plugins/entire.ts in this repo looks stale; it does not include the newer inject_context / experimental.chat.system.transform logic.

So: the code works generally, but this repo’s local hook state/cache means the trail prompt injection did not reach this current Pi session.

Dig deeper, does the preferences.json actually work?

Short answer: the preferences file works as a local gate, but the population/refresh path is weak — in this repo it is not populated even though trails are accessible.

What I verified:

• Current repo path resolves to:
  • .git/entire/preferences.json
• Currently it is missing.
• settings.LoadClonePreferences() treats missing as {} → trailsEnabled == nil → injection gate is false.
• Temporarily writing:
  • {"trails_enabled": true} made the gate read true
  • {"trails_enabled": false} made it read false
• Existing test passes:
  • TestTrailsEnabledForRepo_ReadsClonePreference

But importantly:

• go run ./cmd/entire/main.go trail list --limit 1 --status any works in this repo and shows trails exist/access is enabled:
  • Recent trails · 1/631
• Yet .git/entire/preferences.json is absent.
• So normal trail usage does not refresh/write the cache.
• It looks like only entire enable writes this via reportRepoEnabled(), and that path is best-effort/silent. Existing enabled clones can easily never get the cache.

Current session impact:

• Latest Pi session has context_injection_decided: true.
• Since prefs were missing at first turn, the session failed closed and won’t retry even if prefs are added later.

How can we make it more reliable then?

Only writing on entire enable is not enough; it should more "constantly" check based on certain events. Are the preferences.json git ignored?

Yes — preferences.json is safe from git, but the refresh model is too sparse.

Reliability improvements I’d make:

1. Refresh on successful trail commands
   • Any successful entire trail list/show/create/update/delete/finding/watch response proves trails are enabled/accesssible.
   • So after those 2xx responses, call saveTrailsEnabledForRepo(ctx, true).
2. Refresh on definitive disabled responses
   • On 404/403/410 from trails endpoints, save false.
   • On network errors, auth errors, 5xx: do not overwrite the cache.
3. Add freshness metadata
   • Extend clone prefs with e.g.
     • trails_enabled_checked_at
     • trails_enabled_repo / remote key
   • Avoid stale true after origin changes or after trails are disabled.
4. Refresh opportunistically before agent turns
   • On SessionStart, if cache is missing/stale, kick off a bounded/background refresh.
5. Keep hook-time gate simple
   • TurnStart should only read local prefs:
     • fresh true → inject + mark decided
     • fresh false → mark decided/no inject
     • unknown/stale → request refresh, don’t mark decided

The key bug is:

missing prefs currently behaves like false and is sticky per session. Better is unknown → refresh + retry later.

All right, which are the safest triggers to make sure this isn't stale ever?

If we mean “not stale ever”, triggers alone aren’t enough. The safest model is:

1. Validate on use
   • Before injecting, only trust a cache entry if it matches current:
     • repo key: forge/owner/repo
     • origin URL hash or canonical remote
     • API base/core/context identity
     • checked timestamp / generation
   • If it doesn’t match: treat as unknown, not false.
2. Refresh on agent SessionStart
   • Best safe trigger for prompt injection.
3. Refresh on every successful trail API command
   • trail list/show/create/update/delete/finding/watch
   • Any 2xx from repo-scoped trail endpoint → write trails_enabled: true.
4. Invalidate on identity changes
   • auth login/logout/use
5. Use a TTL
   • Even with triggers, server-side state can change without CLI knowing.

Key behavioral change:

unknown/stale must not set context_injection_decided. Current behavior makes missing prefs sticky for the whole session, which is the main bug.

Sounds good, let's make the changes.

Implemented the trail context-injection cache refresh changes.

Key changes:

• Added scoped/fresh trail enablement cache in .git/entire/preferences.json:
  • trails_enabled
  • trails_enabled_checked_at
  • trails_enabled_repo_key
  • trails_enabled_api_base
  • trails_enabled_auth_key
• TurnStart now only reads local cache and injects only when cache is fresh true.
• Missing/stale/mismatched cache is now unknown and does not set ContextInjectionDecided.

Validation run:

• go test ./cmd/entire/cli/...
• mise run lint

Create a trail commit and push the changes to the new branch.

Done.

• Branch: dip/trail-context-cache-refresh
• Commit: de2087233 Gate trail injection on enablement cache
• Pushed to: origin/dip/trail-context-cache-refresh
• PR URL: https://github.com/entireio/cli/pull/new/dip/trail-context-cache-refresh

Validation run:

• mise run check
• mise run lint
• Working tree is clean.