Version. 0.1 Date. 2026-06-03 Provenance. Engine-source trace, Operator: Marvin Percival. Steps up from the seed-creation investigations to the whole engine/wrapper boundary: what the engine's surface actually is today, and how far it is from an architecture-enforced API any foreign wrapper could talk to. Status. Investigation / inventory + assessment. Report-only — no design, no proposal, no engine changes. Reads with (the seed/boundary set).
investigations/loomworks-seed-creation-mechanism-map-v0_1.md — the seed lifecycle map.investigations/loomworks-seed-creation-three-paths-deep-dive-v0_1.md — the three-paths divergence.investigations/loomworks-seed-creation-engine-contract-v0_1.md — the seed-creation interface contract (a worked example of the boundary this inventory generalizes).standing-notes/loomworks-standing-note-engine-wrapper-boundary-v0_1.md — the lens (engine must survive any wrapper).
Code citations. engine: = the loomworks-engine repo; OL: = the loomworks (operator-layer frontend) repo. Line numbers indicative, names load-bearing.
There is no single engine boundary — there are two, because "the Companion" is two things:
loomworks, Next.js) is a real remote HTTP client. OL: src/lib/api.ts:15-16: API_BASE = process.env.NEXT_PUBLIC_API_URL || "http://localhost:8000"; every call is fetch(${API_BASE}${path}) (:67). A network boundary exists and is crossed today./operator/converse orchestration: classifier + router + translators) lives inside the engine process and reaches capabilities by direct in-process calls to route handlers and core functions, bypassing HTTP and auth. engine: orchestration/routers/converse.py:185 converse_route(..., _check=None, _internal_delegation=True); :232 commit_seed_from_brief(..., _check=None); :295 extract_seed_from_discovery(...); :371 create_engagement_from_conversation(...); router.py:971 draft_engagement(...). No internal HTTP client exists in orchestration/ (no httpx/requests/AsyncClient).So the boundary is enforced by architecture for the UI, and by discipline only for the brain — which sits inside and uses privileged shortcuts no external surface has.
One FastAPI app, create_app() (engine: api/app.py:390, title="Loomworks", version=LOOMWORKS_VERSION — the package version, not an API contract). It mounts ~50 routers / ~197 HTTP routes flat (app.py:667-785), spanning the full domain (engagements, seed_view, seed_conversation, seed_extraction, seed_commit_from_brief, me_create_engagement, manifestations, shapings, renders, considerations, assertions, contributions, files, me/*, dashboard, workspaces, tags, auth, credits) — and the orchestration /operator/converse router mounted as a peer.
Reachability tiers:
get_current_person, assert_engagement_creator, require_operator_designation).draft_seed, induct_seed, amend_candidate_seed, commit_engagement/_divergent, revise_seed (creation.py). Wrapped by routes (POST /engagements, /seed/induct, /instantiate) but also called directly in-process.seed_fields produced only inside converse_route (see the engine-contract doc).A mix, not a uniform API client:
/operator/converse, /operator/conversation-history, /operator/create-engagement, and raw domain routes /engagements, /me/credits, /me/spend, /me/settings/, /me/dashboard/needs_you, /me/dashboard/recent, /tags, /workspaces, /saved-filters, /contributions, /files/, /admin/grants, /claim/grant, /auth/./operator/converse) is not a client of the API — it's co-resident and calls internal functions/handlers directly, with auth stubbed (_check=None) and billing/usage skipped (_internal_delegation=True).There is no uniform engine API the Companion is a client of.
draft_engagement is POST /engagements and called in-process (router.py:971, no HTTP/auth). converse_route, commit_seed_from_brief, extract_seed_from_discovery, create_engagement_from_conversation, dashboard's list_needs_you_route (orchestration/routers/inbox.py:32) — all both routes and direct callees._check=None skips assert_engagement_creator; _internal_delegation=True skips usage-capture/consumption hook. The in-process brain has privileges a foreign HTTP wrapper cannot replicate._adapt_seed_fields_for_draft_seed (seed_commit_from_brief.py:97) translates this Companion's seed_fields emission shape into draft_seed kwargs. The translator (translators.py:284) maps seed_document→draft_specification and drops seed_fields/completion. intent_hint on /operator/converse is shaped to the frontend's create-engagement entry.
No. No version prefix or contract version (grep for /v1, api_version, /api/v returns nothing); the only "version" is LOOMWORKS_VERSION on the app title (app.py:393) — the software version. ~197 routes grown phase-by-phase, mounted flat; the orchestration router is just another include_router peer; OpenAPI exists only as FastAPI's auto-generation, not a governed published contract. No code construct or doc asserts "this is the engine API, complete and versioned."
Already API-shaped (partly done): a real, configurable HTTP boundary exists and is consumed by a wrapper (the frontend over NEXT_PUBLIC_API_URL). Not greenfield. Auth deps gate routes; the domain CRUD is genuinely externally reachable.
Welded / privileged (the gap): the Companion's brain is a co-resident insider, not a client — it bypasses the surface a foreign wrapper must use, with auth/billing shortcuts unavailable externally; so the route surface is not complete or parity-true. Phase 31 extraction is welded; wrapper-specific shapes bake one caller into engine code.
Missing: any versioned, governed, complete contract; any guarantee that everything a wrapper needs is reachable through public routes with no insider shortcut; parity between in-process-brain capability and HTTP-surface capability.
Answering Marvin's framing question: the boundary is enforced by discipline plus a partial physical HTTP boundary (the UI), but not by architecture — the brain reaches in from inside and uses privileged back doors. "Give the engine an API" is therefore two different-sized things:
_check=None/_internal_delegation auth-and-billing skips, direct-handler calls, welded extraction). The real boundary-enforcement project, and what the standing note's "engine must survive any wrapper" actually demands.Short version: a network boundary exists and one wrapper (the UI) respects it; the other wrapper (the brain) lives inside and bypasses it. The distance to architecture-enforcement is the distance of moving the brain out and closing those shortcuts — not of inventing an HTTP boundary from scratch.
Investigation / inventory only. No engine or wrapper code changed. No API designed or proposed. Filed in loomworks-record/investigations/. Pairs with the seed-creation map, the three-paths deep-dive, the engine-contract doc, and standing-notes/loomworks-standing-note-engine-wrapper-boundary-v0_1.md (the lens).