# Eve gap analysis: what Eve should borrow from Eunomia, Zel and Linear

- Date: 2026-09-22
- Baseline: oshun `10771d1e8e4` (branch `olt67`); eunomia `FEATURES.md` (506
  checked, 31 open, reconciled 2026-08-29); zel-ai `docs/ZEL_PRODUCT_PRD.md`
  (2026-09-10); Linear public changelog through 2026-09-14
- Author: Claude Fable 5.1, at Elikem's request
- Status: promoted. Every actionable item is a task in Eve board family
  `eve-gap-analysis` (priority P0, rank 1) as of 2026-09-22; section 15 maps
  items to task keys. The report stays the reasoning record; the board is the
  backlog of record.

Thirty-six candidate features (R1–R36), eleven UI recommendations (U1–U11)
and thirteen graph capabilities (G1–G13),
ranked for a one-person company: Elikem, plus an open-ended fleet of agents
that Eve runs. Every item names where it comes from, what Eve already has, and
where it would land in the repository. Section 9 assesses Eve's own UI and
dashboards; sections 10 and 11 record the second, source-level sweep of
Eunomia and Zel; section 12 is the second pass on Linear's 2026 features; section 13 sets out
graphs as Eve's spine.

## 1. The frame: Elikem, plus agents

Elikem is the only human at Oshun Synthetics, and Eve exists so that Elikem can
design, plan, build, create content, manage and run the whole company alone.
That single fact reorders every comparison below. Eunomia, Zel and Linear are
all built for teams: reviewer roles, tester quorums, workspaces, seats, share
links. None of that is a gap for Eve. What matters instead is three things.

- **Elikem's attention is the scarcest resource in the system.** Every feature
  that keeps low-value decisions away from Elikem, or presents the ones that do
  reach Elikem in a ranked queue, pays back immediately.
- **Agents must be able to act under policy, with audit, when Elikem is not
  there.** Eunomia's delegated-authority Steward is the clearest model of this
  in the three systems.
- **Uncertainty needs one typed channel.** Today an agent that is stuck parks a
  task with a reason. A structured question that blocks the right thing, reaches
  Elikem on the right device, and re-fires the agent when answered is the
  highest-leverage missing piece.

Verdict vocabulary used in the tables:

| Verdict | Meaning |
| --- | --- |
| HAS | Eve already ships this; not worth rebuilding |
| PARTIAL | A related seam exists but the feature as the other system ships it does not |
| GAP | Nothing comparable in Eve |
| SKIP | Exists elsewhere but is wrong for a company of one |

## 2. What Eve already is

Eve is six planes stitched together. Every gap below is measured from this
baseline.

| Plane | Where | What ships today |
| --- | --- | --- |
| Task Board | `tools/eve-task-board`, `infra/hetzner/eve` | Shared PostgreSQL backlog of record. `./eve next / claim / start / done / park / verify / dep / context / prompt / promote / pull`. Leases with fencing tokens and four-hour TTL, journals, families, dependency DAG with cycle refusal, parked reasons, evidence capped at 160 words, the eight-question `check`, `drift`, task authoring API with revision checks. HTTPS worker API with scoped keys (`board:read/work/author/review`), interrupted-operation recovery, retry identities. |
| Reviews and automation | `eve_api.reviews`, `tools/eve-reviewer` | Independent review lifecycle (submit, claim, ten-minute lease, complete with approval / changes / missing evidence, reconcile), trusted CI evidence per commit, automatic worker and reviewer switches (Codex `exec` only, default off), presentation proposals. |
| Content and publications | `apps/oshun/eve-content` | The Eve Workspace UI (Tasks, Docs Center, PRDs, Decisions, Architecture, Presentation Center, Review queue, Publications, Media, Automatic agents) over Payload-backed documents with revisions, sections, relations, successors, patch-block edits and review states; sources and task-sources; media with checksum-verified restore; publications with freeze, promote and export; UAT read-only snapshots; 16,379 catalogued documents with a full-text cache and `docs stale`. |
| Workbench | `apps/oshun/bff/src/workbench`, `apps/oshun/bff/src/routes/workbench.ts` | Governed work items (`draft → triaged → ready → leased → in-progress → in-review → shipped → verified`, plus `parked` and `rejected`), queue policy with cloud spend approvals, briefs, reports, triage, verification-failure triage, planning goals / plans / revisions, planning fleet, threads, decisions with ADR export, feature proposals, content briefs and dispatch, release notes (global feed), shipped narratives, `what_shipped_since`, fleet read model, lease listing, graph neighbourhood and explorer, operator labour accounting, publish consents. |
| Assistant runtime | `apps/oshun/bff/src/assistant`, `libs/oshun/assistant` | Builder assistant with exact confirmation cards and reversal, curated tours, drawer voice, contextual invocation, page vision, operator memory (default-on), SMX task-family skills with a prompt-hash ratchet and 251-case evaluation decks, weekly model lifecycle on a price-sorted fp8 OpenRouter route, capacity budget, turn cancellation, history compaction, citation / count / dispatch claim checks, admin tools (incidents, crash groups, review queue, support, moderation, release readiness, model registry, `board_next/show/search`). Library layer: cron and one-shot scheduler, watcher contract and engine (no UI yet, ADR-0081), Discord / Slack / Telegram / Signal / email bridges, subagents with terminal sessions, browser / code-exec / filesystem / vision tools, Voyager skill store, native desktop computer use behind a run policy (ADR-0080). |
| Reliability and evidence | `docs/adr/ADR-0080…0088`, `tools/eve-everywhere` | Twelve-plane SLO contract, operation-class reliability policy, threat model, red-team matrix, backup and recovery proofs, delivery fault game, roughly 200 evidence and verification scripts. |

Two observations shape the rest of the report. Eve's governance depth
(confirmation proof, fencing, prompt ratchets, SLO contracts) is already ahead
of all three comparators. Eve's planning and attention layers are thin: tasks
are still authored by hand from markdown trackers, uncertainty is expressed as a
parked task, and the only ranked view of Elikem's day is the terminal.

## 3. Eunomia: the pipeline and the Steward

Eunomia (`/mnt/volume300/workspace/eunomia`) is a Python master/worker system
that takes a project from idea to certified completion: PRDComposer,
TechSpecComposer, EpicPlanner, StoryPlanner, AtomicPlanner, Sequencer,
DeveloperAgent, AgentReviewer, QA, and a certification committee, with four
human gates. It reaches models only through the Claude and Codex CLIs. The
design decisions that transfer to Eve are the structural ones, not the team
ones.

| Eunomia feature | What it does | Eve today | Verdict |
| --- | --- | --- | --- |
| ClarificationIssue (D17) | The only channel for agent uncertainty. Typed scope, concern kind, suggested resolutions, state machine open → answered → applied → resolved, gate-blocking, scoped re-fire of the emitting agent once the workspace gains an answer. | `./eve park --reason human` plus a journal note. No state machine, no re-fire, no blocking semantics beyond the parked task. | GAP |
| Project Steward delegated authority (ADR-0040) | Per-project policy presets, shadow mode, confidence floor, mandatory escalation for high-risk classes, immutable decision audit with policy snapshot. The Steward can approve gates, certify tasks, triage bugs, recover failed tasks. | Automatic worker and reviewer switches; publish consents; verify must be "somebody else". No policy object that lets Eve decide on Elikem's behalf inside bounds. | GAP |
| Composer chain (PRD → spec → epics → stories → atomic tasks) | Each layer emits typed artifacts with acceptance criteria, spec anchors, scope globs, T-shirt sizes, dependency DAG, sibling scope-overlap checks and clarifications for anything thin. | Planning goals, plans and revisions exist in the workbench; board tasks are imported from markdown trackers or authored by hand. | PARTIAL |
| Cascade barrier (D3/D4) and identity hashes (D16) | A changed PRD or spec marks downstream scopes, pauses in-flight work, re-plans, supersedes, and dispatches. Stable feature identities survive the re-plan. | Document successors and relations; `docs stale` is a 35-second git-blame heuristic run on demand. | PARTIAL |
| WorkProduct (D15) | Structured output of a developer run: diff set, scope check, test delta, decision log, human inputs, agent notes. The reviewer reads the decision log first. | `done --evidence` takes prose under 160 words and a commit SHA. | GAP |
| Certification committee (ADR-0043) | Deterministic floor (build, imports, routes, orphans, single DB registry, whole-app render), model ceiling (structural, security), intent tier (feature audit, coherence). Findings dedupe by hybrid identity; loop terminates on novelty with a per-attempt budget; only the floor gates. | `./eve check` asks eight questions of the board; ~200 evidence scripts under `tools/eve-everywhere` exist but are not a committee that runs per family or release. | PARTIAL |
| BugReport pipeline and Auto-mapper | Five intake channels, severity classification, embedding rank against features, vision check on evidence, confidence with alternatives, a human triager only when confidence is low. | Admin crash groups, incidents, support and moderation queues are readable by the assistant; nothing maps them onto board families automatically. | PARTIAL |
| Progress snapshots and burn-down (ADR-0022) | Append-only snapshots on cron, cascade and gate events; velocity and ETA with confidence tiers; sparklines per project. | `./eve stats` and `./eve board` print current counts only. | GAP |
| LLM control plane (LLM-CP, CLI-007…010) | Durable invocation ledger, scoped allowances per organisation / project / workload with periods and hard stops, budget-aware routing, fallback chains with account cooldowns, prompt version linked to downstream outcome. | Capacity budget, provider route governance, weekly SMX lifecycle, denial-of-wallet audit. No per-lane allowance periods, no fallback chain across Codex accounts. | PARTIAL |
| Governed agent configuration (ADR-0045) | Immutable agent revisions, skill version pins, prompt lineage with evaluation, promotion and rollback. | SMX prompt hash ratchet and evaluation decks cover the served bytes; ADR-0082 defines skill ownership. Promotion and rollback are manual re-stamps. | PARTIAL |
| Master/worker distributed execution (ADR-0019) | Redis Streams dispatch, heartbeats, stale-worker watchdog and job reclaim, bare-clone cache with worktrees, async push after every agent commit. | Worker API, leases, fencing tokens, planning fleet and fleet read model. No heartbeat or automatic reclaim of a dead worker's lease beyond TTL expiry. | PARTIAL |
| Environment sessions (ADR-0024) | Hosted code-server IDE on EC2, artifact-only evidence workspaces, signed artifact URLs. | None. Review happens on the Mac or the Linux box. | GAP |
| Notes, brainstorm boards, readiness signal | Draft → promote notes, Excalidraw boards with semantic contracts, agent-generated architecture boards, a green/amber/red readiness hint before drafting a PRD. | Threads and a graph explorer in the workbench; documents in Eve content. | PARTIAL |
| Work intake (ADR-0038) | A work request is routed deterministically: direct task, additive PRD, or full composition; advisory duplicate detection never suppresses work. | `create_work_item` and `./eve promote`. No routing, no duplicate check. | PARTIAL |
| Chatbot with mutation gating (D11) | Read tools run inline; any mutation needs confirmation. | Eve's confirmation cards are stronger: complete-state proof before, after parking, and after decline. | HAS |
| F-classified failures | Every failure carries a code; returning nothing is forbidden. | CLI refusals carry a code and a sentence; the reliability policy classifies operations. | HAS |
| QA Playbook with two independent testers (ADR-0047) | Blind passes, quorum, tester invitations, per-scenario results. | Not applicable: Elikem is the only tester. | SKIP |
| Design Studio parity (ADR-0046) | Claude-Design-class studio with design-system library, share links, PDF export. | Oshun has its own studio surfaces; not an Eve concern. | SKIP |
| Identity, organisations, reviewer roles (D20) | Users, orgs, participant roles, magic links. | Scoped API keys per agent identity are the right shape when Elikem is the only person. | SKIP |

## 4. Zel: the embedded runtime

Zel (`/mnt/volume300/workspace/zel-ai`) is a NestJS platform that consumer
apps embed: chat, knowledge base, workflows, integrations, reviewable action
artifacts, usage metering, personas, voice. Most of its product model (apps, app
users, workspaces, teams, developer portal, SDKs) is multi-tenant plumbing Eve
does not need. Its runtime ideas are worth taking.

| Zel feature | What it does | Eve today | Verdict |
| --- | --- | --- | --- |
| `ask_human` and Telegram resumption | A durable run pauses on a clarification or tool-permission request and resumes when the linked Telegram user answers; approval cards render in chat and in Telegram. | Telegram, Signal, Slack, Discord and email bridges exist in `libs/oshun/assistant/src/channels`; confirmation cards live in the drawer. No pause-and-resume tied to a channel answer. | PARTIAL |
| Workflows | Durable automation graphs: manual, scheduled, webhook or agent-generated triggers; wait / resume, approval, loops, branching, sub-workflows; AI-generated from chat; visual editor. | Scheduler (cron and one-shot prompts) and a watcher contract without a worker or UI (ADR-0081). | PARTIAL |
| Runtime sessions and persona playbooks | Cross-turn durable state for guided multi-step jobs with step kinds, required inputs, approval flags, a resumable task pane. | Planning plans and intent machines cover work items; no generic guided-job substrate for operator routines. | PARTIAL |
| Skill mining | Completed runs become mining traces; extractors propose learned skills; a curator and review queue gate activation; activation feedback closes the loop. | Voyager recipes can be saved and retrieved; ADR-0082 defines the admission contract but nothing mines the journals. | GAP |
| Dynamic MCP connectors | Database-backed connector records, encrypted credentials, discovery, cached tool catalogs, risk classification, approval-gated generic action artifacts; first-party MCP for GitHub, Linear, Google. | Eve is an MCP server (18 tools). Conformance and trust evidence exists for consuming MCP, but no governed connector registry. | PARTIAL |
| Integration preflight | Before the model runs, detect a required provider that is disconnected and emit a connect card instead of a failed tool call. | Provider route posture probes exist; no per-turn preflight. | PARTIAL |
| Usage reservations and reconciliation | Deterministic cap checks, Redis reservations released only after durable accounting, budget-exhausted as a structured state, pricing snapshots reconciled against provider usage. | Capacity budget with a Redis integration spec; weekly cost evidence; the 2026-08 lesson that billed behaviour, not catalog price, is the truth. | PARTIAL |
| Decision Council persona | A bounded read-only council of model members with different briefs, budgets and partial-success thresholds, exposed only when the persona activates. | Decisions with ADR export; no structured dissent step. | GAP |
| Knowledge base with provider sync | Drive, GitHub and Linear sync, embeddings, permission-aware search, attachments become knowledge. | Repository-scoped catalogue with FTS and dense-index probes. No external sources. | PARTIAL |
| Full-duplex voice | LiveKit worker, Modal STT / TTS, VAD turn detection, push-to-talk and live-listen. | Drawer voice over OpenRouter STT / TTS and ElevenLabs; a voice-depth decision record already exists. | PARTIAL |
| Patch semantics for existing documents | Find / replace hunks, stale base rejection, diff viewer. | Patch-block edits with revision preconditions. | HAS |
| Operator memory and workspace policies | User memories and policies injected into prompt context. | Operator memory is default-on with poisoning and governance evidence. | HAS |
| Apps, app users, workspaces, teams, SDKs, developer portal, billing plans | Multi-tenant product surface. | Not applicable. | SKIP |

## 5. Linear: attention design and agent-native tracking

Linear's 2026 direction is the most relevant of the three: it has turned an
issue tracker into a place where agents are first-class workers. Linear Agent
(March), MCP for the agent (April), Code Intelligence (May), Coding Sessions
(June), Loops (July), coding environments and browser testing (August), Priority
Inbox and Loops for product management (September). The team features are
irrelevant here; the attention and automation features are exactly what Elikem
needs.

| Linear feature | What it does | Eve today | Verdict |
| --- | --- | --- | --- |
| Priority Inbox (2026-09-03) | Separates critical notifications from routine ones, customisable by source or filter. | Notifications arrive as terminal output, the drawer, and channel bridges. No single ranked queue. | GAP |
| Triage inbox, triage rules, triage intelligence | Issues from integrations land in triage; rules set team, status, assignee, labels, project, priority in order; the model suggests properties and flags duplicates. | Work items have a `triaged` status and a triage route; there are no rules and no suggestions. | PARTIAL |
| Loops (2026-07-20, extended 2026-09-14) | Plain-language recurring agent workflows on a schedule or an event; update projects, edit documents, post to Slack. | Watcher contract and scheduler in the library; no product. | PARTIAL |
| Initiatives, project health, project updates, milestones, graphs | Status, priority, target date, health rolled up from the latest update; "Write with Agent" drafts the update from recent changes. | Families are ranked; `what_shipped_since` and shipped narratives exist; no health, target dates or drafted updates. | PARTIAL |
| Cycles | Fixed cadence, cooldowns, auto-add of started work, rollover, capacity dial from the last three cycles, scope-change graph. | None. | GAP |
| Coding Sessions, environments, browser testing, guided reviews | Assign an issue to the agent; a cloud sandbox produces a draft PR with preview links and before / after screenshots; guided reviews organise a diff into explained sections; spend limits per user and timeframe; signed commits. | Automatic worker lane with Codex, cloud spend approvals on leases, publish consents. No preview link, no guided review, no browser-tested evidence attached to the item. | PARTIAL |
| Linear Agent in comments, Slack, and as skills | `@Linear` in any thread; saved skills as slash commands; drafting issues and projects from conversation; agent-assisted document editing with text attribution and checkpoints. | Threads exist; the assistant is invoked from the drawer or contextually. No mention-invocation in threads or documents, no attribution of agent-written spans. | PARTIAL |
| GitHub automations | Branch names and PR links move issues through states automatically. | `done --commit` records a SHA after the fact. | GAP |
| SLAs | Rules apply deadlines by priority; risk indicators and notifications before breach. | Lease TTLs on tasks and reviews; nothing ages a question waiting on Elikem. | PARTIAL |
| Views, display options, insights | Saved filtered views as list, board or timeline; instant breakdowns on any view. | The Eve Workspace Tasks view is a filtered list with a detail pane; the work-item kanban is in the member-shell explorer; `@oshun/workbench-kit` ships DataTable, StageBoard, TimelineEditor and a command palette that the Workspace does not mount. No saved views, no timeline, no breakdowns. | PARTIAL |
| Customer requests | Requests captured from support channels link to issues; customers carry tier and revenue; views by request count. | Support queue, feedback store, member complaints. Release feed is deliberately global. | PARTIAL |
| Asks | Slack / Teams / email requests become issues. | Channel bridges exist; no intake into the board. | PARTIAL |
| Issue relations, sub-issues, templates, callouts | Blocks / blocked-by / related / duplicate with merge; templates for issues, projects and documents. | Dependencies and sections; no duplicate or related relation, no templates. | PARTIAL |
| Release pipeline changelogs | Aggregated release notes with auto-generation. | Release notes and shipped narratives. | HAS |
| Document version history and checkpoints | Restore by checkpoint. | Document revisions with preconditions. | HAS |
| Teams, private sub-teams, team initiatives, third-party app approvals, Okta-managed MCP, seats | Organisation features. | Not applicable. | SKIP |

## 6. Recommended build list

Three tiers. NOW items reduce load on Elikem or let Eve act safely while Elikem
is elsewhere. NEXT items deepen planning and delivery quality. LATER items are
real but can wait for the first two tiers to prove out. Effort is relative to
the existing seams: S is days, M is a week or two, L is a multi-week
initiative. Sizes are judgement, not measurements.

### NOW: attention and delegated action

**R1 · Clarification queue · M.** One typed channel for agent uncertainty. An
agent emits a question with scope (task, document section, family), concern
kind, suggested answers and what it blocks. States open → answered → applied →
resolved. Answering re-fires the agent on the same task with the answer in its
brief. Delivered to the drawer and to Telegram or Signal, with an age indicator.
Replaces `park --reason human` for questions.
From: Eunomia D17, Zel `ask_human`, Linear SLAs.
Where: `tools/eve-task-board` schema and worker API (`./eve ask`,
`./eve answer`), an MCP tool, `libs/oshun/assistant/src/channels`.

**R2 · Priority inbox for Elikem · M.** A single ranked queue that merges
clarifications, reviews awaiting Elikem, confirmation cards, publish consents,
watcher deliveries, crash groups and lease anomalies. Rules by source and
severity decide what is critical; everything else is a daily digest. Mobile
through the admin-mobile notifications surface and the channel bridges.
From: Linear Priority Inbox, Eunomia two-pane Inbox.
Where: `apps/oshun/web/src/components/workbench/NotificationCentre.tsx`, a BFF
inbox read model, `apps/oshun/admin-mobile`.

**R3 · Eve Steward: delegated authority under policy · M–L.** A versioned
per-family policy with presets (advisory, shadow, delegated), a confidence
floor, a list of decision classes Eve may take alone (verify a shipped task,
approve a non-PRD document review, publish a release note, unpark, retry a
failed lane) and classes that always escalate to R1. Every decision writes an
immutable audit row with the policy snapshot, model, rationale and confidence.
Shadow mode records what Eve would have decided so Elikem can calibrate before
delegating.
From: Eunomia ADR-0040 and PST-001…010.
Where: `apps/oshun/bff/src/workbench` beside intent machines and publish
consents; automation switches in `eve_api.agent_automation`.

**R4 · Triage before Elikem · M.** New items from crash groups, support,
watchers and channel intake enter as `draft`. Ordered deterministic rules set
family, section and priority. An embedding pass against the task index proposes
the family and flags likely duplicates with confidence and alternatives. Only
what the rules could not settle reaches Elikem through R2.
From: Linear triage rules and intelligence, Eunomia BR Auto-mapper.
Where: `POST /v1/workbench/items/:id/triage`, the board `triaged` state,
`.cache/eve-task-board/knowledge.sqlite` for the embedding index.

**R5 · Eve Loops · L.** Plain-language recurring automations with a cron or
event trigger, bounded tools, wait and approve steps, and a delivery target.
First loops: the weekly family update, the stale-document sweep, lease-expiry
reclaim, the SMX model lifecycle run, a nightly board `check`. Needs the worker
ADR-0081 deferred, plus a list page with pause and run-now.
From: Linear Loops, Zel workflows, Eve's own watcher contract.
Where: `libs/oshun/assistant/src/scheduling` and `watchers`, a BFF loop
registry, a `WorkbenchShell` page.

### NEXT: planning and delivery depth

**R6 · Planning chain from an Eve document · L.** From a PRD or design document
in Eve content, generate epics, stories and board tasks with scope globs,
acceptance criteria, spec anchors as Eve section IDs pinned to a revision, a
dependency DAG, sibling scope-overlap checks and a one-day granularity rule.
Thin or contradictory nodes raise R1 questions. Elikem's single approval of a
plan revision dispatches it.
From: Eunomia PRD / TSC / EPL / STL / ATL and Sequencer.
Where: planning goals / plans / revisions in
`apps/oshun/bff/src/routes/planning-*.ts`, the task authoring API,
`./eve promote`.

**R7 · Change cascade from document revisions · M–L.** A superseding revision
signals every task that cites the changed section, pauses leased work on it,
re-plans the scope, supersedes what no longer applies and dispatches the rest.
Stable task identities survive. Make `docs stale` event-driven instead of a
git-blame sweep.
From: Eunomia D3, D4, D16.
Where: `doc_links`, `task_links`, the content-events collection, intent
machines.

**R8 · Typed work product on done · M.** `./eve done` accepts a structured
product beside the prose: diff set, scope check against the paths the task
declared, test delta, decision log, and the inputs Elikem gave it along the
way. The reviewer reads the decision log first. Eve renders a guided review for
Elikem: sections of the diff with a one-line explanation each.
From: Eunomia D15, Linear Guided Reviews.
Where: `lib/done.mjs`, the worker API, `tools/eve-reviewer`, the review report
schema.

**R9 · Certification committee per family and release · L.** Unify the evidence
scripts into a committee: a deterministic floor (build, typecheck, import
graph, route registration, orphan modules, whole-app render), a model ceiling
(structural and security sweeps) and an intent tier (does the family do what
its tracker asked). Findings dedupe by identity and become board tasks; the
loop ends on novelty with a per-attempt budget; only the floor gates a family's
closure.
From: Eunomia ADR-0043, AUD-001…040.
Where: `tools/eve-everywhere/verify-*`, `./eve check`, family policies.

**R10 · Family health and agent-drafted updates · M.** Families gain status,
health (on track, at risk, off track), target dates and milestones. Append-only
progress snapshots on cron and on state changes; velocity and ETA with
confidence tiers; sparklines in the board view. Every week Eve drafts the
family update from `what_shipped_since`, journals and open R1 questions, and
posts it to the release feed and Elikem's channel.
From: Linear initiatives and project updates, Eunomia ADR-0022.
Where: the `families` table, a snapshots table, shipped narratives, release
notes.

**R11 · Commit and PR automation · S–M.** A commit trailer or branch prefix
carries the board key. A push moves the task to in-progress, a merge to main
records the SHA and moves it to shipped, and a webhook refuses `done` for a
commit that does not exist on the remote. Closes the "done before the commit"
defect the board README documents.
From: Linear GitHub automations.
Where: a GitHub webhook into the worker API, `./eve done --commit` validation.

**R12 · Board page: the command centre · M–L.** A browser view of families and
tasks as list, board and timeline with saved filters, keyboard-first
navigation, quick-add into `draft`, and the R2 inbox docked. The Eve Workspace
Tasks view is the starting point (list, filters, detail, actions); the
workbench kit already has DataTable, StageBoard, TimelineEditor, HierarchyTree
and a command palette. Section 9 (U1, U2, U3) details the UI side.
From: Linear views, Eunomia Boards / MyQueue / State of Affairs.
Where: `apps/oshun/web/src/components/workbench`, BFF read-only board tools.

### LATER: compounding advantages

**R13 · Learned skills from journals · L.** Mine completed task journals, review
reports and Elikem's corrections into candidate recipes; a review queue admits
them under the ADR-0082 contract; activation feedback feeds the next mining
pass. The SMX ratchet stays untouched.
From: Zel skill mining and curator.
Where: `libs/oshun/assistant/src/skills`, the `events` journal, eval decks.

**R14 · Per-lane allowances and fallback chains · M.** Daily, weekly and
monthly allowances per lane with hard stops and alerts; fallback chains with
cooldowns across the Codex subscription and OpenRouter routes; an invocation
ledger that links the served prompt version to the downstream verify outcome.
From: Eunomia CLI-007…010, LLM-CP.
Where: capacity budget, provider route governance, model lifecycle persistence.

**R15 · Governed connectors: Eve as MCP client · M–L.** A connector registry
with encrypted credentials, tool-catalog cache, risk classification and the
existing read-inline / write-as-card rule. First connectors: GitHub, Hetzner,
OpenRouter usage, Stripe, Telegram.
From: Zel dynamic MCP connectors, Linear Agent MCP.
Where: MCP trust and conformance evidence in `tools/eve-everywhere`, toolset
scope.

**R16 · Cycles for the fleet · M.** A weekly cycle that auto-adds started tasks,
rolls unfinished ones forward and shows a capacity dial from the last three
cycles' measured throughput per lane, with a scope-change graph. Gives Elikem a
pace to plan against instead of an open backlog.
From: Linear cycles.
Where: board schema, R10 snapshots.

**R17 · Work-request intake with routing · M.** A message from Telegram, Signal
or email becomes a work request. Deterministic routing sends it as a direct
task, an addition to an existing family plan, or a new R6 planning run;
duplicate detection is advisory and never suppresses.
From: Eunomia ADR-0038, Linear Asks.
Where: channel bridges, `POST /v1/workbench/items`, R4 triage.

**R18 · Preview links and browser-tested evidence · L.** Each agent PR gets an
ephemeral preview on the Hetzner Dev host and before / after screenshots
attached to the work item, with spend limits per lane per timeframe. Guided
review from R8 links to it.
From: Linear Coding Sessions and environments.
Where: Hetzner release controller, publish consents, cloud spend approvals.

**R19 · Hosted review IDE · M.** code-server on the Linux box behind Eve auth so
agent work can be reviewed from any device, with artifact-only evidence
workspaces for runs that should not expose a full checkout.
From: Eunomia ESP-015…019.
Where: `infra/hetzner/eve`.

**R20 · Decision council before ADR export · S–M.** A bounded read-only council
of cheap-model members with different briefs produces structured dissent on a
drafted decision. Elikem still decides; the council output attaches to the ADR.
From: Zel Decision Council persona.
Where: `draft_decision` / `export_decision_adr` tools.

**R21 · Notes and brainstorm intake with a readiness signal · M.** A notes kind
and Excalidraw boards in Eve content as planning inputs, promoted into a PRD
run; a green/amber/red readiness hint before R6 drafts anything.
From: Eunomia NOT, BRD, RDY.
Where: Eve content collections, threads.

**R22 · Full-duplex voice · L.** Only if the drawer voice proves limiting for
hands-free operation; the existing voice-depth decision record should be the
gate.
From: Zel LiveKit voice worker.
Where: `apps/oshun/bff/src/assistant/voice-config.ts`.

**R23 · Member request counts on tasks · S–M.** Aggregate counts of member
requests per task and family from the support and feedback stores, so Elikem
can sort by demand. Keeps the standing decision that the release feed carries
no per-member targeting.
From: Linear customer requests.
Where: feedback store, support queue, `task_links`.

**R24 · Templates and relations · S.** Task and document templates; duplicate
and related relations with a merge that carries journals and links to the
canonical task.
From: Linear issue relations and templates.
Where: `task_deps`, the task authoring API.

### Suggested order

R1 first, because R3, R4, R5 and R6 all need somewhere to send a question. R2
second, because once questions and reviews have a home Elikem will want them
ranked. R3 third in shadow mode, so that by the time R5 and R6 generate
decisions Elikem already knows how well Eve decides. R11 is the cheapest item on
the list and closes a known defect, so it can slot in anywhere. R29 (pre-publish
Git integration, section 10) is also NOW: it removes the merge work every
session currently does by hand. R34 (standing guidance, section 12) is NOW
because it is small and every later item reads it.

## 7. Deliberately not building

These exist in the comparators and would be wasted effort for a company of one.
Listing them keeps future sessions from re-proposing them.

- Workspaces, organisations, tenants, teams, private sub-teams, invitations,
  seats, per-seat billing.
- Human RBAC UX. Scoped agent credentials are the right model; Elikem holds the
  owner role and there is no second human to authorise.
- Two-tester QA quorums, blind passes, tester invitations, triage responsibility
  rotations, on-call integrations.
- Share links with viewer / commenter / editor roles, third-party app
  approvals, identity-provider-managed MCP.
- Developer portal, embeddable SDKs, app model, customer app users.
- Design Studio parity for Eve itself. Oshun's product studios own design work.
- Multi-human text attribution. Attribution of agent-written spans versus
  Elikem's own edits is still useful and folds into R8's review and Eve
  content's revisions.

## 8. Rules worth revisiting

- **Name the human.** Across Eve's prompts, tool descriptions, UI copy, ADRs
  and task text, "the human", "the operator", "the owner" and "a human
  reviewer" all mean one person. Say Elikem. A census of those phrases in
  `apps/oshun/bff/src/assistant`, `libs/oshun/assistant`, `AGENTS.md` and the
  Eve ADRs is a small task and removes a standing ambiguity for every agent that
  reads them.
- **"PRD, ADR and architecture approvals require an independent human"** in
  `AGENTS.md`. With Elikem as the only human, "independent" can only mean "not
  the authoring agent". Suggested wording: Elikem approves; the authoring agent
  never self-approves; a reviewer identity may pre-review. R3 then decides which
  document kinds the Steward may approve alone.
- **Verify must be "somebody else".** Today that is a second agent identity. R3
  should make that explicit: verify is delegated to Eve under policy, with
  Elikem as the escalation path, so the rule stops depending on which credential
  happened to be loaded.
- **The global release feed with no per-member targeting** was a deliberate
  decision on 2026-08-22. R23 respects it by counting rather than targeting.
- **Parking for "human" reasons** should become an R1 question addressed to
  Elikem. The park reason stays for things no agent can obtain: licences,
  devices, accounts, a human act.

## 9. Eve's UI and dashboards: comprehensiveness and ergonomics

Assessed on 2026-09-22 from source at `10771d1e8e4` and from the twelve
showcase frames in `evidence/eve-builder-showcase` (captured 2026-08-29). No
server was booted for this pass. Three prior audits already cover parts of this
ground and are not repeated: the chat-surface parity audit
(`docs/audits/EVE_CHAT_UI_PARITY_AUDIT_2026-09-11.md`, whose 205 closure items
stood at 111 open on 2026-09-16), the polish defect ledger
(`docs/audits/EVE_POLISH_DEFECT_LEDGER_2026-08.md`, 280 rows, all closed) and
the terminology table (`docs/audits/EVE_ASSISTANT_TERMINOLOGY_2026-08.md`).

### 9.1 The surfaces Elikem has today

| Surface | App and port | What it holds | Designed for |
| --- | --- | --- | --- |
| Eve Workspace | `apps/oshun/eve-content` (Payload + Next) at `/workspace` | Nav: Tasks, Docs Center, PRDs, Decisions, Architecture, Presentation Center, Review queue, Publications; Media library; Automatic agents switches; the generic Payload admin at `/admin` for the `documents`, `users`, `content-events` and `content-publications` collections. Tasks: search, project (family) and status filters, "mine" toggle, list and detail with claim (30 min), start, extend, release, park, unpark, note, finish work with evidence, verify, add and remove dependencies, "enables", linked documents, an activity journal. Documents: library with search, working documents by kind and state, pinned revisions, read and edit modes, section preview, a review and history inspector, relationships, a presentation editor, diagrams. | A team of authors, workers and reviewers with scoped credentials. Copy says "Your team's work, ownership and evidence." Light theme only, purple accent, responsive to 700 px. |
| Oshun Operations | `apps/oshun/admin` at `:3020` | Seventeen workspaces in four groups (governance, safety, content, operations): dashboard cards, unified inbox (workspace, priority, SLA and assignee filters, bulk assign to an operator id), review, policy, trust and safety, incidents, editorial, personas, models, support, privacy, analytics, Isis operations. The Operations Copilot drawer (about 460 px): context band (workspace, operator, memory), transcript with a `Consulted:` tool trace and read-aloud, confirmation cards with Approve and Decline, dictation, stop, Tours, Session details. | Many operators on shifts. Placeholder text: "Ask about queues, incidents, SLAs…". Operator identity reads "Studio Operator 01". Dark theme only. |
| Workbench explorer | `apps/oshun/web` at `:3010`, route `/assistant/graph`, inside the Lilith customer shell | Product graph with explore, work, decisions and changes tabs; work-item kanban lanes (draft, triaged, ready, leased, in-progress); ADR timeline; coverage line ("19/19 domains verified"). Built on `@oshun/workbench-kit`: three-region shell, command palette, inspector, notification centre, status strip. | Builder use, but mounted in the member product's shell with the member's serif light theme and the Lilith persona. |
| `./eve` and `TODOS/BOARD.md` | terminal | `next`, `show`, `context`, `prompt`, `families`, `stats`, `docs search`, `docs related`, `docs stale`, `check`, `drift`, reviews, promote and pull. | Coding agents first, Elikem second. From this box `./eve board` timed out on 2026-09-22 without an SSH tunnel or an API key file. |
| Oshun Admin mobile | `apps/oshun/admin-mobile` | Urgent, Inbox, Incidents, More: queue health, SLA breaches, incident acknowledgement, review cards. | On-call operators. No board task, document, review or confirmation-card surface. |
| Presentation Center and Docs Center | `docs/presentations/presentation-center` | The Eve learning path (twelve chapters, 6 h 23 m) and Use Eve (six chapters). | Teaching Eve; the accepted "Meet Eve" specimen is the target look for the redesign ledger. |

### 9.2 Comprehensiveness: what the surfaces cover and what they do not

What is covered well:

- Governed writes. Every mutation from the copilot parks an exact confirmation
  card, and the showcase frames prove approve, decline and read-back against
  Postgres. This is the strongest UI behaviour in the system.
- Document lifecycle. Revisions, review findings, publications with freeze and
  promote, UAT read-only mode, and a proper history inspector.
- Task mechanics. Claim, lease, evidence, verify, dependencies and the journal
  are all reachable from the Tasks view with the same fencing rules as the CLI.
- Operations queues. Review, moderation, incidents, support, privacy and
  models each have a workspace and the inbox composes them.

What is missing for Elikem:

1. **There is no home.** Nothing shows the state of the company on one screen:
   open tasks by family, reviews waiting on Elikem, publications in flight,
   agents holding leases, spend this week, incidents. The admin dashboard is a
   grid of operations workspaces; the Eve Workspace opens on the document
   library; the Tasks view shows one totals line.
2. **Families exist only in the terminal.** `./eve families` ranks them; the
   Tasks view has a "project" filter and nothing else. No family page, no
   health, no next-ready list, no counts by state.
3. **The agent fleet is invisible.** `admin_agent_fleet`, `list_agent_leases`,
   the planning fleet routes and the operator labour accounting exist as tools
   and endpoints. The only fleet UI is the two automation switches. Elikem
   cannot see who holds which lease, what each lane spent, or the last failed
   run without asking the copilot.
4. **Two task-shaped things live in two apps.** Board tasks are in the Eve
   Workspace; workbench work items are in the explorer inside the member shell.
   The vocabulary was unified on 2026-09-18 (ETB decision 4); the UI was not.
   The kanban is on the work-item side, the journal and evidence on the board
   side, and `./eve promote` is the only bridge.
5. **Task detail is behind the CLI.** `./eve next` prints `path:line`;
   `./eve context` bundles the documents; `./eve prompt` produces the brief;
   `./eve docs related` lists what a task cites. The Tasks view shows none of
   these, renders the journal as raw JSON in a `<pre>`, and links documents by
   path only.
6. **No attention queue.** The admin inbox is an operations queue with assignee
   and SLA semantics written for a team. Nothing gathers the things only Elikem
   can do: answer a question, approve a card, verify a shipped task, decide a
   publish consent.
7. **The copilot is a side drawer with no history.** No conversation list,
   search, rename or resume; no attachments; an operations placeholder; memory
   defaults to "Session only" in the drawer's context band. The parity audit
   already binds these to tasks; the point here is that the drawer is Eve's
   only conversational surface for building and planning, and it is sized and
   worded for queue questions.
8. **Nothing on mobile is Eve.** Admin mobile handles incidents and reviews. A
   confirmation card, a clarification, a document review or a task journal
   cannot be reached from a phone.

### 9.3 Ergonomics: how the surfaces feel to use

| Surface | Strengths | Weaknesses |
| --- | --- | --- |
| Eve Workspace | Plain, fast, readable; every action names its refusal; revision pinning and the review inspector are exactly right; search on both tasks and documents. | Eight top-level nav links with no hierarchy or counts; no keyboard model (three files handle keys at all); no command palette even though `@oshun/workbench-kit` ships one; light theme only; team copy; the Payload admin is a second, unstyled UI over the same collections; journal entries are unformatted. |
| Oshun Operations | Clear grouping, SLA pills, `Consulted:` traces, tours, read-aloud, ⌘K search and ⌘/ copilot. | Built for shifts: assignee filters, bulk assign to an operator id, "Studio Operator 01"; dark-only; the copilot drawer covers a third of the page and cannot be popped out; three names for one thing on one screen ("Operations Copilot", "Admin assistant", "Copilot"). |
| Workbench explorer | The graph plus work plus decisions plus changes on one canvas is the right idea; the shell's arrangement logic is proof-backed and accessible. | Lives in the customer shell under the Lilith brand with the member's fonts; a builder tool wearing a member costume. Cards carry no board key, evidence or journal. |
| `./eve` | Complete, byte-stable output, refusals with codes, `context` and `prompt` are the best briefs in the system. | Needs a tunnel or key file; `board` output is a text dump; no way to answer a question or approve a card from the terminal because those do not exist yet. |
| Admin mobile | Thumb-reachable tabs, deep links, offline banner. | No Eve function at all. |

Cross-cutting ergonomic problems:

- **Three sign-ins, three shells, three visual languages.** Payload users for
  the Eve Workspace, the admin session for Operations, the member session for
  the explorer, and an API key for the CLI. Purple-on-white, slate-dark and
  cream-serif for one person's tool.
- **Vocabulary drift on operator surfaces.** The 2026-08 terminology table
  fixed member surfaces around Lilith and reserved "copilot" for operator
  surfaces per `V1/BRAND.md`. Operator surfaces now say copilot, admin
  assistant and Eve interchangeably, and never say Elikem.
- **The best information is where Elikem is not.** The briefs, context bundles
  and family ranking are in the CLI; the kanban is in the member shell; the
  queues are in Operations; the documents are in the Workspace.

### 9.4 UI recommendations

These are additions to the build list in section 6 and use the same tiers and
effort scale. U1 and U2 are where R2 and R12 should land.

**U1 · Eve Home · NOW · M.** A single arrival page in the Eve Workspace:
Elikem's attention queue (R2) at the top, then families with health and next
ready task (R10), agents holding leases and this week's spend per lane, reviews
and publish consents waiting, what shipped since Elikem last looked, incidents.
Every tile links into the existing view. Where: `apps/oshun/eve-content/src/workspace`,
reading the board API, the workbench fleet read model and the admin overview.

**U2 · One board · NOW · M–L.** Bring the work-item lanes out of the member
shell and into the Eve Workspace as a board with list, kanban and timeline
views over board tasks and their promoted work items together, with saved
filters and family grouping. The explorer keeps the graph; the lanes move.
Where: mount `@oshun/workbench-kit` primitives (DataTable, StageBoard,
TimelineEditor, command palette) in the Workspace.

**U3 · Task detail parity with the CLI · NOW · S–M.** Show `path:line`, the
`context` bundle, the `prompt` brief with a copy button, related documents,
the current fencing token and lease expiry, the implementation commit as a
link, and a formatted journal instead of JSON. Attach R8's structured evidence
here when it exists.

**U4 · Family pages · NEXT · M.** One page per family: status, health, target
date, open and parked counts, next ready, blocked-by graph, recent journal,
the family's policy text. This is where R3's Steward policy is edited.

**U5 · Fleet page · NEXT · M.** Leases with holder, age and token, automation
switches, per-lane allowance and spend (R14), last runs with outcome, a stop
control per lane. Where: `planning-fleet.ts`, `list_agent_leases`,
`operator-labor-accounting.ts`.

**U6 · Eve as one conversation everywhere · NEXT · M.** A full-page Eve chat
in the Workspace with history, search, rename and resume, plus the same
drawer in Operations and the explorer. One name on every operator surface.
`V1/BRAND.md` currently reserves "copilot" for operator surfaces; that is
Elikem's call to change, and the report recommends changing it to Eve.

**U7 · One sign-in, one shell · NEXT · M–L.** Either federate the three
sessions or fold the Eve Workspace and the builder explorer into Operations
under one navigation with a "Build" group beside governance, safety, content
and operations. The admin information architecture already has the grouping
model; it lacks the build group.

**U8 · One visual language, both themes · LATER · M.** Adopt the workbench-kit
tokens across the Workspace and Operations, with light and dark in both. The
Presentation Center's "Meet Eve" specimen is the accepted look.

**U9 · Keyboard-first Workspace · LATER · S–M.** Mount the command palette,
add list navigation and single-key actions for claim, note, finish and verify,
and make every card's Approve and Decline reachable by keyboard.

**U10 · Eve on the phone · LATER · M.** Add an Eve tab to admin mobile:
attention queue, confirmation cards, clarification answers, task journal and
document review, reusing the deep-link hydration that exists.

**U11 · Copy census · NOW · S.** Replace team language on Eve surfaces ("Your
team's work", "assigned to me", "Target operator id for bulk assign", "Studio
Operator 01") with Elikem's name and single-person phrasing; one lock in the
string inventory keeps it that way.

## 10. Second pass on Eunomia: source-level sweep

A second sweep walked the `eunomia/` package, its API routes, chatbot tool
registry, YAML registries, the web pages and components, the mobile app and
every ADR through 0047, looking only for things section 3 did not cover. The
findings below are the ones that transfer to a one-person company. Team-only
findings (QA workforce and reviewer tiers, plant seeding, payments, collab
channels, tenant admin, Penpot SSO, Figma bridge) are omitted. "Eve today" is
what this checkout shows; where nothing comparable was found it says so.

| Eunomia feature | What it does | Eve today | Disposition |
| --- | --- | --- | --- |
| Operations projection (`eunomia/operations.py`, `operation_reporter.py`, `api/routes/operations.py`, `docs/v2/operations-inventory.md`) | One durable row per long operation, created before dispatch; real worker phases and heartbeats ("never synthesize percentages without a real total"); sanitised terminal reasons; acknowledge, retry, cancel; SSE stream; watchdog fails abandoned rows. | Turn traces and a telemetry sink exist; workbench-kit ships a `JobQueueView` primitive; there is no cross-job operations table spanning renders, narration, builds and agent runs. | New item R25 |
| Contextual guide tools (`chatbot/registry.py`: `get_current_screen`, `search_eunomia_help`, `get_recommended_next_steps`, `find_destination`; `web/src/components/guide`) | The assistant knows the current screen's actions, searches a product catalogue, returns sourced next steps and resolves "where do I do X" to a route. | Tours, contextual invocation and page vision exist; there is no per-screen action catalogue or next-step tool. | Fold into U6 |
| "What is Eunomia doing / why is it stuck" (`get_active_operations`, `get_operation_details`, `explain_blocker`) | Conversational status from persisted operation state. | Nothing comparable. | With R25 |
| Assistant knowledge-gap records (`api/routes/assistant_feedback.py`, `AssistantInsightsSettingsPage.tsx`) | Thumbs-down and unresolved answers become durable records typed `no_knowledge`, `no_tool`, `permission`, `ambiguous`, `runtime_failure`, `unhelpful`, grouped by screen. | `feedback-store.ts` records feedback; nothing turns it into a typed gap queue. | New item R26 |
| State of Affairs weekly report (`eunomia/state_of_affairs/`, `StateOfAffairsPage.tsx`) | Per project: progress delta, ETA with confidence, gates pending, open bugs, risk flags, one-line insight; rollups for biggest movers, stalled, watchlist; HTML export; weekly snapshot. | `what_shipped_since` and shipped narratives. | Fold into R10 |
| Dashboard "Suggested next move", "How to avoid stalls", "Due soon" (`DashboardPage.tsx`) | The one thing to touch next, with stall coaching. | Nothing comparable. | Fold into U1 |
| Continue-pipeline verb with a refusal matrix (`eunomia/lifecycle/continue_pipeline.py`) | "Advance this project" dispatches the one unstarted step, or refuses with a named reason (open clarifications, pending gate, failed tasks, no remote, no worker). | Nothing comparable; `./eve next` lists, it does not advance. | New item R27 |
| Completion certificate (`eunomia/progress/certificate.py`) | Markdown close-out: what shipped, QA evidence, PR refs, residual risks, acceptance stamp. | Verify evidence is free text. | Fold into R9 |
| Human-resume dispatch burst (ADR-0031, `docs/v2/human-resume-jit-dispatch.md`) | A task whose question was just answered jumps the queue: four human-resumed dispatches before one normal one; `SKIP LOCKED` reservation with a transactional outbox. | No queue priority for answered work. | Fold into R1 |
| Lease-owned stage executions (ADR-0032, `eunomia/execution/leases.py`) | Execution key of task, stage and epoch; completed keys suppress duplicates; explicit `paused_hitl` state distinguishes waiting-on-a-human from lost. | Fencing tokens and lease TTLs; no stage epochs, no paused-on-human state. | Fold into R1 and R3 |
| Per-project pause, drain or immediate (ADR-0033, `eunomia/projects/pause.py`) | Pause one project's execution across restarts without stopping shared workers. | Automation switches are global. | New item R28 |
| Recovery and composer-retry surfaces (`api/routes/recovery.py`, `composer_retry.py`) | Named recovery verbs instead of ad-hoc SQL. | `./eve remote pending / resume / abort` cover interrupted API operations only. | With R25 |
| Atomic planner finalisation (ADR-0042) | Commit a running marker first, then artifact, review state and gate together in a fresh transaction, failure recorded separately. | Eve content writes documents and opens reviews as separate calls. | Rule for R6 |
| Task review, early PR, merge lifecycle (ADR-0026, `registries/lifecycle.yaml`) | Review a real diff; approving re-dispatches an idempotent publisher; squash merge policy as config. | Reviews attach to a commit SHA; no PR-first flow. | Fold into R8 and R11 |
| Pre-publish Git integration (ADR-0036, `agents/git_integration/agent.py`) | Rebase onto fresh main in an isolated worktree; deterministic resolvers only for provable shapes (manifests, append-only docs, aggregators); a bounded agent for the rest, rejected if it strays or leaves markers; base SHA re-checked before push. | Every session merges `origin/main` by hand; `pnpm-lock.yaml` has a written recipe and nothing else does. | New item R29 |
| Governed review proposals (ADR-0029, `api/routes/prd_review.py`) | A comment never regenerates; a proposal bound to a component hash does, once accepted. | Document reviews carry findings; nothing distinguishes a remark from an authorised correction. | Note under R7 |
| Artifact lineage graph (ADR-0021, `SourceMaterialsPanel.tsx`) | Every generated artifact records its sources and their roles. | Document relations exist; generated presentations and docs do not record what fed them. | Fold into R21 |
| Thresholds registry (`registries/thresholds.yaml`) and HITL timeout sweep | One file for confidence floors, HITL timeout (24 h), supersede backstop, tool-call budget, max task estimate; a sweep that pauses and alerts on timeout. | Constants are spread across policies and code. | Fold into R1 and R3 |
| Per-agent model routing with fallbacks (`registries/models.yaml`; AUD-038 independent auditor never the engine that wrote the code) | Cheapest model per role, fallback per role, reviewer never the author's engine. | The OpenRouter route and the Codex lane are pinned in code and environment. | Fold into R14 |
| CLI failure taxonomy and per-worker account isolation (CLI-005, CLI-006) | `binary_missing`, `timeout`, `auth`, `rate_limit`, `nonzero_exit`, `parse_error`, `budget_exhausted`; `HOME` / `CODEX_HOME` per worker. | The Codex lane reports failures as text. | Fold into R14 |
| Project autonomy profile (`eunomia/autonomy/profile.py`) | Typed conventions agents read instead of asking; only high-risk questions reach a human. | `CLAUDE.md` and `.claude/rules` are prose. | Fold into R3 |
| Brownfield onboarding (ADR-0025, `eunomia/brownfield/`) | Feature inventory separate from the aspirational PRD; evidence rails drop claims whose paths do not resolve; targeted evidence search before declaring a feature missing. | Nothing comparable, and every Oshun root is brownfield. | Prerequisite for R6 |
| GitHub push webhook with self versus external distinction (`integrations/github_webhook.py`) | Keeps the system current when Elikem pushes from a laptop. | None. | Fold into R11 |
| Chatbot file generation (`file_gen.pdf`, `docx`, `pptx`, `xlsx`, `png`; `save_generated_file`) | Content-production verbs from chat, saved to the workspace. | Eve's turn accepts text only; presentation tools exist for slides. | Note under R21 |
| Steward memory and supervisory lane (`docs/v2/project-steward-memory-and-supervisory-lane.md`) | Semantic memory from approved components, episodic from applied decisions, retrieval capped and scoped, invalidated on artifact replacement; a second worker allow-listed to the Steward. | Operator memory is default-on; no decision-episode memory. | Fold into R3 |
| Architectural-layer dispatch phasing (`routing/layers.py`, `routing.yaml`) | "Finish the interface before wiring the backend" as scheduler policy. | None. | Note under R6 |
| Fleet resource snapshots and retained logs (ADR-0035, `observability/resources.py`, `PlatformLogsPage.tsx`) | Workers self-report memory and CPU; logs retained behind an authenticated proxy. | The 16 GB machine rules are prose; nothing measures them. | Fold into U5 |
| Non-destructive artifact integrity cron (`workspace/integrity.py`) | Content-hash reconciliation on a schedule. | Media restore verifies checksums; documents have no periodic integrity pass. | Later, minor |
| In-app documentation the guide reads (`DocsPage.tsx`, `docsContent.ts`) | "When the lifecycle looks stuck", "Investigate before retrying". | The Presentation Center teaches Eve; the copilot does not read it as help. | Fold into U6 |
| Operator mobile app (`eunomia/mobile/`) | Expo companion for approvals and overview. | Admin mobile has no Eve function. | Fold into U10 |

## 11. Second pass on Zel: source-level sweep

Same method over `api/src/modules`, the admin, portal, sandbox and embedded
packages, and the seventy planning documents under `docs/`. Tenant, SDK and
billing findings are omitted.

| Zel feature | What it does | Eve today | Disposition |
| --- | --- | --- | --- |
| Durable agent runs with sequenced, replayable events (`docs/DURABLE_AGENT_RUNTIME_PLAN.md`, `agent/run/*`, `durable-token-buffer.ts`) | User message persisted first; events saved then published with sequence numbers; reconnect replays; token deltas buffered off the live path. | Assistant sessions are durable and a long-job recovery proof exists; replay by sequence is not verified. | Fold into R5 and U6 |
| External-action idempotency ledger (`planned`, `dispatching`, `succeeded`, `failed`, `unknown`) | Retries consult the ledger; `unknown` requires confirmation. | Confirmation outcomes are retained; watcher deliveries are idempotent; content-API writes carry retry identities. | HAS, mostly |
| Artifact continuation and completion recovery (`agent-artifact-continuation.service.ts`, `completion-recovery.service.ts`) | Approval is a checkpoint, not a stop; a second attempt runs on step-limit stop, announced-but-untaken action, or empty reply. | The dispatch claim check holds a claim until the action exists; there is no second attempt on an empty reply, which the SMX decks record as "empty-reply provider tails". | New item R30 |
| Working context per conversation (`working-context-recorder.service.ts`, `agent-working-context.service.ts`) | Tool results, artifacts and error summaries remembered across turns; revalidation and pruning. | Tool-result digest and history compaction; no cross-turn working memory of tool results. | New item R30 |
| Prompt-context cache, snapshot prewarm, static-prefix cache breakpoints (`prompt-context-cache.service.ts`, `runtime-prewarm.controller.ts`, `system-prompt-caching.ts`) | Warm the snapshot while viewing; static prefix and volatile suffix so provider caches hit. | `prompt-order.ts` and the SMX prompt hash fix bytes; cache breakpoints are not verified. | New item R31 |
| Attachment rehydration by distance (`kb/image-derivative.service.ts`) | Four newest images kept; derivatives sized by turn distance; stored captions. | Attachment artifact lifecycle evidence exists; the turn accepts text only. | Note under chat parity ledger |
| Reasoning-stream normaliser (`reasoning-stream-normalizer.ts`) | Handles `<think>` leakage and provider tool-loop quirks. | Eve serves DeepSeek through OpenRouter; not verified. | Check, small |
| Turn policy by task kind (`agent-turn-policy.ts`: `quick_answer`, `lookup`, `document_summary`, `repo_analysis`, `audit_review`, `multi_source_report`, `action_result`) | Budgets sized by the kind of question. | Task-family router picks skills, not budgets. | Fold into R14 |
| Tool failure classifier, run diagnostics, provider-evidence grounding (`tool-failure-classifier.ts`, `agent-run-diagnostics.service.ts`, `provider-evidence-grounding.ts`) | After an authoritative integration fails, the model may not fill in private data. | Citation, count, lookup and dispatch claim checks do the same job for Eve's tools. | HAS |
| Research drafts with sources, versions, diff, restore, export (`research-draft-tools.service.ts`, sandbox research-drafts) | Agent-facing durable drafts with S1/S2 citations and version diff. | Eve documents have revisions and patch-block edits through the content API; no agent-facing citation or draft-diff tools. | Fold into R21 |
| Delegated analysis to a cheaper worker model (`agent/delegation/*`) | Bounded read-only sub-analysis on a cheap model. | Subagents exist with terminal sessions; no cost-tiered delegation policy. | Fold into R14 |
| Document reading tools (`prepare_document_context`, `search_within_document`, `read_document_section` with `next_action_guidance`) | Chunked reading with guidance for the next call. | `eve_document_query` offers outline, text and context with `nextOffset`. | HAS |
| Office and PDF extraction (`kb/extractors/*`) | Ingest `.docx`, `.pptx`, `.xlsx`, PDF into searchable text. | Catalogue covers Markdown and slide JSON. | Later, minor |
| Learned-skill review inbox, activation feedback, policy settings (`skills/review/*`, `skill-activation-feedback-policy.ts`) | Approve, reject or edit a mined candidate; activation feedback loops back. | ADR-0082 admission contract without a review inbox. | Fold into R13 |
| Persona reference library with progressive disclosure (`persona-reference-tools.service.ts`) | References read on demand; never grant tool permissions. | SMX playbooks are static; Voyager recipes are mutable. | Fold into R13 |
| Hermes skill rules (`docs/HERMES_SKILL_ARCHITECTURE_ANALYSIS.md`) | Procedural not factual, provenance-aware writes, telemetry outside skill content, curator as hygiene, approval gate with pending store. | Partly encoded in ADR-0082. | Rubric for R13 |
| Product-management method library and playbooks (`skills/personas/product-management/references/`) | JTBD canvas, opportunity tree, PRD and stories, interview synthesis, journey map, lean canvas, OKRs, experiment design, Design Sprint tools, PM critic; playbook steps `clarify → problem_statement → hypothesis → competitive_context → stakeholders_opportunities → solution_brief → prd_and_stories → decision_review → review_publish`. | Nothing comparable for product design work. | New item R32 |
| Trusted-automation policy (`workflow-trusted-automation.ts`: `auto`, `approval_required`, `trusted`; policies `pending`, `active`, `revoked`) | Generated automations get approval gates for unsafe actions unless a pending policy is explicitly authorised. | Watcher authority is revocable by contract; no authorisation states. | Fold into R5 |
| Workflow outputs with acknowledgement and signed outbound webhooks (`workflow-outputs.service.ts`, `outbound-webhooks/*`) | Results handed to other systems with Standard Webhooks signatures. | None. | Later, minor |
| Scheduler tick with CTE claim dedup, filter-based webhook routing (`workflow-scheduler.service.ts`, `webhook-router.service.ts`) | Double-fire-safe claims, per-trigger error isolation. | Cron next-fire and a Redis lease exist in the scheduler. | Fold into R5 |
| HTTP tool with SSRF allowlist and provider-API blocks (`utility-tools.service.ts`) | Raw HTTP cannot bypass governed integrations. | `web-fetch.tool.ts`; allowlist not verified. | Check, small |
| Per-purpose model preferences and OpenRouter catalogue import (`docs/ADMIN_MODEL_CONTROL_PLAN.md`, `model-pricing-catalog.service.ts`, `openrouter-generation-stats.service.ts` `reconcileBatch`) | Resolution order per purpose; billed generation stats reconciled in batches. | Model registry and weekly lifecycle; reconciliation against billed stats is what the 2026-08 cache breach lesson asked for. | Fold into R14 |
| Usage-cap modes and estimator calibration (`hard_cap`, `soft_cap`, `warn`, `off`) | Soft modes and a calibration readout. | Capacity budget is hard. | Fold into R14 |
| API-boundary rate limiting with wait budget, queue operational monitor (`queue/rate-limit.service.ts`, `queue-operational-monitor.service.ts`) | Backlog and failed-delta thresholds; search falls back rather than waits. | Reliability policy defines backpressure classes; no queue monitor. | Fold into R14 and U5 |
| Admin access audit log with sensitive reads (`admin-audit.interceptor.ts`) | Every admin-gated request logged, message-body reads tagged sensitive. | Audit store covers actions; reads not verified. | Check, small |
| Integration health and triage (`integration_events`, health card) | Append-only integration events and a health view. | Provider route posture probes. | Fold into R15 |
| Built-in MCP tool review and workspace tool controls (`docs/BUILT_IN_MCP_REVIEW_PLAN.md`, `docs/WORKSPACE_MCP_TOOL_CONTROLS_PLAN.md`) | Per-tool review, approval and default-enable with overrides. | Toolset scope and validate; no per-tool review record for the two MCP servers. | Fold into R15 |
| Third-party MCP security review template (`docs/operations/security-reviews.md`) | A checklist before mounting a community server. | MCP trust evidence exists. | Rubric for R15 |
| Dashboard briefing (`dashboard.service.ts` `buildBriefing`) | One custom prompt, a mini agent loop, cached an hour. | None. | Fold into U1 |
| Command palette and unified search (`sandbox/src/components/command-palette/`, `pages/search.tsx`) | One jump box across chats, knowledge, integrations and pages. | The workbench kit has a palette; nothing spans tasks, docs, decks and chats. | Fold into U9 |
| Chat-first versus dashboard shell modes (`docs/SANDBOX_CHAT_FIRST_SHELL_REDESIGN_PLAN.md`) | Two modes with their own sidebars, sticky per user. | The copilot is a drawer. | Input to U6 and U7 |
| Activity feed and weekly digest (`pages/activity.tsx`, notification settings) | Filtered feed; weekly digest. | Notification centre primitive; no digest. | Fold into R2 |
| Floating assistant with source chips, reasoning block, paired tool traces (`zel-embedded/src/chat/*`) | Resizable panel; sources and tool traces as first-class chips. | `Consulted:` trace line; no source chips. | Input to U6 |
| Telegram as a full chat channel with approvals (`human-interactions/telegram/*`: `/chats`, `/switch`, inline approve and reject) | Conversation switching and artifact approval from the phone. | Telegram bridge exists in the library; no approval cards over it. | Fold into R1, R2 and U10 |
| Harness findings tracker (`docs/AGENT_CONVERSATION_HARNESS_FINDINGS.md`) | A format for "this went wrong in chat" reports. | SMX distillery register serves this role. | HAS |
| Decision-conflict rule (`docs/agents/domain.md`) | Agents flag conflicts between instructions instead of picking one. | Worth copying into `AGENTS.md`. | Rule |

### Additions to the build list

**R25 · Operations projection · NEXT · M.** One durable row per long
operation across renders, narration, builds, publications, watcher runs and
agent lanes: accepted, queued, running with real phases, terminal with a
sanitised reason; acknowledge, retry and cancel; a stream for U1 and U5; a
watchdog for abandoned rows; "what is Eve doing and why is it stuck" answered
from this table. From Eunomia `operations.py`. Where: BFF, workbench-kit
`JobQueueView`.

**R26 · Knowledge-gap queue from feedback · LATER · S–M.** Thumbs-down,
abstentions and refused actions become typed gap records grouped by screen
and skill, triaged into docs or tool tasks on the board. From Eunomia
assistant feedback. Where: `feedback-store.ts`, R4 triage.

**R27 · Advance verb with a refusal matrix · NEXT · S–M.** `./eve advance
<family>` dispatches the one next step or refuses with a named reason: open
question, review pending, failed lane, no remote, no worker. From Eunomia
`continue_pipeline.py`. Where: CLI and worker API; the same verb backs U1's
"next move".

**R28 · Pause a family, drain or immediate · NEXT · S.** Durable per-family
pause that survives restarts; drain lets leases finish, immediate returns
them to ready. From Eunomia ADR-0033. Where: family policies, queue admission.

**R29 · Pre-publish Git integration · NOW · M.** Before any agent pushes:
rebase onto fresh main in an isolated worktree, resolve only provable shapes
deterministically (lockfile, append-only ledgers, generated boards), hand the
rest to a bounded agent that is rejected if it leaves markers or strays, run
the discovered gates, re-check the base SHA, then push. From Eunomia ADR-0036.
Where: a tool under `tools/`, called by `./eve done` and the automatic worker.
This repo's standing merge pain is the reason it is NOW.

**R30 · Working context and completion recovery · NEXT · M.** Remember tool
results, artifacts and error summaries across turns in a conversation with
revalidation; run a bounded second attempt when a turn ends on a step limit,
an announced-but-untaken action, or an empty reply. From Zel. Where:
`apps/oshun/bff/src/assistant`, beside `tool-result-digest.ts` and
`history-compaction.ts`.

**R31 · Prompt cache breakpoints · LATER · S.** Split the served prompt into
a static prefix and a volatile suffix so provider caches hit, and measure the
saving on the standing route. From Zel. Where: `prompt-order.ts`, the SMX
weekly cost evidence.

**R32 · Product-design method library as Eve skills · LATER · M.** Import the
product-management references and playbook step machine as reviewed Eve
skills under the ADR-0082 admission contract, with provenance checked before
import. From Zel `skills/personas/product-management`. Where:
`libs/oshun/assistant/src/skills`, R13's review inbox.

### Folded into existing items

R1 gains the human-resume dispatch burst, lease stage epochs with a
paused-on-Elikem state, the HITL timeout sweep and Telegram answers. R3 gains
the autonomy profile, Steward memory and the thresholds registry. R5 gains the
trusted-automation authorisation states and the claim-dedup scheduler tick.
R6 gains brownfield intake as a prerequisite and the planner finalisation
transaction rule. R8 and R11 gain the PR-first lifecycle and the push webhook.
R9 gains the completion certificate. R10 gains the weekly State of Affairs
rollups and export. R13 gains the review inbox, activation feedback and the
Hermes rubric. R14 gains per-role routing with fallbacks, the CLI failure
taxonomy, task-kind turn budgets, cost-tiered delegation, billed-stats
reconciliation, soft cap modes and a queue monitor. R15 gains per-tool review
records, integration health and the security-review template. R21 gains
artifact lineage, research-draft citations and file generation. U1 gains the
dashboard briefing and "next move". U5 gains worker resource self-reporting.
U6 gains the per-screen guide, in-app help and source chips. U9 gains unified
search. U10 gains Telegram approvals.

## 12. Second pass on Linear: the 2026 agent-era features in detail

The first pass read the changelog index and five docs pages. This pass read
each 2026 changelog entry, the docs for Linear Agent, Loops, Inbox, Reviews,
Releases, Insights, project graphs and Triage Intelligence, the developer
model for agent sessions, and the late-2025 entries that introduced Product
Intelligence and third-party agents. Rows repeat a section 5 feature only
when the detail changes what Eve should build.

| Linear feature | What it does, in detail | Eve today | Disposition |
| --- | --- | --- | --- |
| Loops mechanics (docs, 2026-07-20, 2026-09-14) | Triggers: schedule with timezone; issue events (status, priority, assignee, cycle, project, label); object events (project, initiative, cycle, release); a team's triage queue. Actions: comment, create issues and follow-ups, edit metadata, edit documents, post to Slack, start a coding session, call MCP connectors. A loop may write only to the entity that triggered it unless broadened. Permissions per loop: team access, web access, code intelligence, coding sessions, externally synced issues, external sources. Draft-then-publish editing with every published version restorable. Run history with failures, and the agent can be asked to explain a run. A finished run can be continued as a conversation. Limits: eight conditions, eight actions. Runs pause when credits run out. | Watcher contract (ADR-0081) has sources, conditions, budgets and revocable authority; no write-scope default, no versioned drafts, no run history UI, no continue-as-conversation. | Fold into R5 |
| Skills (docs, 2026-06-04) | "Save this conversation as a skill": a successful chat becomes a personal skill invoked by slash command, auto-triggered when context matches, shareable, with templates for spec writing, weekly planning and drafting updates. | SMX task families are static and ratcheted; Voyager recipes can be saved but are not slash-invocable or auto-triggered; nothing turns a good Eve conversation into a skill in one step. | New item R33 |
| Workspace and personal guidance (Settings → AI) | Standing instructions the agent always reads; team guidance overrides workspace guidance; Product Intelligence accepts per-team guidance text ("do not suggest duplicates for issues with 'data pull' in the title"). | Operator memory holds facts; `CLAUDE.md` and `AGENTS.md` are prose for coding agents; there is no editable guidance document that Eve's runtime reads. | New item R34 |
| Agent sessions model (Linear for Agents 2025-05-20, developer docs) | An agent is a first-class user with a profile and activity page. Delegating an issue or mentioning the agent opens a session on that issue; the human stays the owner. Activities are typed: thought (within ten seconds), action, elicitation (a question to the human), response, error. Views filter by delegate; Insights segment by delegate; agents cannot sign in or administer. | Agents are scoped API identities; the assistant has a turn-event protocol; worker lanes write journal lines and a fleet read model, with no typed activity stream and no elicitation type. | New item R35 |
| Releases (2026-04-30, docs, 2026-06-18) | Pipelines, continuous or scheduled, owned by a team. A release is a commit SHA plus the issues auto-attached from commit references. Status automation: merged on PR merge, done when the release completes, so integrations fire when the change reaches customers. Release notes generated by the agent from included issues with a template; a changelog per pipeline; a GitHub Action and pipeline access keys; path filters for monorepos; frozen stages. | Publications carry freeze and promote for content; the Hetzner release controller deploys; the release-note feed exists; `done --commit` records a SHA. Code deploys to Dev and UAT are not objects that link board tasks. | New item R36 |
| Product Intelligence detail (2025-08-14, 2025-09-19, docs) | Suggestions for team, project, assignee, labels, related and duplicate issues with the reasoning on hover ("assignee on previous issues about performance in the mobile launch flow"); accept and dismiss feed the model; auto-apply per property or per value with auto-applied properties marked; one to four minutes per issue. | R4 as written. | Fold into R4 |
| Agent auto-fix on triage (2026-06-11) | On a new bug the agent gathers evidence through MCP (Sentry, Datadog), inspects code and attempts a fix before an engineer sees it; Linear reports roughly 30% of bugs resolved on the first pass. Scoping requests (investigate, plan) never trigger coding; only implementation does. | Crash groups and incidents are readable; nothing attempts a fix. | Fold into R4 and R18 |
| Reviews and Diffs (2026-05-27, 2026-07-30, docs, "Reviewing code in the agent era") | Review inside the tracker, synced both ways with GitHub. Reviews sidebar ordered by shipping proximity. Guided reviews group the change into sections that read like a story, core first, glue code separated, with an explanation each. Approve, request changes, merge. Iterate with a background agent from the diff and watch the diff update. Rich previews of images, PDFs and Markdown in the diff. Branch status widget (behind, conflicted). Preview-link shortcuts on the issue. Agent comments carry the agent's name, avatar and model. Providers can attach a risk score (Low, Typical, High, Very High) with an explanation. One click from the review to what inspired the change. | Reviews record findings against a commit and the reviewer's model; no diff surface, no risk score, no iterate-from-review. | Fold into R8 and R18 |
| Coding sessions detail (2026-08-20, docs) | Environments per repository: runtimes and versions, env vars, setup scripts, repository guidance. Model chosen per workspace. After coding the agent runs the app in a browser, walks the flow, captures before and after screenshots, fixes and reruns. Pricing shows tokens at provider rates plus sandbox blocks; spend caps per workspace and per user reset daily, weekly or monthly. Signed commits enforceable. Mobile Changes tab with line comments. | Automatic worker lane, cloud spend approvals, the Playwright inspect harness. No self-verification loop attached to the item, no per-lane caps with reset periods. | Fold into R14 and R18 |
| Priority Inbox mechanics (docs) | Priority tab auto-selected and customisable by source or filter; snooze and reminders with natural dates ("next quarter"); J and K navigation; quick search by title, id, type, team, project, priority; unsubscribe; a cap of 2,000 open notifications. | R2 as written. | Fold into R2 |
| Pulse (docs) | A feed of project and initiative updates, "for me", popular and recent; personal feeds from filters; a daily or weekly summary in the inbox at 06:00 local time; play the summary aloud. | Release-note feed; drawer voice can read a reply aloud. | Fold into R2 and R10 |
| LLM change summaries in notifications (2025-05-20) | Document changes summarised in inbox, email and Slack, filtering out grammar and style edits. | Content events record revisions; notifications carry no summary. | Fold into R2 and R7 |
| Advanced and AI filters, subscribe to a view (2026-02-13) | AND/OR groups; a natural-language filter; subscribe to a view to be notified when an issue starts matching; shared filtered views by URL. | `./eve list` filters. | Fold into R12 and R5 |
| Insights (docs) | Issue count, effort, cycle time, lead time, triage time and issue age as bars and scatterplots, sliced and segmented by label, project, team, assignee or status; burn-up; CSV export. | `./eve stats`. | Fold into R10 |
| Project graphs (docs) | Scope line, started and completed lines, weekly velocity, three completion estimates with a ±40% buffer and a one-quarter credit for in-progress work; refreshed hourly. | None. | Fold into R10, with the formula |
| Text attribution and agent-assisted editing (2026-07-23) | Author indicators tell a colleague's text from a loop's; agent edits highlight separately for review; restore to any checkpoint. | Revisions record the identity; no span-level attribution or highlight of agent edits. | Fold into R21 and U6 |
| Draft projects with the agent (2026-09-03) | "Create with Agent" composes a project brief from workspace context, auto-saving drafts. | Planning goals and plans exist; no agent-composed family from a brief. | Fold into R6 |
| Chat ergonomics (2026-04-23, docs) | Select text anywhere and press ⌘J to send it as context; chat as a maximised overlay; multiple chat tabs; browsable history. | Contextual invocation and page vision; the drawer has no history or tabs. | Fold into U6 |
| Team documents and anchored comments (2026-06-04) | Team pages that gather documents into sections; comments on a specific span or image of a description. | Threads exist; comments are not anchored to spans. | Fold into R21, minor |
| Web forms for Asks (2026-04-02) | Template-driven request forms; non-users can submit; follow-up by a synced email thread; every submission lands in triage. | Support queue and feedback store. | Fold into R17, minor |
| Desktop tabs with per-tab history and pinned tabs (2026-06-18) | Navigation that survives restarts. | None. | U9, minor |
| Team initiatives, private sub-teams, shared private issues, third-party app approvals, Okta-managed MCP, GitHub team reviews, Gemini Enterprise | Organisation features. | Not applicable. | SKIP |

### Additions to the build list

**R33 · Save a conversation as a skill · NEXT · M.** After a good exchange,
"save this as a skill" turns it into a named recipe with a slash command and
an auto-trigger description, stored under the ADR-0082 admission contract
beside the SMX families. Skills are versioned, listed in the drawer and the
Workspace, and never grant tools beyond the family's allowlist. From Linear
Skills. Where: `libs/oshun/assistant/src/skills`, the Voyager store, the
drawer composer.

**R34 · Standing guidance · NOW · S–M.** One editable guidance document for
Eve and one per family, versioned in Eve content, injected as the volatile
suffix of the prompt (R31) so the SMX prefix hash stays stable. Family
guidance overrides the global one. This is where Elikem writes "never suggest
duplicates for narration tasks" or "Isis work always cites a row in the
evidence file". From Linear workspace and personal guidance. Where: Eve
content, `prompt-order.ts`, R3 policy.

**R35 · Agent session protocol · NEXT · M.** Every lane run on a task is a
session with typed activities: thought (first one within seconds), action,
elicitation (which is an R1 question), response, error. Sessions render in
the task journal, the fleet page and the attention queue; delegating to a
lane keeps Elikem as owner; views and metrics segment by lane. From Linear
for Agents. Where: `events` journal, `turn-event-protocol.ts` extended to
worker lanes, `tools/eve-reviewer/worker.mjs`, the automatic worker.

**R36 · Releases as objects · NEXT · M.** A release per Dev or UAT deploy:
commit SHA, tasks attached from commit trailers (R11), status shipped then
live, generated release notes into the existing feed, a changelog per
pipeline, and integrations that fire when the change is live rather than
merged. Content publications and code releases share one timeline. From
Linear Releases. Where: Hetzner release controller, publications, release
notes, `done --commit`.

### Folded into existing items

R2 gains snooze, reminders with natural dates, keyboard navigation, quick
search, a daily summary at a set hour read aloud through the drawer voice, and
change summaries in notifications. R4 gains the reasoning-on-hover, accept and
dismiss feedback, per-property auto-apply with marked properties, and an
attempt-a-fix step for crash groups before Elikem sees them. R5 gains
write-scope defaulting to the triggering entity, per-loop permissions,
draft-then-publish versions, run history that Eve can explain, and continuing
a run as a conversation. R6 gains "create a family from a brief". R8 gains
guided sections, a risk score with explanation, iterate-from-review that sends
a finding back to the lane, and the reviewer's model on every comment. R10
gains lead, cycle and triage time per lane, burn-up, CSV export and the
project-graph estimate formula. R12 gains AND/OR and natural-language filters
and subscribing to a view. R14 gains per-lane caps with daily, weekly and
monthly resets and a cost readout that shows tokens at provider rates. R18
gains environments per repository, the browser self-verification loop with
before and after screenshots, and the scoping-versus-implementation gate. R21
gains span attribution and anchored comments. U6 gains select-to-context,
tabs and history. U10 gains a Changes tab with line comments.

## 13. Graphs as Eve's spine

Elikem's prompt for this section: graphs and graph algorithms keep turning up
as the useful structure for knowledge bases, grounding, deterministic
representations and agentic systems; what can Eve get from that? The short
answer is that Eve is already half a graph system and does not yet use it as
one. The long answer follows: what exists, what the comparators do with
graphs, the principle, thirteen concrete capabilities with the algorithm each
one needs, and what not to build.

### 13.1 What Eve already has, verified in source

| Piece | Where | What it is |
| --- | --- | --- |
| Product graph | `libs/oshun/product-graph` | A typed property graph. Node kinds are a discriminated union (domains, flows, journeys, routes, docs pages, tours, work items, decisions, threads). Twelve edge kinds: `contains`, `follows`, `verifies`, `documents`, `anchors`, `tours`, `launches`, `visits`, `tracks`, `decides`, `discusses`, `supersedes`. Every edge carries provenance (source and content hash). The graph has a Merkle-style version; `validateProductGraph` fails CI on curation that points at unknown nodes; `indexProductGraph` builds adjacency; `whatTouchesRoute` is the first query. Compiled deterministically from the curated feature catalogue, the e2e journey inventory, the docs inventory and the route table. |
| Neighbourhood grounding | `apps/oshun/bff/src/workbench/graph-neighborhood.ts` | When a discussion anchors on a node, Eve's context is the neighbourhood: containment path and children, what `documents` it, what `verifies` it, routes reached by `visits`, work that `tracks` it. Every entry cites the edge kind that justified it. Per-relation cap 8, total cap 48, truncation counted. This is graph grounding done right, for one node kind family. |
| Board graph | `tools/eve-task-board` schemas | `task_deps` with kinds `depends-on` and `parent`, cycles refused, unresolved targets kept as `unresolved-dep` links rather than dropped. `task_links` to docs, code, tasks, slides, docs pages, work items. `doc_links` from documents to docs, code, tasks, slides, docs pages and URLs. `./eve context`, `docs related` and `docs stale` are all graph walks in disguise. |
| Retrieval | `apps/oshun/bff/src/assistant/retrieval` | BM25F and a 57,008 × 1,024 dense index fused by reciprocal rank fusion (k = 60). Lexical-only is the shipping default. There is no graph arm. |
| Explorer | `apps/oshun/web/src/app/assistant/graph` | Explore, work, decisions and changes tabs over the product graph with coverage counts. |
| Domain graph code | `libs/sophia/knowledge-graph`, `libs/sophia/citation-graph`, `libs/metis/knowledge-graph`, `libs/yemaya/canon-graph`, `libs/oshun/skill-system/src/dependencies.ts` | Traversal and algorithms, learning-path optimisation, co-citation and network analysis, temporal analysis, anomaly detection, construction, embeddings, GNN and temporal modules, canon consistency checks, a skill dependency resolver with cycle detection. Built for products, reusable by Eve. |
| Docs Center plan | `docs/proposals/DOCS_CENTER_PROPOSAL.md` §7 | A `systems/` entity catalogue: one code-linked node per domain, substrate, service, library, app, contract and UE module. |

Two gaps stand out immediately. The product graph, the board graph and the
document graph are three graphs with three schemas and no edges between them
except `task_links`. And nothing computes over them: no ordering, no closure,
no diff, no metric. They are stored, walked one hop at a time, and drawn.

### 13.2 What the comparators do with graphs

- **Eunomia** is the most graph-native. The Sequencer alone owns the task DAG
  (D13); feature identity hashes (D16) keep node identity stable across
  regenerations; the cascade (D3/D4) is a forward-closure walk from a changed
  scope; ADR-0021 records every artifact's sources as a lineage graph;
  brainstorm boards are typed component, edge and boundary contracts rendered
  to Excalidraw with stable element ids (BRD-009 to BRD-011); as-built
  architecture is derived from repository scans; sibling scope-glob overlap is
  an edge conflict (F-OVERLAP); the BR Auto-mapper ranks feature nodes by
  embedding.
- **Zel** treats workflows as executable graphs (breadth-first executor,
  sub-workflow edges, recursion caps), the knowledge base as entities and
  chunks with team-tag predicates, and the Hermes analysis as a capability
  dependency graph. It has no knowledge graph as such.
- **Linear** is a graph product without saying so: issue relations (blocks,
  blocked by, related, duplicate with merge), sub-issues, project to
  initiative, milestones, customer requests to issues, releases to issues via
  commit references. Triage Intelligence proposes `duplicate` and `related`
  edges from semantic similarity with reasoning. Loops fire on entity events
  and may write only to the triggering entity unless broadened, which is a
  graph-locality rule for agent authority. Code Intelligence joins the code
  graph to the work graph.

### 13.3 The principle

A model proposes; the graph disposes. Deterministic graph structure gives Eve
four things a retrieval index and a prompt cannot:

1. **Grounding with a citation.** An answer that names the edge it followed
   (`documents`, `verifies`, `tracks`) can be checked. Eve's neighbourhood
   packs already do this; the rest of Eve should.
2. **Computation instead of judgement.** What is blocked, what is stale, what
   a revision affects, what to do next, how far a family is from closure: all
   are graph queries with exact answers. Today several of these are model
   calls or Elikem's memory.
3. **Verifiable agent action.** Write scope as reachability, lineage as a
   backward closure, certification as a walk over evidence edges. An action
   outside the allowed subgraph is refused before a card is drawn.
4. **One map for Elikem.** Product, code, documents, tasks, decisions,
   releases, agents and evidence as one navigable structure instead of four
   apps.

The counter-principle matters as much: edges enter the graph only from
deterministic compilers (code, catalogues, links, commit trailers) or as
`proposed` with confidence and provenance until Elikem or the Steward accepts
them. A model may never write a fact edge directly. That is Eve's bright line
applied to structure.

### 13.4 Capabilities, with the algorithm each needs

**G1 · The Eve graph · NOW · M.** One typed property graph in PostgreSQL that
unifies the product graph, the board (families, tasks, dependencies, links),
Eve documents (sections, relations, successors), work items, decisions,
releases (R36), agent lanes and sessions (R35), and evidence artifacts.
Tables, not a graph engine: `graph_node (id, kind, attrs, content_hash)` and
`graph_edge (from, to, kind, provenance, valid_from, valid_to)`, recursive
CTEs for walks, a materialised adjacency cache, and a Merkle version like the
product graph has today. Compilers extend `@oshun/product-graph`'s pattern:
each source compiles to nodes and edges with a content hash, and a curation
target that points at nothing fails `./eve check`. Where:
`libs/oshun/product-graph` compilers, `tools/eve-task-board` schema, Eve
content relations.

**G2 · Grounding by neighbourhood everywhere · NEXT · M.** Extend the
neighbourhood pack from graph nodes to tasks, documents, families and
releases, so every Eve answer about work cites edges. Add a third retrieval
arm: candidates from a bounded walk out of the query's matched entities
(k-hop with edge-kind filters, or personalised PageRank seeded on the
matches) fused with BM25F and dense by the same reciprocal rank fusion.
Measure it with the existing relevance-set battery before it ships; the
hybrid audit's rule that a controlled invariant is not a relevance win applies.
Algorithms: k-hop with edge filters, personalised PageRank, three-arm RRF.
Where: `graph-neighborhood.ts`, `retrieval/hybrid-search.ts`.

**G3 · Impact and cascade as reachability · NEXT · M.** R7's engine. A
superseding document revision computes the forward closure over `anchors`,
`documents`, `tracks` and `derived-from` edges to the tasks, work items,
slides and artifacts it affects, marks them stale with the path as evidence,
and hands the set to the cascade. Stable identity comes from content hashes
plus an identity hash for regenerated nodes (Eunomia D16), so untouched nodes
survive a re-plan. Algorithms: forward closure with an edge whitelist,
snapshot diff (nodes and edges added, removed, rehashed). Where: content
events, `doc_links`, `task_links`.

**G4 · Scheduling on the DAG · NEXT · M.** `./eve next` becomes topological
order under priority, with the critical path to family closure as the ETA
input for R10, blocked-by chains rendered in U2 and U3, and scope overlap
between concurrently leased tasks refused as an edge conflict (Eunomia
F-OVERLAP) using declared path globs. Algorithms: Kahn's topological sort,
longest path in a DAG, glob interval overlap. Where: `lib/next.mjs`, the
board API, family policies.

**G5 · Proposed edges for triage · NEXT · M.** R4's inference layer.
`duplicates`, `related` and `caused-by` candidates from embedding nearest
neighbours, lexical overlap and shared neighbours in the graph (common
neighbours, Adamic-Adar), written as `proposed` edges with confidence and a
reasoning string, accepted by Elikem or the Steward under R3, and merged with
journals carried. Algorithms: kNN over the dense index, link prediction by
common neighbours, entity resolution on titles and paths. Where: the triage
route, `.cache/eve-task-board/knowledge.sqlite`.

**G6 · Write-scope locality · NOW · S.** A lane, loop or assistant turn may
write only to nodes within k hops of its anchor (the task it holds, the
watcher's source, the thread it was invoked from) unless the policy broadens
it. Checked as reachability before the confirmation card and refused with the
path that failed. Linear's loop rule, generalised. Algorithm: bounded
reachability. Where: workbench agent tools, watcher engine, R3 policy.

**G7 · Lineage for evidence · NEXT · M.** Every generated artifact (deck,
document, release note, screenshot, verify evidence, model output) records
`derived-from` edges to its inputs with content hashes. "Show everything that
fed X" is a backward closure; R9's certification walks it to prove a claim
rests on current inputs; R21's research drafts get citations for free.
Eunomia ADR-0021. Algorithms: backward closure, hash-chain verification.
Where: publications, media, presentation sources, the evidence scripts.

**G8 · The code graph · NEXT · M–L.** Compile the monorepo's module, import,
route and ownership graph deterministically (tsconfig path mappings and
project manifests, since Nx's own graph breaks under worktrees here) and join
it to the product graph through `anchors` and `visits`. Then "what depends on
this library", "blast radius of this change", orphan modules (in-degree zero,
R9's floor) and hotspots (betweenness) are queries, and Code Intelligence
questions are answered from structure before a model reads a file.
Algorithms: reverse dependency closure, in-degree, betweenness centrality.
Where: a compiler beside `compileRouteSection`, `tools/eve-everywhere`
orphan and route probes.

**G9 · Family health as graph metrics · NEXT · S.** For R10, computed with no
model: frontier size (tasks whose predecessors are all done), unleased ready
count, longest blocked chain, stale documents on the frontier, verify edges
missing on shipped tasks. Where: family pages (U4), snapshots.

**G10 · Decision graph constraints · LATER · S–M.** Decisions already
`decides` nodes and `supersedes` each other. Give decisions a typed outcome,
require plan revisions to cite the decisions they rest on, and detect two
active decisions with conflicting outcomes on one node. Where:
`draft_decision`, `transition_decision`, R6.

**G11 · Shape rules in `./eve check` · NOW · S–M.** Extend the eight questions
with graph shape rules the way `validateProductGraph` already validates
curation: a ready task links to at least one document or code path; a task
may not cite a superseded document without a successor; a shipped task has a
commit edge; a verify edge may not come from a failed journey; no `proposed`
edge older than a policy age without a decision. Algorithm: rule evaluation
over the graph, like SHACL shapes without the vocabulary. Where: `lib/check.mjs`.

**G12 · Temporal graph · LATER · M.** `valid_from` and `valid_to` on edges so
"what did the graph look like when this task shipped" and "what changed since
Elikem last looked" are queries. Feeds R2's change summaries, the explorer's
changes tab and R12's subscribed views. Algorithms: time-sliced queries,
snapshot diff. Where: G1's schema from the start, so no migration later.

**G13 · Graph views for Elikem · LATER · M.** The explorer draws
neighbourhoods; add a blocked-by chain view, a blast-radius view for a
document revision, and a lineage view for an artifact. Reuse
`@sophia/knowledge-graph` traversal and `@sophia/citation-graph` network
analysis rather than writing new code. Where: `GraphExplorerBoard`, U2, U3.

### 13.5 What not to build

- **No graph database engine.** At Eve's scale (thousands of nodes, tens of
  thousands of edges, 57 thousand retrieval chunks) PostgreSQL with recursive
  CTEs and a materialised adjacency cache is enough, and it keeps one backup,
  one credential and one audit path. Revisit only if a walk exceeds its
  reliability budget in the SLO contract.
- **No model-extracted knowledge graph as truth.** Entity and relation
  extraction from prose produces plausible edges, which is exactly what Eve
  must not treat as fact. Extraction may produce `proposed` edges only.
- **No embedding features in scheduling or checks.** Similarity belongs in
  retrieval and link prediction; ordering, closure and shape rules stay exact.
- **No reachability-as-permission.** The graph decides what an action may
  touch; the scoped credential decides whether the actor may act at all. Keep
  the two layers separate.

### 13.6 Order

G1 first, because everything else needs the unified schema, and G12's
validity columns go in with it. G6 and G11 next because they are small and
each one converts an existing rule from prose into a check. Then G3 and G4,
which give R7 and R10 their engines. G2 and G5 after the relevance battery
can measure them. G7 and G8 when R9 and R18 need them. G9, G10 and G13 ride
on the pages that show them.

## 14. Evidence boundary

- Eve inventory is from source in this checkout at commit `10771d1e8e4`:
  `tools/eve-task-board`, `infra/hetzner/eve`, `apps/oshun/eve-content`,
  `apps/oshun/bff/src/workbench` and `assistant`, `libs/oshun/assistant`,
  ADR-0080 to ADR-0088, and `docs/agents/eve-everywhere-initiative.md`. The
  `oshun-eve` MCP server failed to connect in the session that wrote this (its
  launcher could not find `node`), so no live board or document query was made.
- Eunomia is read from `FEATURES.md` (506 checked, 31 open, reconciled against
  code on 2026-08-29), `CLAUDE.md`, `README.md`, `docs/v2/agents-explained.md`
  and the ADR index through ADR-0047. Nothing was executed.
- Zel is read from `docs/FEATURES.md`, `docs/ZEL_PRODUCT_PRD.md` (2026-09-10),
  `AGENTS.md` and the API module tree. Nothing was executed.
- Linear is from public pages: the changelog through 2026-09-14
  (<https://linear.app/changelog>), "Introducing Linear Agent"
  (<https://linear.app/changelog/2026-03-24-introducing-linear-agent>),
  <https://linear.app/ai>, and the docs for triage, initiatives, customer
  requests, cycles and SLAs under <https://linear.app/docs>. Section 12 adds
  the individual 2026 entries (2026-02-05, 02-13, 04-02, 04-23, 04-30, 05-14,
  05-27, 06-04, 06-11, 06-18, 07-02, 07-20, 07-23, 07-30, 08-13, 08-20, 09-03,
  09-14), the 2025 entries for Linear for Agents (05-20), Product Intelligence
  (08-14) and auto-apply triage (09-19), the docs for Linear Agent, Loops,
  Inbox, Reviews (Diffs), Releases, Insights, project graphs, Pulse, Triage
  Intelligence and agents in Linear, the developer page for agent sessions,
  and the essay "Reviewing code in the agent era" on <https://linear.app/now>.
  Pricing and plan gates are as published there.
- Sections 10 and 11 come from a second, source-level sweep on 2026-09-22 that
  walked both codebases' module trees, route files, tool registries, YAML
  registries, web pages and planning documents; every row cites the path that
  proves the feature exists. "Eve today" cells marked "not verified" were not
  checked in Eve's source and should be checked before a task is written.
- Section 9 is from source and the showcase frames only; no server was booted
  and no page was rendered for this pass.
- Section 13's inventory of Eve's graph pieces is from source in this
  checkout (`libs/oshun/product-graph`, `graph-neighborhood.ts`, the board
  and document schemas, the retrieval directory, the four domain graph
  libraries). The comparator rows reuse sections 3, 4, 5 and 10 to 12. The
  algorithms named are standard and are not claimed to exist in Eve unless the
  row says so.
- Effort sizes are judgement against the existing seams named in each item,
  not measurements.

## 15. Tasks on the Eve board

Created 2026-09-22 through `./eve add` (API mode, `eve-codex-worker-01` credential; the `remote-worker-01` identity was at its rolling 24-hour cap) into family `eve-gap-analysis`, kind `plan`, priority P0, rank 1, task policy `free`.

Elikem's review of the first cut (66 items) found them too coarse for an Opus-class worker. Every epic was therefore decomposed in the same session into atomic sub-tasks: 209 sub-tasks across 60 epics, each naming exact paths, what to do, a done-when clause with the spec or proof to run, its dependencies, and a worker-rules block (touch only the named paths; stop and park rather than invent; no stubs; test-route model binding; evidence with commands and counts). Sub-task ids are `<epic>.<n>`; dependencies run inside an epic and across epics where the report's order requires it. Each epic now depends on all its sub-tasks and its body says it is integration verification only, so `./eve next` offers sub-tasks first and an epic only when every sub-task is verified. The three C items are atomic checks and were left as written; the three L items stay atomic.

Sections on the board: NOW, NEXT, LATER, UI, GRAPH, CHECKS.

Board audit of 2026-09-22 (same day, later): every sub-task body was checked against the tree. Twenty-four sub-tasks carried a parent-context block cut at 600 characters and were rewritten with the epic's full text; three named `tools/eve-reviewer/reviewer.mjs`, which does not exist (the reviewer lane is `tools/eve-reviewer/run.mjs`, its report shape `report.mjs`); R34.1 and R21.1 named `libs/oshun/eve-content-core`, which is the package `@oshun/eve-content-core` at `tools/eve-content` (`model.mjs` holds `DOCUMENT_KINDS`); G01.2 and R06.1 named a `buildProductGraphRuntime` export that does not exist (`composeProductGraph` and `readProductGraphArtifact` do); R21.3 and R21.5 cited `publications.ts` and `media.ts` without their `apps/oshun/eve-content/src` path; R01.5 said the board check had eight questions (it has ten); R11.1's parser file was not marked new. All corrected on the board. R33 sits in NEXT (section 12 says NEXT; the first cut filed it under LATER). Tier is now also carried by status: the LATER-tier epics and sub-tasks (R13–R24, R26, R31, R32, L01–L03) and the LATER-tier UI items (U08–U10) are `later`, so `./eve next` offers NOW, NEXT, UI, GRAPH and CHECKS work in position order and the family counts 203 actionable and 72 later. Every other family on the board was checked in the same pass; the record is `docs/audits/TASK_BOARD_POLISH_AUDIT_2026-09-22.md`. Rule changes from section 8 that needed no build were applied directly to `AGENTS.md`, `CLAUDE.md` and `.claude/rules/task-checkbox-verification.md`; the wider copy census is epic U11.

| Epic | Section | Sub-tasks (each atomic: paths, do, done-when, deps) |
| --- | --- | --- |
| `eve-gap-analysis:R01` Clarification queue: one typed channel for agent questions | NOW | `R01.1` Questions table and migration on the board (S); `R01.2` Worker API actions ask-question and answer-question (M); `R01.3` CLI: ./eve ask, ./eve answer, ./eve questions, and the brief (S); `R01.4` MCP tools for questions (S); `R01.5` Board check and next: open questions are visible and age (S); `R01.6` Telegram delivery of questions and /answer replies (M); `R01.7` Answered work re-fires with the answer in its brief (S); `R01.8` Human-resume priority in ./eve next (S); `R01.9` Questions as cards in the admin copilot drawer (M) |
| `eve-gap-analysis:R02` Priority inbox for Elikem: one ranked attention queue | NOW | `R02.1` Attention read model composing every source (M); `R02.2` Severity rules and the thresholds file (S); `R02.3` Route GET /v1/workbench/attention (S); `R02.4` Attention page in the Eve Workspace (M); `R02.5` Daily summary at a set hour, delivered and readable aloud (S); `R02.6` Deterministic change summaries for document revisions (S) |
| `eve-gap-analysis:R03` Eve Steward: delegated authority under a per-family policy | NOW | `R03.1` Steward policy schema and per-family storage (S); `R03.2` Append-only steward decision audit table (S); `R03.3` Steward decision engine (shadow first) (M); `R03.4` Delegated verify-task through the steward (S); `R03.5` Delegated document review for non-governed kinds (S); `R03.6` Autonomy profile per family in context and briefs (S); `R03.7` One thresholds file for Eve (S); `R03.8` Shadow week report before any delegation (S) |
| `eve-gap-analysis:R04` Triage before Elikem: rules, suggestions, duplicates, attempt-a-fix | NOW | `R04.1` Intake adapters create draft work items (M); `R04.2` Ordered triage rules applied at intake (S); `R04.3` Task dense index and duplicate/related suggestions (M); `R04.4` Accept, dismiss and per-property auto-apply (S); `R04.5` Family guidance suppresses suggestions (S); `R04.6` Attempt-a-fix lane for crash groups (M) |
| `eve-gap-analysis:R05` Eve Loops: plain-language recurring automations | NOW | `R05.1` Loop definition contract and validator (S); `R05.2` Postgres loop store with versions and run history (S); `R05.3` Loop runner: ticks, event triggers, dedup, execution (M); `R05.4` Write scope enforced on every loop action (S); `R05.5` Loop routes in the BFF (S); `R05.6` Loops page in the Eve Workspace (M); `R05.7` The five first loops as fixtures with a smoke run (S); `R05.8` Explain a run and continue it as a conversation (S) |
| `eve-gap-analysis:R29` Pre-publish Git integration for agent pushes | NOW | `R29.1` Integration tool skeleton: isolated worktree rebase and conflict report (S); `R29.2` Deterministic resolvers for provable shapes (S); `R29.3` Bounded agent resolver for the rest (M); `R29.4` Gates, base-SHA recheck and the two-line push (S); `R29.5` Wire into ./eve done and the automatic worker; document (S) |
| `eve-gap-analysis:R34` Standing guidance document for Eve and per family | NOW | `R34.1` Document kind guidance in Eve content (S); `R34.2` BFF guidance loader with revision pin and cache (S); `R34.3` Inject guidance as the volatile prompt suffix (S); `R34.4` Family-over-global merge with bounds (S); `R34.5` Seed guidance and measure one case (S) |
| `eve-gap-analysis:R06` Planning chain from an Eve document to board tasks | NEXT | `R06.1` Brownfield feature inventory for one root, with evidence rails (M); `R06.2` Planning goal from a PRD document with section anchors (S); `R06.3` Epic and story decomposition with coverage checks (M); `R06.4` Atomic tasks with scope globs, granularity and overlap checks (M); `R06.5` Elikem approves one plan revision; transaction shape (S); `R06.6` Create a family from a brief (S) |
| `eve-gap-analysis:R07` Change cascade from document revisions | NEXT | `R07.1` Revision events feed the cascade (S); `R07.2` SIGNAL and SETTLE: stale marks and paused leases (S); `R07.3` RECONCILE and DISPATCH through the planner (S); `R07.4` Event-driven docs stale replaces the git-blame sweep (S); `R07.5` Remark versus authorised correction on document reviews (S) |
| `eve-gap-analysis:R08` Typed work product on done, with guided review | NEXT | `R08.1` WorkProduct schema and validator (S); `R08.2` ./eve done --product accepts and stores the product (S); `R08.3` Automatic worker composes the product from git and the run (S); `R08.4` Reviewer reads the decision log first; report carries risk and model (S); `R08.5` Guided review view for Elikem (M) |
| `eve-gap-analysis:R09` Certification committee per family and release | NEXT | `R09.1` Committee registry and runner skeleton (S); `R09.2` Floor members from existing scripts (M); `R09.3` Ceiling members: structural and security sweeps on the test route (M); `R09.4` Intent member: feature audit against the family tracker (M); `R09.5` Findings become board tasks with identity dedupe (S); `R09.6` Completion certificate on family closure (S) |
| `eve-gap-analysis:R10` Family health, progress snapshots and agent-drafted updates | NEXT | `R10.1` Family fields: status, health, target date, milestones (S); `R10.2` Append-only progress snapshots (S); `R10.3` Velocity, ETA and lane timing metrics (S); `R10.4` Agent-drafted weekly family update (S); `R10.5` State of Affairs rollup with export (S); `R10.6` Family health shown in the Workspace and the CLI (S) |
| `eve-gap-analysis:R11` Commit and PR automation for board tasks | NEXT | `R11.1` Board-key convention in commits and branches (S); `R11.2` GitHub push and PR webhook receiver (M); `R11.3` State transitions from git events (S); `R11.4` done refuses a commit absent from the remote (S) |
| `eve-gap-analysis:R12` Board views: list, board, timeline with saved filters | NEXT | `R12.1` Saved views model and routes (S); `R12.2` Natural-language filter to a filter tree (S); `R12.3` List and board layouts over the board API (M); `R12.4` Timeline layout (S); `R12.5` Subscribe to a view (S) |
| `eve-gap-analysis:R25` Operations projection: one durable row per long operation | NEXT | `R25.1` Operations table and reporter (S); `R25.2` Wire lanes, loops, watchers and publications to the reporter (S); `R25.3` Acknowledge, retry, cancel and the watchdog (S); `R25.4` Stream and the "what is Eve doing" tool (S) |
| `eve-gap-analysis:R27` `./eve advance <family>` with a refusal matrix | NEXT | `R27.1` ./eve advance <family> with the refusal matrix (S) |
| `eve-gap-analysis:R28` Pause a family: drain or immediate | NEXT | `R28.1` Durable family pause: drain or immediate (S) |
| `eve-gap-analysis:R30` Working context and completion recovery for Eve turns | NEXT | `R30.1` Working-context recorder across turns (S); `R30.2` Completion recovery: bounded second attempt (S); `R30.3` Approval is a checkpoint, not a stop (S) |
| `eve-gap-analysis:R35` Agent session protocol for every lane run | NEXT | `R35.1` Session and activity schema (S); `R35.2` Lanes emit sessions (S); `R35.3` Sessions in the journal, fleet page and metrics (S) |
| `eve-gap-analysis:R36` Releases as objects across code and content | NEXT | `R36.1` Release object and pipeline (S); `R36.2` Release controller records releases (S); `R36.3` Generated release notes and per-pipeline changelog (S) |
| `eve-gap-analysis:R13` Learned skills from journals with a review inbox | LATER | `R13.1` Mining trace selection from journals and reviews (S); `R13.2` Candidate skill extraction with provenance (M); `R13.3` Review inbox: approve, reject, edit (S); `R13.4` Activation feedback loop (S); `R13.5` Deck measurement gate for an admitted skill (S) |
| `eve-gap-analysis:R14` Per-lane allowances, fallback chains and cost reconciliation | LATER | `R14.1` Invocation ledger per lane and purpose (S); `R14.2` Allowances with hard, soft and warn modes (S); `R14.3` Fallback chains with cooldowns and the CLI failure taxonomy (S); `R14.4` Reviewer never the author engine (S); `R14.5` Task-kind turn budgets (S); `R14.6` Billed-stats reconciliation and weekly report (S); `R14.7` Queue monitor and API-boundary rate limiter (S) |
| `eve-gap-analysis:R15` Governed connectors: Eve as MCP client | LATER | `R15.1` Connector registry with encrypted credentials (S); `R15.2` Eve as MCP client: discovery and per-tool review records (S); `R15.3` Read inline, write as card (S); `R15.4` First connectors: GitHub and Hetzner (M); `R15.5` Integration health events (S) |
| `eve-gap-analysis:R16` Cycles for the fleet | LATER | `R16.1` Cycle model and rollover (S); `R16.2` Capacity dial and scope-change graph (S) |
| `eve-gap-analysis:R17` Work-request intake with deterministic routing | LATER | `R17.1` Channel messages become work requests (S); `R17.2` Deterministic routing: direct task, additive plan, new planning run (S); `R17.3` Request form and synced reply thread (S) |
| `eve-gap-analysis:R18` Preview links, browser self-verification and lane spend caps | LATER | `R18.1` Ephemeral preview per PR on the Dev host (M); `R18.2` Browser self-verification loop for lanes (M); `R18.3` Environments per repository root (S); `R18.4` Scoping versus implementation gate and per-lane caps (S) |
| `eve-gap-analysis:R19` Hosted review IDE on the Linux box | LATER | `R19.1` code-server behind Eve auth on the Linux box (M); `R19.2` Artifact-only evidence workspaces (S) |
| `eve-gap-analysis:R20` Decision council before ADR export | LATER | `R20.1` Council tool with bounded members (S); `R20.2` Council output attached to the ADR export (S) |
| `eve-gap-analysis:R21` Notes, brainstorm intake, research drafts and lineage for content | LATER | `R21.1` Notes kind and readiness hint (S); `R21.2` Research drafts with citations, versions and diff (S); `R21.3` Lineage edges for generated artifacts (S); `R21.4` Span attribution and anchored comments (S); `R21.5` Generate document, deck and spreadsheet files as content verbs (S) |
| `eve-gap-analysis:R22` Full-duplex voice (gate: the voice-depth decision record) | LATER | `R22.1` Re-measure the voice-depth decision (S) |
| `eve-gap-analysis:R23` Member request counts on tasks and families | LATER | `R23.1` Aggregate member request counts per task and family (S) |
| `eve-gap-analysis:R24` Task and document templates; duplicate and related relations with merge | LATER | `R24.1` Task and document templates (S); `R24.2` Duplicate and related relations with merge (S) |
| `eve-gap-analysis:R26` Knowledge-gap queue from assistant feedback | LATER | `R26.1` Typed gap records from feedback and abstentions (S); `R26.2` Gap triage into board tasks (S) |
| `eve-gap-analysis:R31` Prompt cache breakpoints: static prefix, volatile suffix | LATER | `R31.1` Static prefix and volatile suffix with a measured saving (S) |
| `eve-gap-analysis:R32` Product-design method library as Eve skills | LATER | `R32.1` Provenance check and import of the PM references (S); `R32.2` Playbook step machine as an Eve skill (S) |
| `eve-gap-analysis:R33` Save a conversation as a skill | NEXT | `R33.1` Save this conversation as a skill (S); `R33.2` Auto-trigger on matching context (S) |
| `eve-gap-analysis:U01` Eve Home: one arrival page for Elikem | UI | `U01.1` Home read model (S); `U01.2` Home page in the Workspace (M); `U01.3` Next move and morning briefing (S) |
| `eve-gap-analysis:U02` One board in the Eve Workspace | UI | `U02.1` Move work-item lanes into the Workspace board (M); `U02.2` Saved filters and family grouping on the board (S) |
| `eve-gap-analysis:U03` Task detail parity with the CLI | UI | `U03.1` path:line, brief and context in the task detail (S); `U03.2` Lease token, expiry, commit link and formatted journal (S); `U03.3` Related documents and structured evidence (S) |
| `eve-gap-analysis:U04` Family pages | UI | `U04.1` Family page with status, health and counts (S); `U04.2` Blocked-by graph and policy editing on the family page (S) |
| `eve-gap-analysis:U05` Fleet page | UI | `U05.1` Fleet page: leases, switches, last runs, stop (M); `U05.2` Spend, allowances and worker resource self-report (S) |
| `eve-gap-analysis:U06` Eve as one conversation everywhere | UI | `U06.1` Full-page Eve chat with history in the Workspace (M); `U06.2` Select-to-context and in-app help (S); `U06.3` Source chips and tool traces; one name on operator surfaces (S) |
| `eve-gap-analysis:U07` One sign-in, one shell for Eve, Operations and the explorer | UI | `U07.1` Session federation design and decision (S); `U07.2` Implement the chosen option (L) |
| `eve-gap-analysis:U08` One visual language with light and dark themes | UI | `U08.1` Workbench-kit tokens in the Eve Workspace with dark mode (S); `U08.2` Light theme for Operations (S) |
| `eve-gap-analysis:U09` Keyboard-first Workspace with unified search | UI | `U09.1` Command palette and list keys in the Workspace (S); `U09.2` Unified search across tasks, docs, decks and chats (S) |
| `eve-gap-analysis:U10` Eve on the phone | UI | `U10.1` Eve tab in admin mobile: attention and questions (M); `U10.2` Confirmation cards and Telegram approvals (S); `U10.3` Task journal and document review on mobile (S) |
| `eve-gap-analysis:U11` Name the human: copy census across Eve surfaces | UI | `U11.1` Census script for human-in-the-loop terms (S); `U11.2` Replace terms in prompts and tool descriptions, re-stamp the hash (S); `U11.3` Replace terms in UI copy with a browser proof (S); `U11.4` Replace terms in Eve ADRs and docs; add the lock (S) |
| `eve-gap-analysis:G01` The Eve graph: one typed property graph in PostgreSQL | GRAPH | `G01.1` Schema eve_graph.node and eve_graph.edge (S); `G01.2` Compile the product graph into eve_graph (S); `G01.3` Compile the board into eve_graph (S); `G01.4` Compile Eve documents into eve_graph (S); `G01.5` Compile work items, decisions and threads (S); `G01.6` Graph version, validation and the check question (S) |
| `eve-gap-analysis:G02` Grounding by neighbourhood everywhere and a graph retrieval arm | GRAPH | `G02.1` Neighbourhood packs for tasks, documents, families, releases (S); `G02.2` Graph retrieval arm and three-arm fusion (S); `G02.3` Measure on the relevance battery (S) |
| `eve-gap-analysis:G03` Impact and cascade as reachability | GRAPH | `G03.1` Forward closure with an edge whitelist (S); `G03.2` Identity hashes for regenerated nodes (S); `G03.3` Snapshot diff (S) |
| `eve-gap-analysis:G04` Scheduling on the DAG: toposort, critical path, overlap | GRAPH | `G04.1` Topological order under priority in next (S); `G04.2` Critical path and blocked-by chains (S); `G04.3` Scope-glob overlap refusal on concurrent leases (S) |
| `eve-gap-analysis:G05` Proposed edges for triage: duplicates, related, caused-by | GRAPH | `G05.1` Proposed edge kinds and the decision route (S); `G05.2` Link prediction boost from shared neighbours (S) |
| `eve-gap-analysis:G06` Write-scope locality for agents, loops and turns | GRAPH | `G06.1` Bounded reachability over eve_graph (S); `G06.2` Enforce locality before a confirmation card (S); `G06.3` Enforce locality in watcher and loop delivery (S) |
| `eve-gap-analysis:G07` Lineage for evidence: derived-from edges with hashes | GRAPH | `G07.1` derived-from edges with hashes for publications and media (S); `G07.2` Backward closure and the certification walk (S) |
| `eve-gap-analysis:G08` The code graph joined to the product graph | GRAPH | `G08.1` Module and import graph compiler from tsconfig paths (M); `G08.2` Join code to product: anchors and visits (S); `G08.3` Blast radius, orphans and hotspots as queries (S) |
| `eve-gap-analysis:G09` Family health as graph metrics | GRAPH | `G09.1` Frontier, chain and stale metrics (S) |
| `eve-gap-analysis:G10` Decision graph constraints | GRAPH | `G10.1` Typed decision outcomes and citation rule (S); `G10.2` Conflict detection (S) |
| `eve-gap-analysis:G11` Shape rules in `./eve check` | GRAPH | `G11.1` Rule runner with fixtures (S); `G11.2` Rules: ready links, superseded citation, shipped commit (S); `G11.3` Rules: verify provenance and proposed-edge age (S); `G11.4` Wire the rules into ./eve check (S) |
| `eve-gap-analysis:G12` Temporal graph queries | GRAPH | `G12.1` Time-sliced queries (S); `G12.2` Since Elikem last looked (S) |
| `eve-gap-analysis:G13` Graph views for Elikem | GRAPH | `G13.1` Blocked-by chain and blast-radius views (S); `G13.2` Lineage view (S) |
| `eve-gap-analysis:C01` Check: reasoning-stream normaliser for DeepSeek via OpenRouter | CHECKS | atomic as written |
| `eve-gap-analysis:C02` Check: web-fetch tool SSRF allowlist and provider-API blocks | CHECKS | atomic as written |
| `eve-gap-analysis:C03` Check: audit store records sensitive reads, not only actions | CHECKS | atomic as written |
| `eve-gap-analysis:L01` Artifact integrity cron for documents and media | LATER | atomic as written |
| `eve-gap-analysis:L02` Office and PDF extraction into the catalogue | LATER | atomic as written |
| `eve-gap-analysis:L03` Workflow outputs with acknowledgement and signed outbound webhooks | LATER | atomic as written |
