carthagent 1.0.7 → 1.1.0-preview.13

package/tests/native-daily-editor-focus.test.mjs

@@ -0,0 +1,213 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { EventEmitter } from 'node:events';
+import { readFile } from 'node:fs/promises';
+import { createRoot, createSignal, createEffect, onCleanup } from 'solid-js/dist/solid.js';
+import { createDailyEditorFocus } from '../plugins/carthagent/src/ui/daily-editor-focus.mjs';
+import { createDailyQuestsState } from '../plugins/carthagent/src/ui/daily-quests-state.mjs';
+
+// Focus-only adapter, not a native renderer test: retain the pinned ordering
+// (blur previous, install handlers, emit focused) and route keys to the owner.
+function fixture(t, { microtasks = [], defer = callback => microtasks.push(callback) } = {}) {
+  let current;
+  class Input extends EventEmitter {
+    focused = false;
+    isDestroyed = false;
+    focusCalls = 0;
+    text = '';
+    focus() {
+      if (this.isDestroyed || this.focused) return;
+      current?.blur();
+      current = this;
+      this.focused = true;
+      this.focusCalls++;
+      this.emit('focused');
+    }
+    blur() { this.focused = false; if (current === this) current = undefined; }
+    destroy() { this.blur(); this.isDestroyed = true; }
+  }
+  const actions = new Input();
+  let input = new Input();
+  let state, update, focus, dispose;
+  createRoot(stop => {
+    dispose = stop;
+    [state, update] = createSignal({ phase: 'overview', hasDraft: false, busy: false, editorFocus: true, mode: 'base' });
+    focus = createDailyEditorFocus({ state, editor: () => input, defer });
+    focus.attachActions(actions);
+    createEffect(focus.reconcile);
+    onCleanup(focus.dispose);
+  });
+  t.after(dispose);
+  const flush = () => {
+    let count = 0;
+    while (microtasks.length) {
+      assert.ok(++count < 30, 'focus reconciliation must settle, not poll');
+      microtasks.shift()();
+    }
+  };
+  return {
+    actions, focus, dispose, flush, microtasks,
+    input: () => input,
+    mountEditor: () => { input = new Input(); return input; },
+    newInput: () => new Input(),
+    current: () => current,
+    patch: next => update(previous => ({ ...previous, ...next })),
+    key(text) { if (current === input) input.text += text; },
+    enterAction(run) { if (current === actions && focus.actionsEnabled()) run(); },
+  };
+}
+
+test('compose promise mounts editor before native 1ms refocus; focus event repairs ownership without Tab', async t => {
+  const f = fixture(t);
+  f.flush();
+  assert.equal(f.current(), f.actions);
+  const id = '11111111-1111-4111-8111-111111111111';
+  const detail = { id, status: 'open' };
+  const controller = createDailyQuestsState({
+    api: {
+      snapshot: async () => ({ accountKey: 'a'.repeat(64), slate: { items: [detail] }, records: [] }),
+      detail: async () => detail,
+      submit: () => assert.fail('focus must not send evidence'),
+    },
+    changed: view => f.patch({ phase: view.phase, hasDraft: !!view.draft, busy: view.busy }),
+  });
+  t.after(() => controller.dispose());
+  await controller.refresh(); await controller.select(id);
+  let resolve;
+  const selected = new Promise(done => { resolve = done; });
+  const savedFocus = f.actions;
+  const compose = controller.compose(() => selected);
+  f.patch({ mode: 'modal' });
+  f.flush();
+  resolve({ id, evidence: { goal: 'manual fixture' } });
+  f.patch({ mode: 'base' });
+  // clear() schedules the old renderable's focus after promise continuations.
+  const nativeTimer = () => savedFocus.focus();
+  await compose;
+  f.flush();
+  assert.equal(f.current(), f.input());
+  nativeTimer();
+  assert.equal(f.current(), f.actions, 'reproduce stale actual focus despite editor ownership');
+  let navigations = 0;
+  f.enterAction(() => navigations++);
+  assert.equal(navigations, 0, 'stale Enter cannot activate Back/refresh/submit');
+  f.flush();
+  f.key('Z\n');
+  assert.equal(f.input().text, 'Z\n');
+  assert.equal(f.current(), f.input());
+  assert.equal(f.actions.focused, false);
+  assert.equal(f.actions.listenerCount('focused'), 1);
+});
+
+test('default microtask runs after focus installation and rechecks latest ownership', async t => {
+  const f = fixture(t, { defer: queueMicrotask });
+  await Promise.resolve();
+  f.patch({ phase: 'edit', hasDraft: true });
+  await Promise.resolve();
+  f.actions.focus();
+  await Promise.resolve();
+  assert.equal(f.current(), f.input());
+  f.actions.focus();
+  f.patch({ mode: 'modal' });
+  await Promise.resolve();
+  assert.equal(f.current(), undefined, 'never reclaim focus from a modal');
+});
+
+test('Tab hands ownership to visible actions and back; stale event cannot reverse it', t => {
+  const f = fixture(t);
+  f.patch({ phase: 'edit', hasDraft: true }); f.flush();
+  f.actions.focus(); // reconciliation queued for editor
+  f.patch({ editorFocus: false }); f.flush();
+  assert.equal(f.current(), f.actions);
+  let selections = 0;
+  f.enterAction(() => selections++);
+  assert.equal(selections, 1);
+  f.patch({ editorFocus: true }); f.flush();
+  assert.equal(f.current(), f.input());
+  f.key('after Tab');
+  assert.equal(f.input().text, 'after Tab');
+});
+
+for (const blocked of [{ mode: 'modal' }, { mode: 'palette' }, { busy: true }]) {
+  test(`pending repair respects ${JSON.stringify(blocked)} and restores only after unblock`, t => {
+    const f = fixture(t);
+    f.patch({ phase: 'edit', hasDraft: true }); f.flush();
+    f.actions.focus();
+    f.patch(blocked);
+    const modal = f.newInput();
+    modal.focus();
+    f.flush();
+    assert.equal(f.current(), modal, 'do not steal focus from an unrelated modal/control');
+    assert.equal(f.focus.editorEnabled(), false);
+    assert.equal(f.focus.actionsEnabled(), false);
+    f.patch({ mode: 'base', busy: false }); f.flush();
+    assert.equal(f.current(), f.input());
+  });
+}
+
+test('preview/edit remount uses current editor; cancel/invalidate cannot revive destroyed draft', t => {
+  const f = fixture(t);
+  f.patch({ phase: 'edit', hasDraft: true }); f.flush();
+  const oldEditor = f.input();
+  f.actions.focus();
+  oldEditor.destroy();
+  f.patch({ phase: 'preview' }); f.flush();
+  assert.equal(f.current(), f.actions);
+  const nextEditor = f.mountEditor();
+  f.patch({ phase: 'edit', editorFocus: true }); f.flush();
+  assert.equal(f.current(), nextEditor);
+  f.actions.focus();
+  nextEditor.destroy();
+  f.patch({ phase: 'overview', hasDraft: false }); f.flush();
+  assert.equal(f.current(), f.actions);
+  assert.equal(oldEditor.focusCalls, 1);
+  assert.equal(nextEditor.focusCalls, 1);
+  f.patch({ phase: 'edit', hasDraft: false }); f.flush();
+  assert.equal(f.current(), undefined, 'no editor focus without a live draft');
+});
+
+test('unmount cancels pending repairs, detaches listeners and cannot steal next page focus', t => {
+  const f = fixture(t);
+  f.patch({ phase: 'edit', hasDraft: true }); f.flush();
+  f.actions.focus();
+  assert.ok(f.microtasks.length);
+  f.dispose();
+  assert.equal(f.actions.listenerCount('focused'), 0);
+  f.input().blur(); f.actions.blur();
+  const nextPage = f.newInput();
+  nextPage.focus();
+  f.flush();
+  assert.equal(f.current(), nextPage);
+  f.focus.reconcile();
+  assert.equal(f.microtasks.length, 0);
+  assert.equal(f.focus.actionsEnabled(), false);
+  assert.equal(f.focus.editorEnabled(), false);
+});
+
+test('replacing or destroying native action refs does not retain a stale focus listener', t => {
+  const f = fixture(t);
+  f.flush();
+  const replacement = f.newInput();
+  f.focus.attachActions(replacement); f.flush();
+  assert.equal(f.actions.listenerCount('focused'), 0);
+  assert.equal(replacement.listenerCount('focused'), 1);
+  replacement.destroy();
+  f.focus.reconcile(); f.flush();
+  assert.equal(replacement.focusCalls, 1);
+});
+
+test('page wires focus lifecycle and selection guard; pinned renderer exposes the used focus event contract', async () => {
+  const page = await readFile(new URL('../plugins/carthagent/src/ui/daily-quests.tsx', import.meta.url), 'utf8');
+  assert.match(page, /createEffect\(\(\) => focus\.reconcile\(\)\)/);
+  assert.match(page, /mode: context\.keymap\.mode\.current\(\)/);
+  assert.match(page, /ref=\{\(node\) => \{ actions = node; focus\.attachActions\(node\); \}\}/);
+  assert.match(page, /if \(!value \|\| !focus\.actionsEnabled\(\)\) return/);
+  assert.match(page, /onCleanup\(\(\) => \{ focus\.dispose\(\)/);
+  const api = await readFile(new URL('../node_modules/@opentui/core/Renderable.d.ts', import.meta.url), 'utf8');
+  assert.match(api, /FOCUSED = "focused"/);
+  assert.match(api, /focus\(\): void/);
+  assert.match(api, /blur\(\): void/);
+  assert.match(api, /get isDestroyed\(\): boolean/);
+  const selectApi = await readFile(new URL('../node_modules/@opentui/core/renderables/Select.d.ts', import.meta.url), 'utf8');
+  assert.match(selectApi, /setSelectedIndex\(index: number\): void/);
+});

package/tests/native-daily-editor.test.mjs

@@ -0,0 +1,43 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+import { syncDailyEditor } from '../plugins/carthagent/src/ui/daily-editor.mjs';
+import { createDailyQuestsState } from '../plugins/carthagent/src/ui/daily-quests-state.mjs';
+
+test('pinned renderer empty content-change events read current text before canonical preview', async () => {
+  // Guard the actual pinned implementation, not the misleading Solid callback
+  // type. This is an adapter contract test, not a native FFI rendering test.
+  const module = await readFile(new URL('../node_modules/@opentui/core/index.node.js', import.meta.url), 'utf8');
+  const chunkName = module.match(/from "(\.\/chunk-node-[^"]+)"/g)
+    .map(value => value.match(/"([^"]+)"/)[1]);
+  const chunks = await Promise.all(chunkName.map(name => readFile(new URL(`../node_modules/@opentui/core/${name.slice(2)}`, import.meta.url), 'utf8')));
+  assert.ok(chunks.some(source => source.includes('this._contentChangeListener({})')), 'Pinned renderer event shape changed; review the adapter');
+  const id = '11111111-1111-4111-8111-111111111111';
+  const detail = { id, status: 'open', definition: { title: 'Adapter contract' }, latestSubmission: null };
+  const writes = [];
+  let view;
+  const controller = createDailyQuestsState({ api: {
+    snapshot: async () => ({ accountKey: 'a'.repeat(64), slate: { items: [detail] }, records: [] }),
+    detail: async () => detail,
+    submit: async input => { writes.push(input); },
+  }, changed: next => { view = next; } });
+  try {
+    await controller.refresh(); await controller.select(id);
+    await controller.compose(async () => ({ id, evidence: { projectId: id, outcomeId: id, runId: id, revision: '', goal: 'private text selected originally', change: '', checks: [], findings: [] } }));
+    const edited = JSON.parse(view.draft.text);
+    edited.goal = 'Redacted user-approved goal'; edited.revision = 'a'.repeat(40);
+    const editor = { plainText: JSON.stringify(edited) };
+    const onContentChange = () => syncDailyEditor(editor, controller);
+    onContentChange({});
+    controller.preview();
+    assert.equal(view.phase, 'preview');
+    assert.equal(view.preview.evidence.goal, edited.goal);
+    assert.equal(view.preview.evidence.revision, edited.revision);
+    assert.doesNotMatch(JSON.stringify(view.preview), /private text/);
+    assert.deepEqual(writes, []);
+    controller.backToEdit();
+    edited.goal = ''; editor.plainText = JSON.stringify(edited);
+    onContentChange({}); controller.preview();
+    assert.equal(view.preview.evidence.goal, '');
+  } finally { controller.dispose(); }
+});

package/tests/native-daily-quests-layout.test.mjs

@@ -0,0 +1,53 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+
+const page = await readFile(new URL('../plugins/carthagent/src/ui/daily-quests.tsx', import.meta.url), 'utf8');
+const voyages = await readFile(new URL('../plugins/carthagent/src/ui/voyages.tsx', import.meta.url), 'utf8');
+const tui = await readFile(new URL('../plugins/carthagent/src/tui.tsx', import.meta.url), 'utf8');
+const server = await readFile(new URL('../plugins/carthagent/src/index.ts', import.meta.url), 'utf8');
+
+test('daily quests are registered in the native plugin and reachable from Voyages', () => {
+  assert.match(server, /registerDailyQuestsRpc\(context\)/);
+  assert.match(server, /registerDailySourceRpc\(context\)/);
+  assert.match(tui, /name: "daily-quests", render:.*DailyQuestsPage/);
+  assert.match(voyages, /name: "Daily coding quests"/);
+  assert.match(voyages, /name: "daily-quests"/);
+});
+
+test('evidence editing and the complete outbound preview remain native and scrollable', () => {
+  assert.match(page, /<scrollbox ref=\{summary\} flexBasis=\{0\} flexGrow=\{1\} minHeight=\{1\}/);
+  assert.match(page, /<textarea ref=\{editor\}[^>]*onContentChange=\{\(\) => syncDailyEditor\(editor, controller\)\}/);
+  assert.match(page, /bind: "tab"/);
+  assert.match(page, /JSON.stringify\(view\(\).preview, null, 2\)/);
+  assert.match(page, /JSON.stringify\(record\(\).request, null, 2\)/);
+  assert.match(page, /Ctrl\+P preview, never sends/);
+  for (const text of page.matchAll(/<text\b([^>]*)>/g)) assert.match(text[1], /flexShrink=\{0\}/);
+});
+
+test('daily cancellation helper is wired to the actual actions ref and page-scoped notice', () => {
+  assert.match(page, /actions = node; focus.attachActions\(node\)/);
+  assert.match(page, /handleDailyQuestsEvent\(\{\s*controller, event: details, location: location\(\), changedLocation, actions/);
+  assert.match(page, /interrupted: !!\(view\(\).draft \|\| view\(\).preview \|\| replayID\(\) \|\| activeDialog\)/);
+  assert.match(page, /notice: setCancellationNotice/);
+  assert.match(page, /<Show when=\{cancellationNotice\(\)\}>/);
+  assert.match(page, /stop\(\); actions = undefined; controller.dispose\(\)/);
+});
+
+test('selection starts empty and external consent, retention, uncertainty and no-reward limits are explicit', () => {
+  assert.match(page, /let goal = false, change = false/);
+  assert.match(page, /new Set<string>\(\), findings = new Set<string>\(\)/);
+  assert.match(page, /Consent and send/);
+  assert.match(page, /External JEV receives/);
+  assert.match(page, /Metadata: 90 days/);
+  assert.match(page, /not a background deletion timer/);
+  assert.match(page, /automatic secret detection is not provided/);
+  assert.match(page, /not independent verification/);
+  assert.match(page, /No coins, XP, distance, inventory or other rewards/);
+  assert.match(page, /Earlier failed-before execution is not recorded and is never inferred/);
+  assert.match(page, /c\.after === "passed" \? "fresh" : "not fresh"/);
+  assert.match(page, /\(\{ name: id, before, after, revision, result \}\)/);
+  assert.match(page, /view\(\)\.draft\?\.provenance/);
+  assert.match(page, /This does not cancel a server job, withdraw evidence already sent, or promise provider\/backup deletion/);
+  assert.doesNotMatch(page, /session\.export|file\.read|sendNativeReviewKickoff|outputTail/);
+});