@andorra-labs/code 0.0.0-stage → 0.1.4

package/docs/superpowers/plans/2026-11-01-jev-node-opt-in.md

@@ -0,0 +1,910 @@
+# Jev Node Opt-In Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Make Jev opt-in per Agent node, require a signed-in account for any Jev (hosted or local), add a Jev switch to the desktop composer, and allow `/jev` mid-run with a notice that the change applies after the current run.
+
+**Architecture:** `hostedDecisionPolicy` gains a sign-in gate (via a new pure `resolveDecisionConfig`) and returns `decisionNodeOptIn: true`; the graph runner then gives the run's decision manager only to nodes with `jevEnabled === true`. Bundled presets (the single-node Software Engineer "Default" and the Andorra preset) mark their Agent nodes opted in, so the switch is their control. The desktop composer switch writes the same `config.jevEnabled` that `/jev` writes.
+
+**Tech Stack:** TypeScript (Node 22, `node:test`), plain JS Graph Studio (`src/graph-ui/app.js`), React + Zustand desktop (Vitest).
+
+**Spec:** `docs/superpowers/specs/2026-11-01-jev-node-opt-in-design.md`
+
+**Worktree:** `C:\Users\markx\Documents\GitHub\Andorra-Code-jev-node-opt-in`, branch `feat/jev-node-opt-in`. Run every command from the worktree root unless a step says `desktop/`.
+
+**Running one engine test file:** tests compile into `dist/`, so build first:
+
+```bash
+npm run build && node scripts/run-tests.mjs dist/test/<name>.test.js
+```
+
+Several suites have failures on clean `main` (see the memory notes: `cli.test.js`, `providers.test`, `app-server` suite, `completion-control`, desktop suite). When a suite you did not intend to change fails, compare against `origin/main` in a detached worktree before treating it as a regression.
+
+---
+
+## File map
+
+| File | Change |
+|---|---|
+| `src/decision/hostedPolicy.ts` | New `resolveDecisionConfig`; sign-in gate; return `decisionNodeOptIn: true` instead of `decisionNodeOverrides` |
+| `src/runtime.ts` | Rename `GraphRunOptions.decisionNodeOverrides` → `decisionNodeOptIn` |
+| `src/graph-runner.ts` | Node gets the run's manager only when `node.jevEnabled === true` under opt-in |
+| `src/membership.ts` | `SOFTWARE_ENGINEER_HARNESS.engineer.jevEnabled = true`; `getAndorraHarness()` opts its Agent nodes in |
+| `src/subagent-run.ts` | New exported `subagentDecisionConfig` requiring sign-in; pass `decisionNodeOptIn: true` |
+| `src/graph-ui/app.js` | Checkbox reads `=== true`; untick deletes the key; new help text |
+| `src/commands.ts` | `CommandState.running`; new `/jev` texts; help line |
+| `src/cli.ts` | `/jev` allowed during a run, with `running: true` |
+| `src/terminal-ui.ts` | `/jev` palette description |
+| `src/account-presentation.ts` | Notices describe the new rule |
+| `desktop/src/components/JevToggle.tsx` (new) | Composer switch + pure helpers |
+| `desktop/src/components/NewTaskView.tsx`, `SessionView.tsx` | Render `<JevToggle>` |
+| `desktop/src/components/DecisionSettings.tsx` | "Requires sign-in." note when signed out |
+| Tests | `test/hosted-decision-policy.test.ts`, `test/subagent-run-decisions.test.ts` (new), `test/graph-ui-client-validation.test.ts`, `test/command-screens.test.ts`, `desktop/src/components/JevToggle.test.ts` (new), `desktop/src/components/DecisionSettings.test.ts` |
+| Docs | `docs/reference/config.md`, `docs/getting-started/accounts.md`, `tests/jev-node-opt-in-test-plan.md` (new), `tests/default-active-jev-test-plan.md` |
+
+---
+
+### Task 1: Decision policy requires sign-in and opts nodes in
+
+**Files:**
+- Modify: `src/decision/hostedPolicy.ts` (whole file, 19 lines)
+- Modify: `src/runtime.ts` (`GraphRunOptions`, the `decisionNodeOverrides` field near line 442)
+- Modify: `src/graph-runner.ts` (the `decisionManager` choice near line 598)
+- Test: `test/hosted-decision-policy.test.ts` (rewrite)
+
+- [ ] **Step 1: Rewrite the policy tests**
+
+Replace the whole of `test/hosted-decision-policy.test.ts` with:
+
+```ts
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { hostedDecisionPolicy, resolveDecisionConfig } from '../src/decision/hostedPolicy.js';
+import { DecisionManager } from '../src/decision/DecisionManager.js';
+import { SOFTWARE_ENGINEER_HARNESS } from '../src/membership.js';
+import { MemoryManager } from '../src/memory/MemoryManager.js';
+import { runGraph } from '../src/graph-runner.js';
+import type { Graph, GraphNode } from '../src/graphs.js';
+import { createServer } from 'node:http';
+
+const member = { subject: 'member', paid: false };
+
+async function fixtureMemory() {
+  return MemoryManager.create({ workspace: process.cwd(), repositoryId: 'hosted-policy-fixture',
+    config: { enabled: true, provider: 'graphiti', graphiti: { endpoint: 'http://localhost:8000' }, persistence: { distillOnTaskCompletion: false } },
+    gitRun: async () => '',
+    provider: { initialize: async () => {}, health: async () => ({ status: 'ok' }), search: async () => [],
+      getHistory: async () => [], remember: async () => ({ id: 'unused', persisted: false }), deleteScope: async () => {} },
+  });
+}
+
+function countingManager() {
+  const counter = { calls: 0 };
+  const manager = new DecisionManager({ config: { mode: 'active', provider: 'andorra' }, provider: {
+    evaluate: async (_state, questions) => {
+      counter.calls++;
+      return Object.fromEntries(questions.map(q => [q.id, { type: 'noul' as const, probability: 0.01 }]));
+    },
+  } });
+  return { manager, counter };
+}
+
+const runOptions = async (manager: DecisionManager, decisionNodeOptIn?: boolean) => ({
+  task: 'Reply done without tools', provider: 'mock', model: 'mock', tools: [], memory: await fixtureMemory(),
+  decisionManager: manager, ...(decisionNodeOptIn === undefined ? {} : { decisionNodeOptIn }),
+  adapter: { generate: async () => ({ text: JSON.stringify({ summary: 'Done', tests: [], outcome: 'completed', output: {} }), toolCalls: [] }) },
+  context: { workspace: process.cwd(), signal: new AbortController().signal, yolo: true, approve: async () => false },
+});
+
+test('configured local Laya needs a signed-in account and then uses its endpoint and model', async t => {
+  const requests: { url?: string; body: any }[] = [];
+  const server = createServer(async (req, res) => {
+    let raw = '';
+    for await (const chunk of req) raw += chunk;
+    const body = JSON.parse(raw);
+    requests.push({ url: req.url, body });
+    res.setHeader('Content-Type', 'application/json');
+    res.end(JSON.stringify({ laya: { answers: Object.fromEntries(Object.keys(body.questions).map(id => [id, { type: 'noul', noul: 0.01 }])) } }));
+  });
+  await new Promise<void>(resolve => server.listen(0, '127.0.0.1', resolve));
+  t.after(() => new Promise<void>((resolve, reject) => { server.closeAllConnections(); server.close(error => error ? reject(error) : resolve()); }));
+  const address = server.address();
+  assert.ok(address && typeof address === 'object');
+  const local = { provider: 'laya' as const, mode: 'active' as const, endpoint: `http://127.0.0.1:${address.port}/v1`, model: 'my-local-laya' };
+  assert.equal(hostedDecisionPolicy({ paid: false }, true, local).decisionManager.enabled, false, 'signed out: no local Jev');
+  const policy = hostedDecisionPolicy(member, true, local);
+  assert.equal(policy.decisionManager.active, true);
+  const result = await policy.decisionManager.preflight({
+    task: 'Find code', node: { id: 'engineer' },
+    repository: { codeGraphAvailable: true, memoryAvailable: true },
+    capabilities: { toolFamilies: [], subagentRoles: [] }, run: {},
+  }, { runId: 'local', nodeId: 'engineer', invocationId: '1' }, { codeGraph: true, memory: true }, new AbortController().signal);
+  assert.deepEqual(result, { codeGraph: false, memory: false });
+  assert.equal(requests.length, 1);
+  assert.equal(requests[0].url, '/v1/chat/completions');
+  assert.equal(requests[0].body.model, 'my-local-laya');
+  assert.equal(hostedDecisionPolicy(member, false, local).decisionManager.enabled, false);
+  assert.equal(hostedDecisionPolicy({ subject: 'member', paid: true }, true, { provider: 'none', mode: 'off' }).decisionManager.enabled, false);
+  assert.equal(hostedDecisionPolicy({ subject: 'member', paid: true }, true, { provider: 'andorra', mode: 'off' }).decisionManager.enabled, false);
+  assert.equal(hostedDecisionPolicy({ paid: false }, true, { provider: 'jev', mode: 'shadow', endpoint: local.endpoint }).decisionManager.enabled, false);
+  assert.equal(hostedDecisionPolicy(member, true, { provider: 'jev', mode: 'shadow', endpoint: local.endpoint }).decisionManager.enabled, true);
+});
+
+test('resolveDecisionConfig turns every service off without an account or with the switch off', () => {
+  const off = { provider: 'none', mode: 'off' };
+  assert.deepEqual(resolveDecisionConfig({ paid: false }), off);
+  assert.deepEqual(resolveDecisionConfig({ paid: true }), off, 'a paid flag without a subject is not an account');
+  assert.deepEqual(resolveDecisionConfig(member, false), off);
+  assert.deepEqual(resolveDecisionConfig(member), { provider: 'andorra', mode: 'active', requestTimeoutMs: 15000 });
+});
+
+test('the hosted policy enables free and paid members alike and always asks for node opt-in', () => {
+  for (const paid of [false, true]) {
+    const policy = hostedDecisionPolicy({ subject: 'member', paid });
+    assert.equal(policy.decisionManager.active, true);
+    assert.equal(policy.decisionNodeOptIn, true);
+    assert.equal(hostedDecisionPolicy({ subject: 'member', paid }, false).decisionManager.enabled, false);
+  }
+  const anonymous = hostedDecisionPolicy({ paid: false });
+  assert.equal(anonymous.decisionManager.enabled, false);
+  assert.equal(anonymous.decisionNodeOptIn, true);
+});
+
+for (const optIn of [true, undefined]) for (const enabled of [undefined, true, false]) {
+  test(`node jevEnabled=${enabled} with decisionNodeOptIn=${optIn} controls calls without preventing completion`, async () => {
+    const graph = structuredClone(SOFTWARE_ENGINEER_HARNESS);
+    if (enabled === undefined) delete graph.nodes.engineer.jevEnabled; else graph.nodes.engineer.jevEnabled = enabled;
+    const { manager, counter } = countingManager();
+    const result = await runGraph(graph, await runOptions(manager, optIn));
+    assert.equal(result.status, 'succeeded');
+    // Under opt-in only `true` reaches the run's service; a direct caller that passes no flag keeps
+    // giving every node the manager it supplied.
+    assert.equal(counter.calls, optIn ? (enabled === true ? 1 : 0) : 1);
+  });
+}
+
+test('in a mixed graph only the node that turns Jev on uses the run decision service', async () => {
+  const agent = (id: string, jevEnabled?: boolean): GraphNode => ({ id, name: id, type: 'agent', instruction: `Perform ${id}`, ...(jevEnabled === undefined ? {} : { jevEnabled }) });
+  const graph: Graph = { schemaVersion: 2, id: 'mixed', name: 'Mixed', revision: 1, entry: 'a',
+    nodes: { a: agent('a', true), b: agent('b'), c: agent('c', false), done: { id: 'done', name: 'Done', type: 'end' } },
+    edges: [{ source: 'a', target: 'b' }, { source: 'b', target: 'c' }, { source: 'c', target: 'done' }] } as Graph;
+  const optedIn = countingManager();
+  assert.equal((await runGraph(graph, await runOptions(optedIn.manager, true))).status, 'succeeded');
+  const everyNode = countingManager();
+  assert.equal((await runGraph(graph, await runOptions(everyNode.manager))).status, 'succeeded');
+  assert.ok(optedIn.counter.calls > 0, 'node A used Jev');
+  assert.equal(optedIn.counter.calls * 3, everyNode.counter.calls, 'only one of three nodes used Jev');
+  // Jev off: the policy's manager is disabled, so even node A gets nothing.
+  assert.equal(hostedDecisionPolicy({ subject: 'member', paid: true }, false).decisionManager.enabled, false);
+});
+```
+
+- [ ] **Step 2: Run the tests and confirm they fail**
+
+Run: `npm run build && node scripts/run-tests.mjs dist/test/hosted-decision-policy.test.js`
+Expected: the build fails with a TypeScript error that `resolveDecisionConfig` is not exported and `decisionNodeOptIn` does not exist on `GraphRunOptions`.
+
+- [ ] **Step 3: Rewrite `src/decision/hostedPolicy.ts`**
+
+```ts
+import type { Membership } from '../membership.js';
+import { DecisionManager } from './DecisionManager.js';
+import type { DecisionConfig } from './types.js';
+
+/**
+ * The decision service a run may use. Every service, the hosted one and a local one this
+ * installation configured, needs a signed-in account, and the installation-wide switch stays
+ * authoritative over either.
+ */
+export function resolveDecisionConfig(membership: Membership, enabled = true, decisions?: DecisionConfig): DecisionConfig {
+  if (!enabled || !membership.subject) return { provider: 'none', mode: 'off' };
+  if (decisions && decisions.provider !== 'andorra') return decisions;
+  return { ...decisions, provider: 'andorra', mode: decisions?.mode ?? 'active', requestTimeoutMs: decisions?.requestTimeoutMs ?? 15000 };
+}
+
+/** CLI policy: account entitlement is fetched from the hosted service for each run. */
+export function hostedDecisionPolicy(membership: Membership, enabled = true, decisions?: DecisionConfig) {
+  return {
+    decisionManager: new DecisionManager({ config: resolveDecisionConfig(membership, enabled, decisions) }),
+    // Only Agent nodes that turn Jev on receive the run's decision service.
+    decisionNodeOptIn: true,
+  };
+}
+```
+
+- [ ] **Step 4: Rename the run option in `src/runtime.ts`**
+
+Replace:
+
+```ts
+  /** Set only from current paid membership in the CLI; node JSON cannot grant entitlement. */
+  decisionNodeOverrides?: boolean;
+```
+
+with:
+
+```ts
+  /**
+   * Set by the run policy: an Agent node uses `decisionManager` only when it sets `jevEnabled: true`,
+   * and every other node runs with decisions off. Node JSON cannot grant an account entitlement; the
+   * manager the policy built already reflects sign-in and the installation-wide switch.
+   */
+  decisionNodeOptIn?: boolean;
+```
+
+- [ ] **Step 5: Apply opt-in in `src/graph-runner.ts`**
+
+Replace:
+
+```ts
+      const decisionManager = options.decisionNodeOverrides && node.jevEnabled === false
+        ? new DecisionManager({ config: { mode: 'off', provider: 'none' } }) : options.decisionManager;
+```
+
+with:
+
+```ts
+      const decisionManager = options.decisionNodeOptIn && node.jevEnabled !== true
+        ? new DecisionManager({ config: { mode: 'off', provider: 'none' } }) : options.decisionManager;
+```
+
+- [ ] **Step 6: Confirm no other reference to the old name remains**
+
+Run: `git grep -n decisionNodeOverrides`
+Expected: no output. `src/cli.ts`, `src/app-server.ts` and `src/browser-runner.ts` spread `hostedDecisionPolicy(...)` into the run options, so they pick up `decisionNodeOptIn` with no edit.
+
+- [ ] **Step 7: Run the tests and confirm they pass**
+
+Run: `npm run build && node scripts/run-tests.mjs dist/test/hosted-decision-policy.test.js`
+Expected: all tests pass. (The `SOFTWARE_ENGINEER_HARNESS` matrix deletes/sets `jevEnabled` explicitly, so it does not depend on Task 2.)
+
+- [ ] **Step 8: Run the neighbouring decision suites**
+
+Run: `node scripts/run-tests.mjs dist/test/graph-runner.test.js dist/test/decision-engine.test.js dist/test/decision-active.test.js dist/test/membership.test.js dist/test/continuation-state.test.js`
+Expected: pass. They pass a `decisionManager` without `decisionNodeOptIn`, which keeps the old every-node behaviour.
+
+- [ ] **Step 9: Commit**
+
+```bash
+git add src/decision/hostedPolicy.ts src/runtime.ts src/graph-runner.ts test/hosted-decision-policy.test.ts
+git commit -m "Require sign-in for Jev and give it only to nodes that opt in"
+```
+
+---
+
+### Task 2: Bundled presets opt their Agent nodes in
+
+The bundled Software Engineer graph is what the desktop calls "Default"; it cannot be saved, so its node ships opted in. `SOFTWARE_ENGINEER_HARNESS` has no frozen-revision convention (the app server already serves its current definition for revision 1), so it is edited in place. `DEFAULT_HARNESS` and its frozen revisions are **not** touched: they are the Graph Studio template and resume snapshots, and a duplicate of the template starts unticked like any new node. The Andorra preset is built from `DEFAULT_HARNESS` at call time, so the opt-in is applied in `getAndorraHarness()`.
+
+**Files:**
+- Modify: `src/membership.ts:13-30`
+- Test: `test/hosted-decision-policy.test.ts` (append)
+
+- [ ] **Step 1: Write the failing test**
+
+Append to `test/hosted-decision-policy.test.ts` (and extend its imports: `import { DEFAULT_HARNESS } from '../src/graphs.js';` and add `getAndorraHarness` to the `../src/membership.js` import):
+
+```ts
+test('bundled presets opt their Agent nodes in; the editor template does not', () => {
+  assert.equal(SOFTWARE_ENGINEER_HARNESS.nodes.engineer.jevEnabled, true);
+  const andorra = getAndorraHarness();
+  const agents = Object.values(andorra.nodes).filter(node => node.type === 'agent');
+  assert.ok(agents.length >= 2);
+  for (const node of agents) assert.equal(node.jevEnabled, true, node.id);
+  for (const node of Object.values(DEFAULT_HARNESS.nodes)) assert.equal(node.jevEnabled, undefined, node.id);
+});
+```
+
+- [ ] **Step 2: Run it and confirm it fails**
+
+Run: `npm run build && node scripts/run-tests.mjs dist/test/hosted-decision-policy.test.js`
+Expected: FAIL in the new test: `undefined !== true` for `engineer`.
+
+- [ ] **Step 3: Opt the presets in**
+
+In `src/membership.ts`, change the `engineer` node of `SOFTWARE_ENGINEER_HARNESS` from:
+
+```ts
+      contextPolicy: { history: true },
+      subagents: { enabled: false }, position: { x: 120, y: 120 } },
+```
+
+to:
+
+```ts
+      contextPolicy: { history: true }, jevEnabled: true,
+      subagents: { enabled: false }, position: { x: 120, y: 120 } },
+```
+
+and replace `getAndorraHarness`:
+
+```ts
+export function getAndorraHarness(): Graph {
+  const graph: Graph = { ...structuredClone(DEFAULT_HARNESS), id: 'andorra', name: 'Andorra' };
+  // A preset cannot be saved, so its Agents ship opted in and the Jev switch is their control.
+  for (const node of Object.values(graph.nodes)) if (node.type === 'agent') node.jevEnabled = true;
+  return graph;
+}
+```
+
+- [ ] **Step 4: Run the test and the suites that compare preset structure**
+
+Run: `npm run build && node scripts/run-tests.mjs dist/test/hosted-decision-policy.test.js dist/test/membership.test.js dist/test/graphs.test.js dist/test/subagent-run.test.js`
+Expected: pass. If an `app-server` or `membership` assertion `deepEqual`s a preset against a literal, add `jevEnabled: true` to that literal. Then run `node scripts/run-tests.mjs dist/test/app-server.test.js` and compare any failure with the clean-main baseline (memory: 3 baseline failures).
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/membership.ts test/hosted-decision-policy.test.ts
+git commit -m "Opt the bundled Software Engineer and Andorra presets in to Jev"
+```
+
+---
+
+### Task 3: External subagent runs require sign-in for Jev
+
+`src/subagent-run.ts` builds its decision manager from `config.decisions` with no account check. Keep its existing service selection (it never defaulted to hosted Jev) and add only the sign-in requirement. The membership lookup is skipped whenever decisions would be off anyway, so the common headless run makes no account request.
+
+**Files:**
+- Modify: `src/subagent-run.ts` (imports; the `decisionManager:` line near 746)
+- Test: `test/subagent-run-decisions.test.ts` (new)
+
+- [ ] **Step 1: Write the failing test**
+
+Create `test/subagent-run-decisions.test.ts`:
+
+```ts
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { subagentDecisionConfig } from '../src/subagent-run.js';
+
+const off = { mode: 'off', provider: 'none' };
+const laya = { provider: 'laya' as const, mode: 'active' as const, endpoint: 'http://127.0.0.1:9/v1', model: 'local' };
+
+test('subagent runs keep their configured service but need a signed-in account for it', async () => {
+  let lookups = 0;
+  const signedIn = async () => { lookups++; return { subject: 'member', paid: false }; };
+  const signedOut = async () => { lookups++; return { paid: false }; };
+  assert.deepEqual(await subagentDecisionConfig({ decisions: laya }, signedIn), laya);
+  assert.deepEqual(await subagentDecisionConfig({ decisions: laya }, signedOut), off);
+  assert.equal(lookups, 2);
+  for (const config of [{ jevEnabled: false, decisions: laya }, {}, { decisions: { provider: 'none' as const } }, { decisions: { ...laya, mode: 'off' as const } }]) {
+    assert.deepEqual(await subagentDecisionConfig(config, signedIn), off);
+  }
+  assert.equal(lookups, 2, 'no account request when decisions are off anyway');
+});
+```
+
+- [ ] **Step 2: Run it and confirm it fails**
+
+Run: `npm run build && node scripts/run-tests.mjs dist/test/subagent-run-decisions.test.js`
+Expected: the build fails with "has no exported member 'subagentDecisionConfig'".
+
+- [ ] **Step 3: Implement**
+
+In `src/subagent-run.ts`, extend the existing `./membership.js` import with `type Membership` (`getMembership` is already imported there), and add these imports unless the file already has them (check with `grep -n "from './config.js'\|from './decision/types.js'" src/subagent-run.ts` and merge into an existing import line instead of duplicating it):
+
+```ts
+import type { DecisionConfig } from './decision/types.js';
+import type { Config } from './config.js';
+```
+
+Add this exported function above the `SubagentRunner` class:
+
+```ts
+/**
+ * The decision service an external subagent run uses: the one this installation configured, never a
+ * hosted default, and only for a signed-in account. The account is asked only when the answer could
+ * matter, so a run with decisions off stays free of an account request.
+ */
+export async function subagentDecisionConfig(config: Pick<Config, 'jevEnabled' | 'decisions'>, membership: () => Promise<Membership>): Promise<DecisionConfig> {
+  const decisions = config.decisions;
+  if (config.jevEnabled === false || !decisions || decisions.provider === 'none' || decisions.mode === 'off') return { mode: 'off', provider: 'none' };
+  return (await membership()).subject ? decisions : { mode: 'off', provider: 'none' };
+}
+```
+
+Replace the run-options line:
+
+```ts
+        decisionManager: new DecisionManager({ config: config.jevEnabled === false ? { mode: 'off', provider: 'none' } : config.decisions, onEvent: event => this.observe(run, event) }),
+```
+
+with:
+
+```ts
+        decisionManager: new DecisionManager({ config: await subagentDecisionConfig(config, () => (options.membership ?? getMembership)(signal)), onEvent: event => this.observe(run, event) }),
+        decisionNodeOptIn: true,
+```
+
+(`options` and `signal` are in scope here: the same method uses `options.adapterFactory` and `signal` a few lines above. The subagent graph is `SOFTWARE_ENGINEER_HARNESS`, now opted in by Task 2.)
+
+- [ ] **Step 4: Run the tests and confirm they pass**
+
+Run: `npm run build && node scripts/run-tests.mjs dist/test/subagent-run-decisions.test.js dist/test/subagent-run.test.js dist/test/cli-subagent.test.js dist/test/agent-mcp-subagent.test.js`
+Expected: pass. The existing subagent tests save `jevEnabled: false`, so they make no account request.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/subagent-run.ts test/subagent-run-decisions.test.ts
+git commit -m "Require a signed-in account for Jev in external subagent runs"
+```
+
+---
+
+### Task 4: Graph Studio checkbox defaults off
+
+**Files:**
+- Modify: `src/graph-ui/app.js` (the `'Jev decisions'` `check(...)` line in the Agent inspector, near line 1234)
+- Test: `test/graph-ui-client-validation.test.ts` (the test `agent inspector Jev checkbox defaults on and persists explicit off/on changes`, near line 395)
+
+- [ ] **Step 1: Update the test**
+
+Replace that test with:
+
+```ts
+test('agent inspector Jev checkbox defaults off; ticking stores true and unticking removes the setting', async () => {
+  const f = await validationFixture();
+  runInContext('state.selected = "engineer"; renderInspector();', f.context);
+  const descendants = (e: Element): Element[] => [e, ...e.children.flatMap(descendants)];
+  const checkbox = () => descendants(f.getElement('inspector-body')).find(e => e.children.some(child => child.textContent === 'Jev decisions'))!.children.find(child => child.type === 'checkbox')! as Element & { checked: boolean; onchange(): void };
+  delete f.context.graph.nodes.engineer.jevEnabled;
+  runInContext('renderInspector()', f.context);
+  assert.equal(checkbox().checked, false);
+  const on = checkbox(); on.checked = true; on.onchange();
+  assert.equal(f.context.graph.nodes.engineer.jevEnabled, true);
+  runInContext('renderInspector()', f.context);
+  assert.equal(checkbox().checked, true);
+  const off = checkbox(); off.checked = false; off.onchange();
+  assert.equal(Object.hasOwn(f.context.graph.nodes.engineer, 'jevEnabled'), false);
+  f.context.graph.nodes.engineer.jevEnabled = false;
+  runInContext('renderInspector()', f.context);
+  assert.equal(checkbox().checked, false, 'an older explicit opt-out reads as unticked');
+  runInContext('state.selected = "done"; renderInspector();', f.context);
+  assert.ok(!descendants(f.getElement('inspector-body')).some(e => e.textContent === 'Jev decisions'));
+});
+```
+
+- [ ] **Step 2: Run it and confirm it fails**
+
+Run: `npm run build && node scripts/run-tests.mjs dist/test/graph-ui-client-validation.test.js`
+Expected: FAIL: `true !== false` on the first `checkbox().checked` assertion.
+
+- [ ] **Step 3: Change the checkbox**
+
+In `src/graph-ui/app.js`, replace:
+
+```js
+      explain(check(general, 'Jev decisions', node.jevEnabled !== false, value => { node.jevEnabled = value; }), 'Use Jev to assist this agent with routing decisions. Enabled by default. The coding model still implements the task; account access, quota and runtime permissions apply.');
+```
+
+with:
+
+```js
+      explain(check(general, 'Jev decisions', node.jevEnabled === true, value => { if (value) node.jevEnabled = true; else delete node.jevEnabled; }), 'Off unless ticked. When Jev is on, it assists this agent with routing decisions. The coding model still implements the task; sign-in, quota and runtime permissions apply.');
+```
+
+- [ ] **Step 4: Run the test and confirm it passes**
+
+Run: `npm run build && node scripts/run-tests.mjs dist/test/graph-ui-client-validation.test.js`
+Expected: pass, including `editor blocks malformed or control-node Jev settings before save`, which is unchanged.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/graph-ui/app.js test/graph-ui-client-validation.test.ts
+git commit -m "Make the Graph Studio Jev checkbox opt-in"
+```
+
+---
+
+### Task 5: `/jev` describes the rule and works during a run
+
+**Files:**
+- Modify: `src/commands.ts` (`CommandState` near line 64; help line 44; `case '/jev'` near line 478)
+- Modify: `src/cli.ts` (the in-run command allowlist in `setRunInputHandler`, near line 1180)
+- Modify: `src/terminal-ui.ts:173` (palette description)
+- Modify: `src/account-presentation.ts:12` and `:92`
+- Test: `test/command-screens.test.ts` (test `Jev on/off persists for all users…`, near line 457)
+
+- [ ] **Step 1: Update the command test**
+
+In `test/command-screens.test.ts`, in that test, replace:
+
+```ts
+  assert.match((await run('/jev status')).text, /enabled.*saved preference/);
+```
+
+with:
+
+```ts
+  assert.match((await run('/jev status')).text, /enabled.*saved preference.*Agent nodes with Jev turned on.*Requires sign-in/);
+```
+
+replace:
+
+```ts
+  assert.match((await run('/jev on')).text, /require sign-in and available quota/);
+```
+
+with:
+
+```ts
+  assert.match((await run('/jev on')).text, /Agent nodes with Jev turned on and requires sign-in and available quota/);
+```
+
+and insert directly before `assert.equal(isScreenCommand('/jev'), false);`:
+
+```ts
+  const during = (line: string) => actualExecuteCommand(line, { ...f.state, running: true }, f.persist, undefined, forbiddenGraphAccess);
+  const turnedOff = await during('/jev off');
+  assert.equal(f.state.config.jevEnabled, false, 'a mid-run toggle saves at once');
+  assert.match(turnedOff.text, /^Jev disabled\. Setting saved for this machine\. The current run keeps its setting; the change applies after it ends or you interrupt it\.$/);
+  assert.match((await during('/jev status')).text, /disabled.*saved preference/);
+```
+
+- [ ] **Step 2: Run it and confirm it fails**
+
+Run: `npm run build && node scripts/run-tests.mjs dist/test/command-screens.test.js`
+Expected: the build fails because `running` is not a `CommandState` property.
+
+- [ ] **Step 3: Implement `/jev`**
+
+In `src/commands.ts`, add to `CommandState` after `notify?: (message: string) => void;`:
+
+```ts
+  /** A run is in flight: settings saved now apply to the next run, and the reply says so. */
+  running?: boolean;
+```
+
+Replace the help line:
+
+```
+  /jev <on|off|status>    Turn Jev on or off, or show its saved setting (all plans)
+```
+
+with:
+
+```
+  /jev <on|off|status>    Turn Jev on or off for nodes that enable it, or show its setting
+```
+
+Replace the `case '/jev'` block with:
+
+```ts
+    case '/jev': {
+      if (args.length > 1 || (arg && !['on', 'off', 'status'].includes(arg))) return { text: 'Usage: /jev on|off|status' };
+      const jevStatus = `Jev: ${state.config.jevEnabled === false ? 'disabled' : 'enabled'} (saved preference). Applies to Agent nodes with Jev turned on. Requires sign-in and available quota.`;
+      if (arg === 'status') return { text: jevStatus };
+      if (!arg) return { text: `${jevStatus}\nUsage: /jev on|off|status` };
+      state.config.jevEnabled = arg === 'on';
+      const saved = `Jev ${state.config.jevEnabled ? 'enabled' : 'disabled'}. Setting saved for this machine.`;
+      if (state.running) return { text: `${saved} The current run keeps its setting; the change applies after it ends or you interrupt it.`, save: true };
+      return { text: `${saved}${state.config.jevEnabled ? ' It applies to Agent nodes with Jev turned on and requires sign-in and available quota.' : ''}`, save: true };
+    }
+```
+
+- [ ] **Step 4: Run the command test and confirm it passes**
+
+Run: `npm run build && node scripts/run-tests.mjs dist/test/command-screens.test.js`
+Expected: pass.
+
+- [ ] **Step 5: Allow `/jev` during a CLI run**
+
+In `src/cli.ts`, in `terminal?.setRunInputHandler(...)`, replace:
+
+```ts
+      if (!['/browser', '/yolo', '/permissions', '/help', '/status', '/usage', '/tools'].includes(command)) {
+        void debugRecord('command.steer', { input: text });
+        print(`${command} is unavailable during a run. Use /permissions <mode>, /yolo on|off, /status, /usage, /help, or /exit.`); return true;
+      }
+```
+
+with:
+
+```ts
+      if (!['/browser', '/yolo', '/permissions', '/jev', '/help', '/status', '/usage', '/tools'].includes(command)) {
+        void debugRecord('command.steer', { input: text });
+        print(`${command} is unavailable during a run. Use /permissions <mode>, /yolo on|off, /jev on|off, /status, /usage, /help, or /exit.`); return true;
+      }
+```
+
+and replace:
+
+```ts
+          const commandState = command === '/usage' ? { ...state, usage: sessionUsage() } : state;
+```
+
+with:
+
+```ts
+          // `/jev` saves at once but the run keeps the decision policy it started with; the reply says so.
+          // The spread shares `state.config`, so the saved value lands on the session's configuration.
+          const commandState = command === '/usage' ? { ...state, usage: sessionUsage() } : command === '/jev' ? { ...state, running: true } : state;
+```
+
+`refreshStatus()` (already called after the command) re-reads `config.jevEnabled`, so the footer shows the saved value immediately.
+
+- [ ] **Step 6: Update the palette and account notices**
+
+`src/terminal-ui.ts:173`: change `'/jev': 'Turn Jev on or off (all plans)'` to `'/jev': 'Turn Jev on or off for nodes that enable it'`.
+
+`src/account-presentation.ts:12`: change `'Sign in with /login or create an account to access hosted Jev. Local …'` to start `'Sign in with /login or create an account to use Jev. Local …'` (rest unchanged).
+
+`src/account-presentation.ts:92`: change `Jev decisions default to enabled when signed in; use /jev to toggle.` to `Jev runs on Agent nodes that turn it on; use /jev to toggle.`
+
+- [ ] **Step 7: Run the affected suites**
+
+Run: `npm run build && node scripts/run-tests.mjs dist/test/command-screens.test.js dist/test/terminal-ui.test.js dist/test/cli-live-control.test.js dist/test/account-presentation.test.js`
+Expected: pass (skip any file that does not exist). If `terminal-ui.test.js` or an account test asserts the old strings, update the asserted text to the new strings above.
+
+- [ ] **Step 8: Commit**
+
+```bash
+git add src/commands.ts src/cli.ts src/terminal-ui.ts src/account-presentation.ts test/command-screens.test.ts
+git commit -m "Describe opt-in Jev in /jev and allow it during a run"
+```
+
+---
+
+### Task 6: Desktop composer Jev switch
+
+**Files:**
+- Create: `desktop/src/components/JevToggle.tsx`
+- Create: `desktop/src/components/JevToggle.test.ts`
+- Modify: `desktop/src/components/NewTaskView.tsx` (before the `{/* Start is the send arrow …` comment near line 891)
+- Modify: `desktop/src/components/SessionView.tsx` (before the `{/* One tail control, two affordances …` comment near line 1149)
+- Modify: `desktop/src/components/DecisionSettings.tsx`, `desktop/src/components/DecisionSettings.test.ts`
+
+- [ ] **Step 1: Write the failing tests**
+
+Create `desktop/src/components/JevToggle.test.ts`:
+
+```ts
+import { describe, expect, it } from 'vitest';
+import { jevSavedNotice, jevToggleView } from './JevToggle';
+
+describe('composer Jev switch', () => {
+  it('reads the installation-wide setting, defaulting to on', () => {
+    expect(jevToggleView({}, true)).toMatchObject({ on: true, disabled: false });
+    expect(jevToggleView({ jevEnabled: false }, true)).toMatchObject({ on: false, disabled: false });
+    expect(jevToggleView({ jevEnabled: true }, true).title).toContain('Agent nodes that turn it on');
+  });
+  it('is disabled while signed out or before the configuration loads', () => {
+    expect(jevToggleView({ jevEnabled: true }, false)).toEqual({ on: true, disabled: true, title: 'Sign in to use Jev.' });
+    expect(jevToggleView(undefined, true).disabled).toBe(true);
+  });
+  it('says a change made during a run applies afterwards, and says nothing when idle', () => {
+    expect(jevSavedNotice(false, true)).toBe('Jev off saved. The current run keeps its setting; the change applies after it ends or you interrupt it.');
+    expect(jevSavedNotice(true, false)).toBeUndefined();
+  });
+});
+```
+
+In `desktop/src/components/DecisionSettings.test.ts`, add `DecisionSettings` to the `./DecisionSettings` import and append inside the `describe`:
+
+```ts
+  it('notes that decisions need sign-in when no account is signed in', () => {
+    // The default store has no account, which is the signed-out state.
+    expect(renderToStaticMarkup(createElement(DecisionSettings))).toContain('Requires sign-in.');
+  });
+```
+
+- [ ] **Step 2: Run them and confirm they fail**
+
+Run (from `desktop/`): `npx vitest run src/components/JevToggle.test.ts src/components/DecisionSettings.test.ts`
+Expected: FAIL, `Failed to resolve import "./JevToggle"`, and the DecisionSettings case missing `Requires sign-in.`.
+
+- [ ] **Step 3: Create `desktop/src/components/JevToggle.tsx`**
+
+```tsx
+import { useState } from 'react';
+import { describeError, saveConfig } from '../engine/bridge';
+import { useAppStore, useDataStore } from '../engine/store';
+import type { ConfigView } from '../engine/protocol';
+
+/**
+ * The composer's Jev switch is the installation-wide setting `/jev` and Settings also change, so the
+ * CLI, Settings and every composer agree. It lets Jev run on Agent nodes that turn it on; off, no
+ * node uses it. Jev needs a signed-in account, so the switch is inert while signed out.
+ */
+export function jevToggleView(config: Pick<ConfigView, 'jevEnabled'> | undefined, signedIn: boolean): { on: boolean; disabled: boolean; title: string } {
+  const on = config?.jevEnabled !== false;
+  if (!signedIn) return { on, disabled: true, title: 'Sign in to use Jev.' };
+  return {
+    on, disabled: config === undefined,
+    title: on ? 'Jev is on for Agent nodes that turn it on. Click to turn it off.' : 'Jev is off for every node. Click to turn it on.',
+  };
+}
+
+/** A run keeps the decision policy it started with, so a change made during one is announced. */
+export function jevSavedNotice(on: boolean, running: boolean): string | undefined {
+  return running ? `Jev ${on ? 'on' : 'off'} saved. The current run keeps its setting; the change applies after it ends or you interrupt it.` : undefined;
+}
+
+export function JevToggle({ running }: { running: boolean }) {
+  const config = useDataStore(state => state.config);
+  const signedIn = useDataStore(state => state.account?.signedIn === true);
+  const supported = useAppStore(state => state.host?.capabilities?.includes('config.decisions') === true);
+  const notify = useAppStore(state => state.notify);
+  const [busy, setBusy] = useState(false);
+  if (!supported) return null;
+  const view = jevToggleView(config, signedIn);
+  async function toggle(): Promise<void> {
+    if (!config) return;
+    const next = !view.on;
+    setBusy(true);
+    try {
+      // A save that fails leaves the store, and so the switch, on the value it had.
+      await saveConfig({ jevEnabled: next }, { jevEnabled: config.jevEnabled ?? null });
+      const notice = jevSavedNotice(next, running);
+      if (notice) notify('info', notice);
+    } catch (error) {
+      notify('error', describeError(error));
+    } finally {
+      setBusy(false);
+    }
+  }
+  return (
+    <button
+      type="button"
+      className="composer-pill"
+      aria-pressed={view.on}
+      aria-label="Jev decisions"
+      title={view.title}
+      disabled={view.disabled || busy}
+      onClick={() => void toggle()}
+    >
+      {view.on ? 'Jev: On' : 'Jev: Off'}
+    </button>
+  );
+}
+```
+
+- [ ] **Step 4: Add the sign-in note to `DecisionSettings`**
+
+In `desktop/src/components/DecisionSettings.tsx`, inside `DecisionSettings()`, after `const source = decisionSource(config);` add:
+
+```tsx
+  const signedIn = useDataStore(state => state.account?.signedIn === true);
+```
+
+and after the `{!supported && …}` line add:
+
+```tsx
+      {!signedIn && source !== 'off' && <span className="setting-row-note">Requires sign-in.</span>}
+```
+
+- [ ] **Step 5: Run the tests and confirm they pass**
+
+Run (from `desktop/`): `npx vitest run src/components/JevToggle.test.ts src/components/DecisionSettings.test.ts`
+Expected: pass.
+
+- [ ] **Step 6: Render the switch in both composers**
+
+`desktop/src/components/NewTaskView.tsx`: add `import { JevToggle } from './JevToggle';` with the other component imports, and insert immediately before the `{/* Start is the send arrow the session composer carries, …` comment:
+
+```tsx
+            <JevToggle running={false} />
+```
+
+`desktop/src/components/SessionView.tsx`: add the same import, and insert immediately before the `{/* One tail control, two affordances. …` comment:
+
+```tsx
+              <JevToggle running={running} />
+```
+
+(`running` is the existing selector `useSessionStore(state => state.session !== undefined && state.runs[state.session.id] !== undefined)` declared near line 447.)
+
+- [ ] **Step 7: Typecheck and run the desktop suite**
+
+Run: `npm run check --prefix desktop`
+Expected: no type errors.
+
+Run (from `desktop/`): `npx vitest run`
+Expected: pass except the three cases that fail on clean `main` (memory: desktop suite baseline failures). Compare against `origin/main` before calling anything a regression.
+
+- [ ] **Step 8: Commit**
+
+```bash
+git add desktop/src/components/JevToggle.tsx desktop/src/components/JevToggle.test.ts desktop/src/components/NewTaskView.tsx desktop/src/components/SessionView.tsx desktop/src/components/DecisionSettings.tsx desktop/src/components/DecisionSettings.test.ts
+git commit -m "Add a Jev switch to the desktop composer"
+```
+
+---
+
+### Task 7: Documentation and QA plan
+
+**Files:**
+- Modify: `docs/reference/config.md:57`
+- Modify: `docs/getting-started/accounts.md:49-57`
+- Modify: `tests/default-active-jev-test-plan.md`
+- Create: `tests/jev-node-opt-in-test-plan.md`
+
+- [ ] **Step 1: Config reference**
+
+`docs/reference/config.md:57` becomes:
+
+```md
+- `jevEnabled` — installation-wide Jev switch; omission means on. When on, Jev runs only on Agent nodes that set `jevEnabled: true` (the bundled presets do) and only for a signed-in account; when off, no node uses it. `/jev` and the desktop composer switch change it. See [Accounts](../getting-started/accounts.md).
+```
+
+- [ ] **Step 2: Accounts guide**
+
+In `docs/getting-started/accounts.md`, rewrite the paragraphs at lines 49–57 so they state:
+
+1. Jev requires a signed-in account, free or paid; signed out, no decision service runs, hosted or a configured local Laya/Jev.
+2. `/jev on|off|status` and the desktop composer's **Jev** switch change one installation-wide setting. Changing it during a run saves it immediately; the running task keeps its setting until it ends or is interrupted.
+3. Jev runs only on Agent nodes that turn it on: in the graph builder select an Agent and tick **Jev decisions** (stores `jevEnabled: true`). Unticked and older nodes do not use Jev. The bundled Software Engineer ("Default") and Andorra presets ship with their Agents opted in. Free and paid accounts both get node control.
+4. Graphs saved before this change have no node setting and so do not use Jev until their Agents are ticked.
+
+Keep the existing text about decision providers, shadow mode and the managed endpoint (lines 53, 59) unchanged except where it says local services work "without hosted sign-in", which now must say they need a signed-in account.
+
+- [ ] **Step 3: Update the older QA plan**
+
+In `tests/default-active-jev-test-plan.md`, edit the cases that assert the old rule, so they match the new one:
+- Line 14 (checkbox default): a new node or an older node without `jevEnabled` shows the checkbox **cleared**.
+- AJ-11: signed out, `/jev on` saves the preference, but no run makes any decision request, including with a local Laya/Jev service configured.
+- AJ-12: with no node setting, a custom graph's nodes do not use Jev; the bundled presets do.
+Add a line at the top: `Superseded in part by [jev-node-opt-in-test-plan.md](jev-node-opt-in-test-plan.md).`
+
+- [ ] **Step 4: Write `tests/jev-node-opt-in-test-plan.md`**
+
+Follow the AGENTS.md sections exactly: **Scope and prerequisites** (build `npm run build`; CLI `node dist/src/cli.js --cwd <test-repo>`; desktop dev app; a free and a paid test account as placeholders; throwaway `ANDORRACODE_HOME` per AGENTS.md); **How to use the feature**; **Test cases** with IDs and concrete expected results, at least:
+
+- JN-01 Mixed custom graph, paid, Jev on: A ticked, B and C not. Only A's invocation produces a `[Jev]` transcript entry / decision request; B and C run with automatic memory retrieval instead.
+- JN-02 Same graph, `/jev off`: no node produces a decision request.
+- JN-03 Same as JN-01 on a free account (3-node graph): same result as paid.
+- JN-04 Signed out, hosted default: no decision request; desktop switch disabled with title "Sign in to use Jev."; Settings row shows "Requires sign-in.".
+- JN-05 Signed out with local Laya configured: no request reaches the local endpoint.
+- JN-06 Default (Software Engineer) preset, signed in, switch on: the engineer node uses Jev; switch off: it does not.
+- JN-07 Andorra preset (paid): orchestrator and engineer use Jev.
+- JN-08 CLI mid-run `/jev off`: reply is exactly `Jev disabled. Setting saved for this machine. The current run keeps its setting; the change applies after it ends or you interrupt it.`; the running task keeps making decisions; the footer shows disabled; the next task makes none.
+- JN-09 Desktop mid-run toggle: the info toast shows the same sentence (with `Jev off saved.`); idle toggles show no toast; `/jev status` in the CLI agrees with the switch.
+- JN-10 Graph Studio: ticking stores `jevEnabled: true`; unticking removes the key (inspect the saved revision JSON under `<home>/graphs/<id>/`); an imported node with `jevEnabled: false` shows unticked.
+- JN-11 Graph saved before the change: its nodes do not use Jev until ticked.
+- JN-12 Save failure on the desktop switch (e.g. engine stopped): error toast; the switch keeps its previous value.
+
+**Edge cases and potential bugs** (concurrent toggle from CLI and desktop resolving through `config.set` `expects`; membership service unreachable → no subject → Jev off for that run; suspected, not yet reproduced: a resume pinned to an older `default` revision loads a frozen snapshot with no node setting and so runs without Jev — confirm which loader a resume uses and record the result). **Gaps and limitations** (telemetry `jevEnabled` still reports the switch, not per-node use). **Validation evidence**: filled in during Task 8 with the commands actually run.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add docs/reference/config.md docs/getting-started/accounts.md tests/default-active-jev-test-plan.md tests/jev-node-opt-in-test-plan.md
+git commit -m "Document opt-in Jev, the composer switch and the sign-in requirement"
+```
+
+---
+
+### Task 8: Verify by running it, then open the PR
+
+Per the saved preference, run targeted suites rather than `ci:local`.
+
+- [ ] **Step 1: Full typecheck and build**
+
+Run: `npm run check && npm run build`
+Expected: both succeed.
+
+- [ ] **Step 2: Targeted suites**
+
+Run: `node scripts/run-tests.mjs dist/test/hosted-decision-policy.test.js dist/test/subagent-run-decisions.test.js dist/test/graph-ui-client-validation.test.js dist/test/command-screens.test.js dist/test/graph-runner.test.js dist/test/subagent-run.test.js dist/test/membership.test.js dist/test/graphs.test.js`
+Expected: pass. Record the summary line for the PR.
+
+- [ ] **Step 3: CLI run verification (signed out, throwaway home)**
+
+Drive the CLI through node-pty as in the memory note "Verify the TUI via node-pty", with `home=$(mktemp -d) || exit 1; export ANDORRACODE_HOME="$home"` and `rm -rf "$ANDORRACODE_HOME"` on exit. Type `/jev status` per character and confirm the output contains `Applies to Agent nodes with Jev turned on. Requires sign-in`. Start a task, and while it runs type `/jev off`; confirm the exact mid-run sentence from JN-08 and that the footer flips to disabled. Kill the PTY and confirm no `node` process from the run survives.
+
+- [ ] **Step 4: Desktop verification**
+
+Start the dev desktop app and drive it over CDP (memory: "Drive the dev desktop app via CDP"). Confirm the composer shows `Jev: On`/`Jev: Off`, signed out it is disabled with title `Sign in to use Jev.`, and Settings shows `Requires sign-in.`. Record what was observed; a signed-in check needs a test account and is listed as pending if none is available.
+
+- [ ] **Step 5: Fill in the QA plan's Validation evidence, commit, push, open the PR**
+
+```bash
+git add tests/jev-node-opt-in-test-plan.md
+git commit -m "Record validation evidence for opt-in Jev"
+git push -u origin feat/jev-node-opt-in
+```
+
+Open a ready-for-review PR to `main` using `.github/PULL_REQUEST_TEMPLATE.md`. The description states the behavior changes (saved graphs lose Jev until ticked; signed-out local services stop), links the spec, plan and `tests/jev-node-opt-in-test-plan.md`, and lists in Validation exactly what ran and what was skipped. Then run the Codex review loop from AGENTS.md.