3 Commits
Author SHA1 Message Date
1661f336cd release(v0.3.1): patch release — post-Phase-3 cleanup batch #1 (D56) (#35)
Patch release closing two XS v1.x-roadmap deferrals that became actionable
once Phase 3 management endpoints existed:
- v1.x #4 — /health activeSpawns integration (ADR 0002 Amendment 6 forward note)
- v1.x #7 — AUTH_MISSING tuple test (D45 P3 deferral)

No feature surface change; D56 already merged at 5ebe3dc. This release commit
only bumps package.json 0.3.0 → 0.3.1 and promotes CHANGELOG.md Unreleased's
D56 entry to "## v0.3.1 — 2026-05-25".

Patch-release classification per release_kit.phase_rolling_mode cross-Phase
discipline: D56 landed on main after v0.3.0 was tagged, so this is a hotfix-
class patch. Bump patch, tag, release before next push. Tag push triggers
release.yml.

Test count: 601 (v0.3.0) → 603 (v0.3.1). 603/603 pass locally on release-v0.3.1
branch head.

Co-authored-by: dtzp555 <dtzp555@gmail.com>
Co-authored-by: Claude Opus 4.7 <noreply@anthropic.com>
2026-05-25 18:47:22 +10:00
5ebe3dc77c feat+test+docs: D56 — v1.x cleanup batch #1: AUTH_MISSING tuple test + /health activeSpawns (#34)
Post-Phase-3 cleanup batch #1. Bundles two small v1.x-roadmap deferrals (#4
and #7 in docs/v1x-roadmap.md) into one D-day. No new user-facing feature;
pins existing behaviour into tests + finally wires the ADR-documented
activeSpawns field on /health.

(1) AUTH_MISSING tuple test (v1.x #7, D45 P3 deferral)

New engine-level test in Suite D40 asserts that an AUTH_MISSING hop produces
a fallbackDetail tuple with trigger_type: 'auth_missing' AND that the engine
does NOT advance past it (HARD_TRIGGER_CODES[AUTH_MISSING]=false). Pre-D56 the
behaviour was implicit through neighbouring tests; D56 makes it explicit so a
future refactor that moves the tuple-push past the auth_missing branch fails
this test directly.

Authority: ADR 0004 § Decision (hard-trigger table) + Amendment 5 (tuple shape).

(2) /health activeSpawns integration (v1.x #4, ADR 0002 Amendment 6 forward
note)

handleHealth now surfaces providers.status.<name>.activeSpawns (sourced from
D38 getActiveSpawnCount(name) — already imported at server.mjs:39). The field
is computed BEFORE healthCheck() is awaited so it remains present even when
healthCheck() throws — getActiveSpawnCount is a cheap in-memory counter read.
New Suite 21c-extra test pins the field presence + numeric + non-negative for
every enabled provider in the fixture.

Authority: ADR 0002 Amendment 6 § "Forward note — exposing the counter via
HTTP" — names the path providers.status.<name>.activeSpawns and pins it as
the Phase 1 deferral that becomes due once management endpoints exist (which
they now do, post-Phase-3).

Test count: 601 → 603 (+2 D56 tests; 603/603 pass locally).

Release-kit: under Unreleased per phase_rolling_mode (Phase 3 closed at v0.3.0;
Phase 4 entries also land here once Phase 4 opens — D56 is a cleanup-D-day
that ships under v0.3.x, not a Phase 4 deliverable).

Co-authored-by: dtzp555 <dtzp555@gmail.com>
Co-authored-by: Claude Opus 4.7 <noreply@anthropic.com>
2026-05-25 18:11:36 +10:00
179b4707a7 docs: ADR 0009 — Anthropic Interactive-Mode Path Placeholder (blocked on OCP P0) (#33)
Records OLP-side decision for the cross-project work OCP started in
ADR 0007 (interactive-mode execution pool to address post-2026-06-15
Anthropic billing split).

OPTION 3 — wait + port:

  - No OLP code change to lib/providers/anthropic.mjs until OCP
    ADR 0007 P0 experiment outcome lands (>= 2026-07-15).
  - Avoid duplicating the P0 risk by running an independent OLP
    experiment against the same Anthropic billing pool.
  - If P0 confirms Transport A (stdio NDJSON) or Transport B (PTY)
    bills as subscription rather than Agent SDK credit, port the
    validated pattern to OLP at that time.
  - If both transports fail, shelve this ADR; OLP Anthropic users
    fall back to Agent SDK $100 / month credit OR shift to multi-
    provider routing (Codex / Mistral) per Phase 1 design.

DECISION TREE recorded in § 3 so a future Phase 4 brief can act
mechanically once OCP P0 lands:

  Transport A wins → Option 1 (parallel impl) likely
  Transport B wins → Option 1 with PTY adapter (node-pty native dep
                     triggers engines-bump prior PR)
  Both fail        → Shelve ADR 0009
  Unobservable     → Extend wait

IMPLEMENTATION LANES (§ 4) — informational, not selected:

  Option 1 — OLP parallel implementation in lib/providers/anthropic.mjs
  Option 2 — Chain OCP as backend (OLP → OCP → Claude)
  Option 3 — Hybrid (prefer OCP backend, fallback to local pool)

NO PHASE 4 D-DAY scheduled. This is a decision-record placeholder
ONLY. Phase 4 standing-autopilot grant ("Phase 4+ requires new
authorization") still applies. When OCP P0 lands, maintainer issues
explicit Phase 4 "go" naming this ADR to trigger implementation
selection + D-day work.

DOCUMENTATION:

  - docs/adr/0009-interactive-mode-path-placeholder.md (new, ~200 lines)
  - docs/adr/README.md index: ADR 0009 row added
  - Cross-machine cc-rules memory (~/.cc-rules/memory/learnings/
    ocp_adr_0007_interactive_mode_pool.md, committed in cc-rules
    a16b775) bridges OCP ADR 0007 + OLP ADR 0009 so future Phase 4
    planning sessions in either repo pull the shared context.

Test count: 601 → 601 (docs-only; no test or .mjs file touched).

AUTHORITY:

  - OCP ADR 0007 (~/ocp/docs/adr/0007-interactive-mode-pool.md,
    Draft 2026-05-25) — the triggering external work.
  - OLP ADR 0001 (Project Founding) — the 2026-06-15 billing-split
    motivation that this ADR reaffirms.
  - OLP ADR 0006 (Provider Inclusion) — the anthropic plugin's tier
    that this ADR would amend if/when implemented.
  - CLAUDE.md release_kit overlay phase_rolling_mode (current_phase:
    Phase 4) — this ADR explicitly does NOT consume a Phase 4 D-day.
  - Standing autopilot grant — Phase 4+ requires new authorization;
    this placeholder is a decision-tree pre-record, not Phase 4
    implementation.

ALIGNMENT.md scope check: docs-only commit (new ADR + index update).
No provider plugin / entry surface / IR change.

Co-authored-by: dtzp555 <dtzp555@gmail.com>
Co-authored-by: Claude Opus 4.7 <noreply@anthropic.com>
2026-05-25 17:49:16 +10:00
6 changed files with 268 additions and 3 deletions
+13
View File
@@ -6,6 +6,19 @@ All notable changes to OLP land here. Per `CLAUDE.md` release_kit overlay, this
(empty — Phase 4 entries land here once Phase 4 opens)
## v0.3.1 — 2026-05-25
### Post-Phase-3 cleanup batch #1 (D56)
Patch release closing two XS v1.x-roadmap deferrals (`docs/v1x-roadmap.md` #4 + #7) that became actionable now that Phase 3 management endpoints exist. No new feature surface; pins existing behaviour into tests + finally wires the ADR-documented `activeSpawns` field on `/health`.
- **AUTH_MISSING tuple test** (v1.x roadmap #7 / D45 reviewer P3 deferral). New engine-level test in Suite D40 asserts that an `AUTH_MISSING` hop produces a `fallbackDetail` tuple with `trigger_type: 'auth_missing'` AND that the engine does NOT advance past the AUTH_MISSING hop (per ADR 0004 § Decision — `HARD_TRIGGER_CODES[AUTH_MISSING] = false`). Pre-D56 the behaviour was implicit through other engine-path tests; this commit makes it explicit so a future refactor that moves the tuple-push past the auth_missing branch fails this test directly.
- **`/health` `activeSpawns` integration** (v1.x roadmap #4 / ADR 0002 Amendment 6 forward note). `handleHealth` now surfaces `providers.status.<name>.activeSpawns` (sourced from D38 `getActiveSpawnCount(name)`). The field is computed BEFORE `healthCheck()` is awaited so it remains present even when `healthCheck()` throws (cheap in-memory counter read). New Suite 21c-extra test pins the field presence + non-negative value for every enabled provider. With no requests in flight: 0; under saturation: equals `hints.maxConcurrent`.
- **Test count:** 601 (v0.3.0) → 603 (v0.3.1). +2 D56 tests.
- **Authority:** `docs/v1x-roadmap.md` #4 + #7; ADR 0002 Amendment 6 (concurrency observability forward note); ADR 0004 § Decision + Amendment 5 (X-OLP-Fallback-Detail tuple shape).
**Patch-release classification.** Per `release_kit.phase_rolling_mode` cross-Phase discipline: D56 landed on main after v0.3.0 was tagged, so this is a hotfix-class patch — bump patch, tag, release before next push. Tag push triggers `release.yml`.
## v0.3.0 — 2026-05-25
### Phase 3 — Dashboard + audit query layer + daily audit rotation (D48 → D54)
@@ -0,0 +1,197 @@
# ADR 0009 — Anthropic Interactive-Mode Path (Placeholder)
- **Date:** 2026-05-25
- **Status:** Draft (Placeholder — blocked on OCP ADR 0007 P0 experiment outcome; no implementation D-day scheduled until P0 lands)
- **Authors:** project maintainer (with AI advisory drafting)
- **Related:**
- **OCP ADR 0007** (Interactive-Mode Execution Pool, stream-json) — at `~/ocp/docs/adr/0007-interactive-mode-pool.md` on the maintainer's workstation. Pin reference at the time of this writing: OCP ADR 0007 is Draft status pending the same P0 outcome.
- OLP ADR 0001 (Project Founding) — establishes the 2026-06-15 Anthropic billing-split trigger that motivated OLP's multi-provider posture in the first place.
- OLP ADR 0006 (Provider Inclusion / Risk Tier Framework) — anthropic is currently a Tier-D Candidate; this ADR amends the operational shape of that plugin if/when P0 succeeds.
- OLP ADR 0007 (Multi-Key Auth) — Phase 2 design; per-key cache + audit layer that any future interactive-mode implementation must continue to satisfy.
- OLP ADR 0008 (Dashboard + Audit Query) — Phase 3 design; any interactive-mode change must not regress the Dashboard's per-provider observability fields.
- **Standing autopilot grant note:** Phase 4 is a "new authorization required" scope per `~/.cc-rules/memory/auto/standing_autopilot_phase_2.md`. This placeholder ADR is recorded NOT as implementation work but as the maintainer's "do not forget this when planning Phase 4" anchor. No implementation D-day is scheduled until P0 lands AND maintainer issues a Phase 4 "go" specific to this ADR.
---
## 1. Context
### 1.1 The triggering external work
OCP shipped ADR 0007 (`docs/adr/0007-interactive-mode-pool.md` in `dtzp555-max/ocp`) on 2026-05-25, draft status. The ADR designs a dual-path execution model for the post-2026-06-15 Anthropic billing split:
- **Current `claude -p` path**: programmatic billing → Agent SDK $100/month credit pool (~2050 heavy coding sessions/month).
- **Proposed interactive-mode path**: spawn Claude without `-p`, communicate via either (Transport A) piped NDJSON over stdio or (Transport B) `node-pty` PTY — possibly classified as interactive billing → subscription pool.
The OCP team accepted the *concept* but rejected an external contributor's PR #101 implementation (tmux + hook-file polling + `--dangerously-skip-permissions`) on alignment + security grounds, then drafted ADR 0007 as the clean redesign.
### 1.2 Why this is OLP's concern
OLP's founding premise (ADR 0001) was that OCP would become uneconomical post-2026-06-15, motivating a multi-provider hedge. OLP's `lib/providers/anthropic.mjs` today uses the same `claude -p` invocation OCP uses → same billing consequence post-2026-06-15.
If OCP's ADR 0007 P0 experiment confirms that an interactive-mode spawn (Transport A or B) bills against subscription rather than Agent SDK credit, the implementation pattern is directly portable to OLP's anthropic provider plugin. OLP would inherit the same billing benefit without needing to commission an independent P0.
If P0 fails for both transports, OLP's anthropic provider remains stuck on `-p` post-June-15; the multi-provider routing (OpenAI Codex, Mistral) becomes the operational mitigation, exactly per OLP's original founding logic.
### 1.3 The unverified premise (binding caveat)
Per OCP ADR 0007 § "Unverified Premise":
> "TTY detection matters. Local testing (Claude Code 2.1.150) shows: in a real TTY, `claude` without `-p` enters the TUI and does not emit NDJSON. With piped stdin/stdout (`child_process.spawn`), it emits NDJSON even without `-p`. This means Anthropic could use `isTTY` as the billing signal, not the `-p` flag."
OLP cannot independently confirm or refute this prior to 2026-06-15 — Anthropic's billing pool signaling is not exposed on any observable surface until the billing split goes live. **Any OLP implementation that bets on Transport A (stdio pipe) without P0 confirmation risks burning real Agent SDK credit on every Anthropic request.**
---
## 2. Decision
**Option 3 — Wait for OCP ADR 0007 P0 experiment outcome, then port the validated approach.**
Rationale:
- **Avoid duplicated P0 risk.** Both OCP and OLP would run the same experiment against the same Anthropic billing pool. OCP is already designed to run it; OLP riding their result is a free observation.
- **Lower decision-tree noise.** P0 has three outcomes (Transport A wins / Transport B wins / both fail). OLP's right answer differs per outcome; making the decision before the data is speculation.
- **No code is wasted.** OLP currently routes anthropic via `claude -p`, which works (just expensive post-June-15). The cost during the wait window is bounded by the Agent SDK $100/month credit + OLP's family-scale request volume.
What "wait" means concretely:
1. **No code change to `lib/providers/anthropic.mjs`** until OCP ADR 0007 transitions from Draft → Accepted (which requires P0 success per OCP ADR 0007 § "Status").
2. **No Phase 4 D-day scheduled for this scope** until that transition AND maintainer issues an explicit Phase 4 "go" naming this ADR.
3. **This placeholder ADR stays Draft** until either OCP P0 lands AND OLP decides to port, OR OCP P0 fails decisively AND OLP marks this ADR Rejected with a "shelved per upstream P0 failure" note.
---
## 3. P0 outcome → OLP action decision tree
Recorded here so a future Phase 4 brief can act mechanically once OCP P0 lands.
```
OCP ADR 0007 P0 result
├─ Transport A (stdio pipe) confirmed interactive-billing
│ → OLP Option 1 OR Option 2 (see § 4); maintainer decides.
│ Likely Option 1: port the lib/interactive-pool.mjs +
│ billing-router.mjs pattern into lib/providers/anthropic.mjs.
│ Updates ADR 0006 to spell out the new spawn mode.
├─ Transport B (PTY) confirmed; Transport A fails
│ → OLP Option 1 with PTY adapter; node-pty dependency added
│ under engines-bump scrutiny (this triggers a separate prior
│ PR per ADR 0007 § 11-like discipline: native addon adds
│ CI matrix work).
├─ Both transports billed as programmatic
│ → OLP marks this ADR Rejected. Anthropic provider stays on
│ `claude -p`. Operational mitigation: family-scale users
│ either (a) accept the Agent SDK $100 cap, (b) bring their
│ own API key (BYOK env path is already there), or (c) shift
│ volume to other providers (Codex / Mistral) via OLP's
│ existing fallback chain.
└─ P0 results unobservable (billing signals not exposed)
→ Continue waiting. Re-evaluate one billing cycle (30 days)
post-2026-06-15. OLP Anthropic provider remains on `-p`
path during the wait; users see Agent SDK credit consumption
as the cost signal.
```
---
## 4. Implementation lanes (to be selected when P0 lands)
This section is informational only. No lane is selected at placeholder time.
### Option 1 — OLP parallel implementation
OLP's `lib/providers/anthropic.mjs` reimplements OCP's interactive pool natively. Replaces the current `claude -p` spawn with a pool-managed warm process + adapter selected per P0 outcome.
- **Pros:** OLP self-contained; no runtime dependency on OCP being installed.
- **Cons:** Duplicates substantial logic (pool lifecycle, transport adapter, crash backoff DEGRADED, permission auto-response). Two codebases drift over time.
### Option 2 — OLP chains OCP as backend
OLP's `lib/providers/anthropic.mjs` invokes OCP (via its existing HTTP entry surface, or via a future direct-spawn API) rather than spawning `claude` directly. OLP becomes a multi-provider layer ON TOP OF OCP for the Anthropic provider; other providers (Codex, Mistral) continue to be direct.
- **Pros:** Zero duplication; OLP benefits from OCP's P0-validated work automatically. Architectural separation: OCP owns Claude execution, OLP owns multi-provider routing.
- **Cons:** OLP gains a runtime dependency on OCP being installed + running. Double caching (OCP cache + OLP cache; cache key composition needs to avoid stampede). OCP's HTTP shim is OpenAI-spec-compatible but adds an extra hop's latency. OCP failure modes propagate.
### Option 3 — Both (default to OCP backend if available, fallback to local pool)
A hybrid: OLP detects OCP installed locally, prefers chaining; otherwise falls back to the parallel implementation. Most defensive but most complex.
**Default at placeholder time:** Option 1 is the simpler ship if P0 transports prove out. Option 2 is the cleaner architecture but adds operational coupling. Maintainer decides at P0-resolution time.
---
## 5. Risk assessment (placeholder snapshot)
| Risk | Likelihood (now) | Impact | Mitigation pending P0 |
|---|---|---|---|
| OLP forgets this ADR exists | Medium (multi-month wait) | High (would mean OLP misses the post-June-15 window) | This ADR + cc-rules memory `~/.cc-rules/memory/learnings/ocp_adr_0007_interactive_mode_pool.md` |
| OCP ADR 0007 P0 fails entirely | Medium | High for OLP Anthropic users (Agent SDK $100 cap binds) | OLP's multi-provider fallback (Codex/Mistral) already shipped as Phase 1 work; users have a path |
| OCP ADR 0007 ships incomplete (interim) | Medium | Medium (OLP can't reliably port) | Wait for OCP to mark Accepted; don't port from Draft |
| Anthropic policy changes mid-wait | Medium | Depends — could obsolete the whole approach | Re-read OCP ADR 0007 + this ADR before any Phase 4 anthropic work; no decisions on stale information |
---
## 6. Out of scope (explicitly NOT in this ADR)
- **Any code change.** This is a placeholder + decision-tree record only.
- **OCP P0 design.** That work is OCP's responsibility per OCP ADR 0007 § "Implementation phases".
- **A new OCP-OLP integration protocol.** If Option 2 is selected at P0-resolution time, the integration shape is a separate ADR.
- **Engines-bump for node-pty.** Only relevant if P0 picks Transport B and Option 1 is selected. Then it lands as a separate prior PR per the ADR 0007 § 11 pattern.
---
## 7. Phase 4 priority interaction
This ADR is recorded BEFORE Phase 4 implementation scope is finalized. Phase 4 currently lists (per OLP v0.3.0 CHANGELOG):
- Per-key per-provider auth artifact mapping (ADR 0007 § 12 deferral)
- Audit retention policies (ADR 0008 § 11 deferral)
- SQLite hybrid migration (ADR 0007 § 13 trigger)
- Provider-cost weights for spend trend (ADR 0008 § 11 deferral)
If OCP P0 succeeds, **the interactive-mode port likely jumps to the top of Phase 4** (highest user impact: keeps OLP Anthropic users on subscription billing). The other items remain Phase 4 but reorder downstream.
If OCP P0 fails, **this ADR is shelved** and Phase 4 ordering is unchanged.
---
## Consequences
**Positive:**
- OLP retains a documented anchor for the interactive-mode option without committing implementation effort prematurely.
- Future Phase 4 planning has a structured decision tree, not a vague "we should look at OCP someday".
- Cross-machine + cross-session memory (cc-rules) ensures the dependency is visible to any future session reading the OLP project context.
**Negative:**
- During the wait window (now → P0 outcome ≥ 2026-07-15), OLP Anthropic users consume Agent SDK credit post-2026-06-15. Bounded by family-scale request volume but a real operational cost.
- Some risk that "wait" turns into "forget" if multiple unrelated Phase 4 priorities crowd the agenda. Mitigated by this ADR + the cc-rules memory pointer.
**Reversibility:**
- This is a placeholder. Either P0 result transitions it (Accepted → port, Rejected → shelve) cleanly. The placeholder itself doesn't lock OLP into anything.
---
## Authority citations
- **OCP ADR 0007** at `~/ocp/docs/adr/0007-interactive-mode-pool.md` (maintainer workstation). Project repo: `dtzp555-max/ocp`.
- **PR #101** to `dtzp555-max/ocp` — external contributor's tmux-based prototype that triggered the OCP ADR 0007 redesign.
- **Anthropic 2026-06-15 billing-split announcement** — see `~/.cc-rules/memory/learnings/anthropic_claude_code_billing_split_2026_06_15.md`.
- **OLP ADR 0001** (Project Founding) — establishes the original billing-split → multi-provider motivation.
- **OLP ADR 0006** (Provider Inclusion + Risk Tier Framework) — the anthropic plugin's tier classification + the surface this ADR would amend.
- **OLP ADR 0007** (Multi-Key Auth, Phase 2) — per-key audit + cache layer that must continue to work across any anthropic execution-mode change.
- **OLP ADR 0008** (Dashboard + Audit Query, Phase 3) — Dashboard per-provider fields must continue to populate.
- **CLAUDE.md `release_kit.phase_rolling_mode`** — current_phase: Phase 4 (post-v0.3.0); this ADR explicitly does NOT consume a Phase 4 D-day until P0 lands.
- **Standing autopilot grant** (`~/.cc-rules/memory/auto/standing_autopilot_phase_2.md` in cc-rules `bf0ed9a`) — Phase 4+ requires new authorization; this placeholder is a decision-tree pre-record, not Phase 4 implementation.
---
## Status transitions (recorded for clarity)
- 2026-05-25 — Created as Draft (Placeholder). OCP ADR 0007 also Draft.
- _(future)_ — If OCP ADR 0007 → Accepted with a confirmed transport: this ADR moves to "Pending Phase 4 implementation D-day", maintainer decides Option 1 / 2 / 3 + lane.
- _(future)_ — If OCP ADR 0007 → Rejected: this ADR moves to "Shelved (upstream P0 failure)" with a note explaining the fallback (multi-provider routing already covers).
+1
View File
@@ -22,6 +22,7 @@ New ADRs increment from the highest existing number. Filenames are `NNNN-<short-
| [0006](0006-provider-inclusion.md) | Provider Inclusion / Exclusion + Risk-Tier Framework | The 4-tier classification (A excluded by default / B explicit consent / C opt-in / D eligible-for-default-enabled), Candidate-vs-Enabled distinction, current v0.1 candidate inventory (0 Enabled), Antigravity exclusion rationale (named prohibition + no cost advantage + reinstatement friction; pending primary-source pin), consent UX, future provider addition procedure. |
| [0007](0007-multi-key-auth.md) | Multi-Key Auth (`lib/keys.mjs`) | Phase 2 design ADR (D43-B, 2026-05-25). Option 2 (filesystem manifest at `~/.olp/keys/<key-id>/manifest.json`) + opaque `olp_<32-byte>` token + SHA-256 hash. Owner / guest / anonymous tier gating with explicit `config.json auth.allow_anonymous` (default false). Bootstrap keygen command surface + `OLP_OWNER_TOKEN` env override with stable synthetic `key_id`. Audit ndjson append-only at `~/.olp/logs/audit.ndjson`, warn+1-retry on append failure. Rejects direct SQLite port at v0.2.0 due to Node baseline (`engines >=18` + CI 20/24 vs `node:sqlite` added 22.5.0 / RC); Option 3 hybrid documented as forward path when Phase 3+ Dashboard / SQL-aggregate quota arrives. |
| [0008](0008-dashboard-and-audit-query.md) | Dashboard + Audit Query Layer | Phase 3 design ADR (D48, 2026-05-25). Static HTML dashboard + vanilla JS + fetch (no build step). In-memory ndjson scan for aggregate queries (O(N) per call; family-scale acceptable; defers SQLite migration to Option 3 hybrid trigger). Daily audit rotation `audit-YYYY-MM-DD.ndjson` on first append after UTC midnight; cross-file query layer for rolling 30-day windows. Owner-only gating on `/dashboard` + 3 `/v0/management/*` JSON endpoints reusing ADR 0007 § 7 auth model. 30s page poll (no SSE infra). Panels: per-provider quota / 24h request+cache+fallback / 30d spend trend / top-N fallback chains per spec § 4.6. Opens ADR 0007 § 12 Phase 3 deferral (Dashboard + audit query + rotation). |
| [0009](0009-interactive-mode-path-placeholder.md) | Anthropic Interactive-Mode Path (Placeholder) | Placeholder ADR (2026-05-25, Draft) — blocked on OCP ADR 0007 P0 experiment outcome. Records the maintainer's "wait + port" decision: do NOT independently implement; ride OCP's P0 result. If P0 confirms Transport A (stdio NDJSON) or B (PTY) bills as subscription rather than Agent SDK credit, port to OLP `lib/providers/anthropic.mjs` (Option 1 parallel impl, or Option 2 OCP-as-backend; decision deferred to P0-resolution time). If P0 fails on both, shelve. No Phase 4 D-day scheduled until P0 lands AND maintainer issues explicit "go" naming this ADR. |
## When to write a new ADR
+1 -1
View File
@@ -1,6 +1,6 @@
{
"name": "olp",
"version": "0.3.0",
"version": "0.3.1",
"description": "Personal multi-provider LLM proxy. Successor to OCP. One HTTP endpoint, multiple subscriptions behind it, automatic routing + fallback + caching.",
"type": "module",
"main": "server.mjs",
+9 -2
View File
@@ -577,10 +577,17 @@ async function handleHealth(req, res) {
const available = listAllProviderNames().length;
const providerStatuses = {};
for (const [name, provider] of loadedProviders) {
// D56 / v1.x roadmap #4 (ADR 0002 Amendment 6 forward note): surface
// per-provider active spawn count for capacity-planning observability.
// D38 shipped getActiveSpawnCount; this is the /health integration.
// The field is set BEFORE healthCheck() in case healthCheck throws —
// activeSpawns is cheap (in-memory counter read) and useful even
// when healthCheck fails.
const activeSpawns = getActiveSpawnCount(name);
try {
providerStatuses[name] = await provider.healthCheck();
providerStatuses[name] = { ...(await provider.healthCheck()), activeSpawns };
} catch (e) {
providerStatuses[name] = { ok: false, error: e.message };
providerStatuses[name] = { ok: false, error: e.message, activeSpawns };
}
}
sendJSON(res, 200, {
+47
View File
@@ -6247,6 +6247,30 @@ describe('D40 — X-OLP-Fallback-Detail header (issue #7)', () => {
assert.equal(result.fallbackDetail[0].code, 'SPAWN_FAILED');
});
it('engine: AUTH_MISSING terminates chain, fallbackDetail tuple records trigger_type:"auth_missing" (D56, v1.x roadmap #7)', async () => {
// v1.x roadmap #7 (D40 follow-up): explicit pin that the AUTH_MISSING
// path produces a fallbackDetail tuple with trigger_type:"auth_missing"
// BEFORE the engine's early-return at engine.mjs:486. Was implicit via
// other engine-path tests; D56 makes it explicit so any future refactor
// that moves the tuple-push past the auth_missing branch fails this.
const err = new ProviderError('No OAuth token found', 'AUTH_MISSING');
const chain = [
{ provider: 'anthropic', model: 'claude-sonnet-4-6' },
{ provider: 'openai', model: 'gpt-5.5' }, // present to verify AUTH_MISSING does NOT advance
];
const hopFn = async () => { throw err; };
const result = await executeWithFallback(chain, makeIR({ model: 'claude-sonnet-4-6' }), hopFn);
// AUTH_MISSING is HARD_TRIGGER_CODES[AUTH_MISSING]=false (engine.mjs L52);
// chain stops at hop 0 instead of advancing to openai.
assert.equal(result.chunks, null, 'AUTH_MISSING terminates chain');
assert.equal(result.fallbackHops, 0, 'AUTH_MISSING does NOT advance — stays at hop 0');
assert.equal(result.fallbackDetail.length, 1, 'fallbackDetail has exactly 1 tuple (the AUTH_MISSING hop)');
assert.equal(result.fallbackDetail[0].code, 'AUTH_MISSING');
assert.equal(result.fallbackDetail[0].trigger_type, 'auth_missing');
assert.equal(result.fallbackDetail[0].provider, 'anthropic');
assert.equal(result.fallbackDetail[0].hop, 0);
});
it('engine: non-ProviderError exception → tuple code is "UNKNOWN"', async () => {
const err = new Error('Something unexpected'); // no .code field
const chain = [{ provider: 'anthropic', model: 'claude-sonnet-4-6' }];
@@ -10522,6 +10546,29 @@ describe('Suite 21 — D46 owner-vs-guest gating (ADR 0007 §§ 7.1, 7.2)', () =
assert.ok('status' in body.providers, 'owner /health providers.status must be present');
});
it('21c-extra: owner /health each provider status carries activeSpawns field (D56, v1.x #4 / ADR 0002 Amendment 6)', async () => {
// ADR 0002 Amendment 6 forward note: when surfaced on /health, the
// per-provider concurrency counter lives at providers.status.<name>.
// activeSpawns. D56 wires it. With no requests in flight, the value
// is 0; under saturation it equals hints.maxConcurrent.
const { plaintext_token } = createKey({ name: '21c-extra', owner_tier: 'owner', providers_enabled: '*', olpHome: TMP });
const r = await fetch({
port, method: 'GET', path: '/health',
headers: { Authorization: `Bearer ${plaintext_token}` },
});
assert.equal(r.status, 200);
const body = JSON.parse(r.body);
// At least one provider must be enabled in the fixture
const statusEntries = Object.entries(body.providers.status);
assert.ok(statusEntries.length >= 1, 'fixture has at least one enabled provider');
for (const [name, status] of statusEntries) {
assert.ok('activeSpawns' in status,
`providers.status.${name}.activeSpawns MUST be present (ADR 0002 Amendment 6)`);
assert.equal(typeof status.activeSpawns, 'number');
assert.ok(status.activeSpawns >= 0, 'activeSpawns >= 0');
}
});
it('21d: owner_only_endpoints config opt-out — empty list → guest gets full payload', async () => {
__setAuthConfig({
allow_anonymous: true,