carthagent 1.0.7 → 1.1.0-beta.1

package/plugins/carthagent/src/ui/commands.ts

@@ -0,0 +1,70 @@
+/** One inventory for native OpenCode slash/palette discovery and dispatch. */
+export type CommandId =
+  | "help" | "resume" | "new" | "restart" | "theme" | "model" | "thinking"
+  | "compact" | "autocompact" | "review" | "export" | "copy" | "stats"
+  | "clear" | "abort" | "raw" | "guide" | "workflow" | "architecture" | "evidence"
+  | "login" | "account" | "usage" | "billing" | "logout-cloud" | "archive" | "demo" | "voyages" | "quests"
+  | "ctg-workspace" | "ctg-open" | "ctg-preview" | "ctg-review" | "ctg-worktree" | "ctg-task";
+
+export interface CarthagentCommand {
+  id: CommandId;
+  name: string;
+  aliases?: string[];
+  args?: string;
+  /** Keep slash input eligible for command dispatch when the composer is submitted. */
+  submitSlash?: boolean;
+  description: string;
+  hidden?: boolean;
+}
+
+export const COMMANDS: readonly CarthagentCommand[] = [
+  { id: "help", name: "help", aliases: ["ctg-help"], submitSlash: true, description: "List Carthagent commands and native shortcuts" },
+  { id: "resume", name: "resume", aliases: ["sessions"], args: "[id|name]", description: "Search and resume native sessions; legacy archives are read-only" },
+  { id: "restart", name: "restart", aliases: ["kill"], description: "Recover the selected session by interrupting its active turn" },
+  { id: "theme", name: "theme", args: "[name]", description: "Pick or set a Carthagent-compatible theme" },
+  { id: "model", name: "model", args: "[name]", description: "Search and select a provider model" },
+  { id: "thinking", name: "thinking", description: "Choose a thinking variant when the model supports it" },
+  { id: "compact", name: "compact", args: "[notes]", description: "Compact the selected session, optionally with notes" },
+  { id: "autocompact", name: "autocompact", args: "[on|off]", description: "Toggle automatic compaction or explicitly enable or disable it for this session" },
+  { id: "review", name: "review", aliases: ["review-mode"], args: "[ask|yes|no|status]", description: "Review the selected session or inspect its review default" },
+  { id: "export", name: "export", args: "[file]", description: "Export the selected session as HTML" },
+  { id: "copy", name: "copy", description: "Copy the full last assistant response" },
+  { id: "stats", name: "stats", description: "Show native session token and cost stats" },
+  { id: "clear", name: "clear", description: "Clear the visible transcript for this session without deleting history" },
+  { id: "abort", name: "abort", description: "Interrupt the selected session" },
+  { id: "raw", name: "raw", args: "<prompt>", description: "Send text without Carthagent delivery framing" },
+  { id: "guide", name: "guide", args: "[task]", description: "Toggle framing or start a delivery-framed prompt" },
+  { id: "workflow", name: "workflow", description: "Open the delivery workspace workflow view" },
+  { id: "architecture", name: "architecture", description: "Open the delivery workspace architecture view" },
+  { id: "evidence", name: "evidence", description: "Open observed delivery evidence" },
+  { id: "login", name: "login", aliases: ["auth"], description: "Connect Ship, Claude, xAI, Codex/OpenAI, or Gemini" },
+  { id: "account", name: "account", aliases: ["cloud"], description: "Show Ship account, credits, plan, and sessions" },
+  { id: "voyages", name: "voyages", description: "Open Voyages profile, wallet, equipment, shop, and daily quests" },
+  { id: "quests", name: "quests", description: "Open daily coding quests; evidence requires separate explicit consent" },
+  { id: "usage", name: "usage", description: "Show recent Ship usage from the control plane" },
+  { id: "billing", name: "billing", args: "[checkout|portal]", description: "Open Ship checkout or billing portal" },
+  { id: "logout-cloud", name: "logout-cloud", args: "[session-id]", description: "Revoke a Ship session or sign out this profile" },
+  { id: "archive", name: "archive", args: "[search <query>|read <id>|export <id>]", description: "Browse bounded read-only archived sessions" },
+  { id: "demo", name: "demo", description: "Run a scripted, provider-free delivery walkthrough" },
+  { id: "ctg-workspace", name: "ctg-workspace", args: "[refresh]", description: "Browse and open local CTG workspace projects, tasks, and sessions" },
+  { id: "ctg-open", name: "ctg-open", args: "[search]", description: "Search local CTG sessions and open one in native OpenCode" },
+  { id: "ctg-preview", name: "ctg-preview", description: "Preview CTG delivery evidence for the selected session" },
+  { id: "ctg-review", name: "ctg-review", description: "Inspect CTG review status for the selected session" },
+  { id: "ctg-worktree", name: "ctg-worktree", args: "<project-id> <name>", description: "Create a local CTG worktree" },
+  { id: "ctg-task", name: "ctg-task", args: "<task>", description: "Create a CTG task with a native worktree and session" },
+] as const;
+
+export function matchCommand(query: string, commands: readonly CarthagentCommand[] = COMMANDS) {
+  const token = query.replace(/^\//, "").toLowerCase();
+  if (!token || token.includes(" ")) return [];
+  return commands.filter((item) => item.name.startsWith(token) || item.aliases?.some((alias) => alias.startsWith(token)));
+}
+
+export function resolveCommand(token: string, commands: readonly CarthagentCommand[] = COMMANDS) {
+  const normalized = token.replace(/^\//, "").toLowerCase();
+  return commands.find((item) => item.name === normalized || item.aliases?.includes(normalized));
+}
+
+// Host-owned commands take priority. These slash names are verified against
+// the V2.0.32 keybind command inventory and are intentionally not shadowed.
+export const NATIVE_COMMAND_COLLISIONS = ["themes", "settings"] as const;

package/plugins/carthagent/src/ui/daily-editor-focus.mjs

@@ -0,0 +1,52 @@
+/**
+ * Native dialogs resolve before their delayed refocus of the saved renderable.
+ * Observe actual action-list focus, then reconcile after focus() has finished
+ * installing its input handlers. A fixed timeout from compose can run too early.
+ */
+export function createDailyEditorFocus({ state, editor, defer = queueMicrotask }) {
+  let actions;
+  let generation = 0;
+  let disposed = false;
+  const permissions = () => {
+    const current = state();
+    const enabled = !disposed && !current.busy && current.mode === 'base';
+    return {
+      editor: enabled && current.phase === 'edit' && current.hasDraft && current.editorFocus,
+      actions: enabled && (current.phase !== 'edit' || !current.editorFocus),
+    };
+  };
+  const reconcile = () => {
+    if (disposed) return;
+    // Read synchronously too, so a Solid effect subscribes to ownership changes.
+    permissions();
+    const ticket = ++generation;
+    defer(() => {
+      if (disposed || ticket !== generation) return;
+      // Never capture ownership or the editor across a modal/phase/Tab change.
+      const allowed = permissions();
+      const input = editor();
+      if (!allowed.editor && input && !input.isDestroyed && input.focused) input.blur();
+      if (!allowed.actions && actions && !actions.isDestroyed && actions.focused) actions.blur();
+      const target = allowed.editor ? input : allowed.actions ? actions : undefined;
+      if (target && !target.isDestroyed && !target.focused) target.focus();
+    });
+  };
+  return {
+    reconcile,
+    editorEnabled: () => permissions().editor,
+    actionsEnabled: () => permissions().actions,
+    attachActions(renderable) {
+      actions?.off('focused', reconcile);
+      actions = renderable;
+      if (disposed) return;
+      actions.on('focused', reconcile);
+      reconcile();
+    },
+    dispose() {
+      disposed = true;
+      generation++;
+      actions?.off('focused', reconcile);
+      actions = undefined;
+    },
+  };
+}

package/plugins/carthagent/src/ui/daily-editor.mjs

@@ -0,0 +1,4 @@
+/** OpenTUI 0.5.17 emits an empty event object, not editor contents. */
+export function syncDailyEditor(editor, controller) {
+  if (editor && typeof editor.plainText === 'string') controller.edit(editor.plainText);
+}

package/plugins/carthagent/src/ui/daily-quests-events.mjs

@@ -0,0 +1,18 @@
+import { voyagesEventAction } from './voyages-state.mjs';
+
+export const dailyCancellationNotice = 'Evidence/consent canceled because the account, connection or location changed. Nothing was resent automatically. Refresh and review again; check the recovery journal for any request already started.';
+
+/** Daily-page invalidation only; retain the shared credential/location policy.
+ * Reset the native index before either replay removal or protected-state clearing
+ * can clamp a former consent selection onto Back. Never focus a renderable here.
+ */
+export function handleDailyQuestsEvent({ controller, event, location, changedLocation = false, interrupted = false, actions, clearReplay, closeDialog, notice }) {
+  const action = changedLocation ? String(event.type) === 'server.disconnected' ? 'clear' : 'refresh' : voyagesEventAction(event, location);
+  if (action === 'ignore') return;
+  if (actions && !actions.isDestroyed) actions.setSelectedIndex(0);
+  if (interrupted) notice(dailyCancellationNotice);
+  clearReplay();
+  controller.invalidate();
+  closeDialog();
+  if (action === 'refresh') return controller.refresh();
+}

package/plugins/carthagent/src/ui/daily-quests-state.mjs

@@ -0,0 +1,218 @@
+import { dailyRequest } from '../daily-evidence.mjs';
+
+const copy = value => value === undefined ? undefined : JSON.parse(JSON.stringify(value));
+function freeze(value) {
+  if (value && typeof value === 'object') {
+    Object.values(value).forEach(freeze);
+    Object.freeze(value);
+  }
+  return value;
+}
+const localError = code => ({ type: 'dailyQuestError', data: { code } });
+const failureMessage = code => `${code}. Refresh required; no success assumed. Sign in again if access expired or was revoked.`;
+
+/** Native promise RPC errors are { type, message, data }. Never render messages. */
+export function dailyErrorCode(error) {
+  const code = error?.type === 'dailyQuestError' ? error.data?.code : undefined;
+  return typeof code === 'string' && code.length >= 1 && code.length <= 64 && !/[^a-z_]/.test(code) ? code : 'daily_request_failed';
+}
+
+/** Processing status is not a coding assessment, nor independent verification. */
+export function dailySubmissionLabel(submission) {
+  if (!submission) return 'No submission';
+  if (submission.status === 'queued') return 'Queued (not completed)';
+  if (submission.status === 'grading') return 'Grading (not completed)';
+  if (submission.status === 'failed') return 'Processing failed (not a coding assessment)';
+  if (submission.status === 'graded') {
+    if (submission.decision === 'assessed_complete') return 'Classifier-assessed complete (not independently verified)';
+    if (submission.decision === 'not_met') return 'Graded: not met';
+    if (submission.decision === 'needs_evidence') return 'Graded: needs evidence';
+    return 'Graded: assessment unavailable';
+  }
+  return 'Submission status unavailable';
+}
+
+/** Offline UI transaction controller. Only explicit submit/retry can upload.
+ * Dialog callbacks receive detached copies plus a live() lifetime predicate.
+ * Cancel/back/invalidate synchronously revoke any outstanding dialog callback.
+ */
+export function createDailyQuestsState({ api, changed = (_state) => {}, timeoutSignal = () => AbortSignal.timeout(15_000) }) {
+  let generation = 0;
+  let disposed = false;
+  let controller = new AbortController();
+  const state = { snapshot: undefined, detail: undefined, busy: false, error: '', draft: undefined, preview: undefined, phase: 'overview' };
+  const emit = () => { if (!disposed) changed(copy(state)); };
+  const clearDraft = () => { state.draft = undefined; state.preview = undefined; state.phase = 'overview'; };
+  const clearProtected = () => { state.snapshot = undefined; state.detail = undefined; clearDraft(); };
+  const revoke = () => {
+    generation++;
+    controller.abort();
+    controller = new AbortController();
+    state.busy = false;
+    state.error = '';
+  };
+  const invalidate = () => { revoke(); clearProtected(); emit(); };
+  const networkSignal = signal => AbortSignal.any([signal, timeoutSignal()]);
+  const savedRecord = id => state.snapshot?.records.find(record => record.id === id);
+  const knownQuest = id => state.snapshot?.slate.items.some(quest => quest.id === id)
+    || state.snapshot?.records.some(record => record.questId === id);
+
+  async function loadSnapshot(tx, expectedAccount = tx.accountKey) {
+    if (!tx.live()) return false;
+    const snapshot = copy(await api.snapshot(networkSignal(tx.signal)));
+    if (!tx.live()) return false;
+    if (!snapshot?.accountKey || (expectedAccount != null && snapshot.accountKey !== expectedAccount)) {
+      throw localError('daily_account_changed');
+    }
+    state.snapshot = snapshot;
+    emit();
+    return tx.live();
+  }
+  async function loadDetail(id, tx) {
+    if (!tx.live()) return;
+    const detail = copy(await api.detail({ id }, networkSignal(tx.signal)));
+    if (!tx.live()) return;
+    if (detail?.id !== id) throw localError('daily_request_failed');
+    // The detail RPC reconciles acceptance and erases raw journal payloads.
+    // Drop the matching in-memory copy before exposing the accepted detail.
+    if (detail.latestSubmission && state.snapshot) {
+      const submission = detail.latestSubmission;
+      const previous = savedRecord(submission.id);
+      const record = { id: submission.id, questId: detail.id, createdAt: previous?.createdAt ?? submission.createdAt, request: null, submission: copy(submission) };
+      state.snapshot.records = state.snapshot.records.filter(item => item.id !== submission.id);
+      state.snapshot.records.push(record);
+    }
+    state.detail = detail;
+    emit();
+  }
+  async function run(action) {
+    if (disposed || state.busy) return;
+    const current = generation;
+    const signal = controller.signal;
+    const tx = { signal, accountKey: state.snapshot?.accountKey, live: () => !disposed && generation === current && !signal.aborted };
+    state.busy = true;
+    state.error = '';
+    emit();
+    try { if (tx.live()) await action(tx); }
+    catch (error) {
+      if (tx.live()) {
+        clearProtected();
+        state.error = failureMessage(dailyErrorCode(error));
+        emit();
+        // Read the durable journal only. Never replay a write, assume success,
+        // or resurrect raw evidence from a callback after an unknown outcome.
+        try { await loadSnapshot(tx); }
+        catch (reconcileError) {
+          if (tx.live()) {
+            clearProtected();
+            if (dailyErrorCode(reconcileError) === 'daily_account_changed') state.error = failureMessage('daily_account_changed');
+          }
+        }
+      }
+    } finally {
+      if (tx.live()) { state.busy = false; emit(); }
+    }
+  }
+  async function refreshedWrite(tx, questId) {
+    // Immediately drop all copies of raw evidence; GET is authoritative.
+    clearProtected();
+    emit();
+    if (await loadSnapshot(tx)) await loadDetail(questId, tx);
+  }
+
+  return {
+    invalidate,
+    dispose() { if (!disposed) { invalidate(); disposed = true; controller.abort(); } },
+    refresh() {
+      return run(async tx => { clearProtected(); emit(); await loadSnapshot(tx, null); });
+    },
+    select(id) {
+      return run(async tx => {
+        if (!knownQuest(id)) return;
+        clearDraft(); state.detail = undefined; emit();
+        await loadDetail(id, tx);
+      });
+    },
+    compose(makeDraft) {
+      return run(async tx => {
+        const detail = copy(state.detail);
+        const accountKey = state.snapshot?.accountKey;
+        if (!accountKey || !detail || detail.status !== 'open' || !knownQuest(detail.id)) return;
+        clearDraft(); emit();
+        if (!tx.live()) return;
+        const draft = await makeDraft(copy(detail), tx.live, tx.signal);
+        if (!draft || !tx.live() || state.snapshot?.accountKey !== accountKey || state.detail?.id !== detail.id) return;
+        state.draft = { accountKey, questId: detail.id, id: draft.id, text: JSON.stringify(draft.evidence, null, 2), provenance: typeof draft.provenance === 'string' ? draft.provenance : '' };
+        state.phase = 'edit';
+        emit();
+      });
+    },
+    edit(text) {
+      if (disposed || state.busy || !state.draft || typeof text !== 'string') return;
+      state.draft.text = text; state.preview = undefined; state.phase = 'edit'; state.error = ''; emit();
+    },
+    preview() {
+      if (disposed || state.busy || !state.draft) return;
+      state.preview = undefined; state.phase = 'edit'; state.error = '';
+      try {
+        const request = dailyRequest(state.draft.id, JSON.parse(state.draft.text));
+        state.draft.text = JSON.stringify(request.evidence, null, 2);
+        state.preview = freeze(copy(request)); state.phase = 'preview';
+      } catch { state.error = 'invalid_daily_evidence. Correct the evidence before previewing or submitting.'; }
+      emit();
+    },
+    backToEdit() {
+      if (disposed || !state.draft) return;
+      if (state.busy) revoke();
+      state.preview = undefined; state.phase = 'edit'; state.error = ''; emit();
+    },
+    cancelDraft() {
+      if (disposed) return;
+      if (state.busy) revoke();
+      clearDraft(); state.error = ''; emit();
+    },
+    submit(confirm) {
+      return run(async tx => {
+        if (!state.draft || !state.preview || !state.detail || state.detail.status !== 'open') return;
+        const draft = copy(state.draft);
+        if (draft.accountKey !== tx.accountKey || draft.questId !== state.detail.id) return;
+        const request = freeze(copy(state.preview));
+        const shown = { quest: copy(state.detail), request: freeze(copy(request)) };
+        if (await confirm(shown, tx.live) !== true || !tx.live()) return;
+        if (state.draft?.id !== draft.id || state.snapshot?.accountKey !== draft.accountKey || !state.preview) return;
+        await api.submit({ accountKey: draft.accountKey, questId: draft.questId, ...copy(request) }, networkSignal(tx.signal));
+        if (tx.live()) await refreshedWrite(tx, draft.questId);
+      });
+    },
+    poll(id) {
+      return run(async tx => {
+        const record = savedRecord(id);
+        const questId = record?.questId ?? (state.detail?.latestSubmission?.id === id ? state.detail.id : undefined);
+        if (!questId || !tx.accountKey) return;
+        clearDraft(); state.detail = undefined; emit();
+        if (!tx.live()) return;
+        await api.poll({ id }, networkSignal(tx.signal));
+        if (await loadSnapshot(tx)) await loadDetail(questId, tx);
+      });
+    },
+    retry(id, confirm) {
+      return run(async tx => {
+        const record = copy(savedRecord(id));
+        if (!record?.request || !tx.accountKey) return;
+        const shown = freeze(copy(record));
+        if (await confirm(shown, tx.live) !== true || !tx.live()) return;
+        await api.retry({ accountKey: tx.accountKey, id: record.id }, networkSignal(tx.signal));
+        if (tx.live()) await refreshedWrite(tx, record.questId);
+      });
+    },
+    forget(id, confirm) {
+      return run(async tx => {
+        const record = copy(savedRecord(id));
+        if (!record?.request || !tx.accountKey) return;
+        if (await confirm(freeze(copy(record)), tx.live) !== true || !tx.live()) return;
+        await api.forgetPayload({ accountKey: tx.accountKey, id: record.id }, networkSignal(tx.signal));
+        if (tx.live()) await refreshedWrite(tx, record.questId);
+      });
+    },
+  };
+}

package/plugins/carthagent/src/ui/daily-quests.tsx

@@ -0,0 +1,235 @@
+/** @jsxImportSource @opentui/solid */
+import { For, Show, createEffect, createSignal, on, onCleanup, onMount } from "solid-js";
+import { createHash, randomUUID } from "node:crypto";
+import type { ScrollBoxRenderable, SelectRenderable, TextareaRenderable } from "@opentui/core";
+import { usePlugin } from "@opencode/plugin/tui";
+import { clickSelect } from "./select-mouse.js";
+import { dailyQuestsClient, dailySourceClient } from "./client.js";
+import type { DailyEvidence, DailyQuestDetail, DailySnapshot, DailySubmission, DailyRecord } from "../daily-quests-rpc.js";
+import type { DailySourceReport } from "../daily-source-rpc.js";
+import { createDailyQuestsState, dailySubmissionLabel } from "./daily-quests-state.mjs";
+import { handleDailyQuestsEvent } from "./daily-quests-events.mjs";
+import { syncDailyEditor } from "./daily-editor.mjs";
+import { createDailyEditorFocus } from "./daily-editor-focus.mjs";
+
+type Request = NonNullable<DailyRecord['request']>;
+type View = {
+  snapshot?: DailySnapshot; detail?: DailyQuestDetail; busy: boolean; error: string;
+  draft?: { accountKey: string; questId: string; id: string; text: string; provenance: string };
+  preview?: Request; phase: "overview" | "edit" | "preview";
+};
+
+/** Stable opaque references, not proof of authorship. Never send a local path. */
+function reference(...parts: string[]) {
+  const h = createHash("sha256").update(JSON.stringify(parts)).digest("hex");
+  return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20, 32)}`;
+}
+
+const privacy = "Only the exact preview below is sent to Carthagent. External JEV receives the revision, goal, change, checks, findings and server rubric, not project/outcome/run IDs. No transcript or whole project is uploaded. Review and remove secrets yourself; automatic secret detection is not provided.\n\nBackend raw evidence: pending up to 24 hours, erased on terminal processing (outages can delay cleanup). Metadata: 90 days. Provider policy applies; immediate provider/backup deletion is not promised. Unknown-send recovery stores this exact payload in a private local journal until acceptance is known or for up to 24 hours on the next journal access, not a background deletion timer. You can erase its local payload while retaining the submission ID.\n\nClassifier assessment is not independent verification. No coins, XP, distance, inventory or other rewards. Signing in or running Ship is not consent.";
+
+export function DailyQuestsPage(props: { sessionID?: string; questID?: string }) {
+  const context = usePlugin();
+  const location = () => (props.sessionID ? context.data.session.get(props.sessionID)?.location : undefined) ?? context.location ?? context.data.location.default();
+  const [view, setView] = createSignal<View>({ busy: false, error: "", phase: "overview" });
+  const [editorFocus, setEditorFocus] = createSignal(true);
+  const [replayID, setReplayID] = createSignal<string>();
+  const [cancellationNotice, setCancellationNotice] = createSignal("");
+  const controller = createDailyQuestsState({ api: dailyQuestsClient(context, location), changed: (next: View) => setView(next) });
+  const sourceApi = dailySourceClient(context, location);
+  let summary: ScrollBoxRenderable | undefined;
+  let editor: TextareaRenderable | undefined;
+  let actions: SelectRenderable | undefined;
+  const focus = createDailyEditorFocus({
+    state: () => ({ phase: view().phase, hasDraft: !!view().draft, busy: view().busy, editorFocus: editorFocus(), mode: context.keymap.mode.current() }),
+    editor: () => editor,
+  });
+  createEffect(() => focus.reconcile());
+  const preview = () => { if (view().phase === "edit") syncDailyEditor(editor, controller); controller.preview(); };
+  let activeDialog: symbol | undefined;
+  const ownDialog = async <T,>(show: () => Promise<T>): Promise<T> => {
+    const token = Symbol(); activeDialog = token;
+    try { return await show(); } finally { if (activeDialog === token) activeDialog = undefined; }
+  };
+  const closeOwnDialog = () => {
+    if (!activeDialog) return;
+    activeDialog = undefined;
+    context.ui.dialog.clear();
+  };
+  const confirm = (title: string, message: string, label: string) => ownDialog(() => context.ui.dialog.confirm({ title, message, label: { confirm: label, cancel: "Cancel" } }));
+  context.keymap.layer(() => ({ commands: [
+    { bind: "ctrl+u", title: "Scroll daily quest preview up", run: () => { summary?.scrollBy(-1); } },
+    { bind: "ctrl+d", title: "Scroll daily quest preview down", run: () => { summary?.scrollBy(1); } },
+    { bind: "ctrl+g", title: "Validate daily evidence preview", enabled: () => view().phase === "edit" && !view().busy, run: preview },
+    { bind: "tab", title: "Switch evidence editor / actions", enabled: () => view().phase === "edit" && !view().busy, run: () => { setEditorFocus((focused) => !focused); } },
+  ] }));
+
+  const chooseProjection = async (source: DailySourceReport, sessionID: string, live: () => boolean): Promise<DailyEvidence | undefined> => {
+    let goal = false, change = false;
+    const checks = new Set<string>(), findings = new Set<string>();
+    while (live()) {
+      const selected = await ownDialog(() => context.ui.dialog.select({
+        title: "Select local evidence · nothing included by default",
+        options: [
+          { title: "Done selecting", value: "done", description: "Open editable JSON; nothing is sent yet" },
+          { title: `${goal ? "Remove" : "Include"} recorded goal`, value: "goal", description: "May contain private task text" },
+          { title: `${change ? "Remove" : "Include"} recorded change`, value: "change", description: source.change ? "Recorded claim, not independently verified" : "Not recorded; remains empty" },
+          ...source.checks.map((c) => ({ title: `${checks.has(c.id) ? "Remove" : "Include"} check ${c.id}`, value: `check:${c.id}`, description: `${c.after} · ${c.after === "passed" ? "fresh" : "not fresh"} · includes output tail, potentially sensitive; before not recorded` })),
+          ...source.findings.map((f) => ({ title: `${findings.has(f.id) ? "Remove" : "Include"} finding ${f.id}`, value: `finding:${f.id}`, description: "Includes issue, evidence and resolution text; model/user-authored claim" })),
+        ],
+      }));
+      if (!live() || selected === undefined) return;
+      if (selected === "done") break;
+      if (selected === "goal") goal = !goal;
+      else if (selected === "change") change = !change;
+      else {
+        const isCheck = selected.startsWith("check:");
+        const id = selected.slice(isCheck ? 6 : 8), set = isCheck ? checks : findings;
+        if (set.has(id)) set.delete(id); else set.add(id);
+      }
+    }
+    if (!live()) return;
+    const session = context.data.session.get(sessionID);
+    const project = reference("daily-project-v1", session?.projectID ?? location().directory);
+    return {
+      projectId: project, outcomeId: reference("daily-outcome-v1", project, source.runId), runId: source.runId,
+      revision: source.revision, goal: goal ? source.goal : "", change: change ? source.change : "",
+      checks: source.checks.filter((c) => checks.has(c.id)).map(({ id, before, after, revision, result }) => ({ name: id, before, after, revision, result })),
+      findings: source.findings.filter((f) => findings.has(f.id)).map(({ issue, evidence, resolution }) => ({ issue, evidence, resolution })),
+    };
+  };
+
+  const compose = () => controller.compose(async (_quest: DailyQuestDetail, live: () => boolean, signal: AbortSignal) => {
+    const kind = await ownDialog(() => context.ui.dialog.select({ title: "Choose evidence source", options: [
+      { title: "Select actual local Ship report", value: "local", description: "Owned session only; choose individual checks/findings, no transcript" },
+      { title: "Write a structured manual claim", value: "manual", description: "Blank evidence, not a claim that checks ran; edit every field" },
+    ] }));
+    if (!kind || !live()) return;
+    if (kind === "manual") {
+      const project = reference("daily-project-v1", props.sessionID ? context.data.session.get(props.sessionID)?.projectID ?? location().directory : location().directory);
+      return { id: randomUUID(), evidence: { projectId: project, outcomeId: randomUUID(), runId: randomUUID(), revision: "", goal: "", change: "", checks: [], findings: [] }, provenance: "Manual user claim. Enter a genuine 40/64-hex revision. Empty evidence does not establish completion. Keep project/outcome/run IDs when revising the same outcome; they do not prove authorship." };
+    }
+    const sessions = context.data.session.list().filter((s) => s.location.directory === location().directory);
+    const sessionID = props.sessionID ?? await ownDialog(() => context.ui.dialog.select({ title: "Choose local Ship session", options: sessions.map((s) => ({ title: s.title ?? s.id, value: s.id, description: s.id })) }));
+    if (!sessionID || !live()) return;
+    const { source } = await sourceApi.report({ sessionID }, AbortSignal.any([signal, AbortSignal.timeout(15_000)]));
+    if (!live()) return;
+    if (!source) throw new Error("daily_source_unavailable");
+    const evidence = await chooseProjection(source, sessionID, live);
+    if (!evidence || !live()) return;
+    return { id: randomUUID(), evidence, provenance: `Local Ship session ${sessionID} · run ${source.runId} · plan revision ${source.planRevision} · ${source.freshness}. Source revision is the actual workspace fingerprint, not the plan revision. Earlier failed-before execution is not recorded and is never inferred. Selected text is editable and remains a user claim, not independent verification.${source.truncated ? " Source projection is truncated; inspect and correct missing details before submitting." : ""}` };
+  });
+
+  const submit = () => controller.submit(({ quest, request }: { quest: DailyQuestDetail; request: Request }) => confirm(
+    "Explicit consent for this one JEV submission",
+    `${quest.definition.title}\nSubmission ${request.id}\nSend only the exact JSON shown in the scrollable preview to Carthagent for external JEV grading? Review/redact before consent. Raw backend evidence: pending up to 24h, erased on terminal processing; metadata 90d. Outages can delay cleanup. Provider/backup deletion is not guaranteed. No rewards or independent verification.\n\nCancel to review the preview and full retention notice again. This authorizes this submission only.`,
+    "Consent and send",
+  ));
+  const retry = (id: string) => controller.retry(id, (record: DailyRecord) => confirm("Retry the SAME consented submission?", `Submission ${record.id}\nReplay only the exact saved ID/body shown in the scrollable recovery preview to Carthagent/external JEV under the same retention notice? Poll first when possible. This cannot edit evidence or create a replacement ID. Cancel keeps it pending.`, "Replay same request"));
+  const forget = (id: string) => controller.forget(id, (record: DailyRecord) => confirm("Erase local recovery payload?", `Submission ${record.id}\nErase the selected evidence from the local journal. Keep the stable submission/quest IDs for read-only status checks. Exact replay will no longer be possible. This does not cancel a server job, withdraw evidence already sent, or promise provider/backup deletion.`, "Erase local payload"));
+
+  const statusText = (submission: DailySubmission) => `${dailySubmissionLabel(submission)}\nSubmission ${submission.id} · provider attempts ${submission.attempts}/4\nCreated ${submission.createdAt}${submission.nextAttemptAt ? ` · next attempt ${submission.nextAttemptAt}` : ""}${submission.finishedAt ? ` · finished ${submission.finishedAt}` : ""}${submission.errorCode ? `\nProcessing code: ${submission.errorCode}` : ""}${submission.model ? `\nModel ${submission.model} · rubric ${submission.rubricVersion}` : ""}${submission.scores ? `\nUncalibrated rubric scores (not confidence): ${Object.entries(submission.scores).map(([id, score]) => `${id}: ${score}`).join(" · ")}` : ""}`;
+  const options = () => {
+    const state = view(), detail = state.detail;
+    const basic = [
+      { name: "Refresh daily assignments and recovery journal", description: "Read-only; never uploads or replays evidence", value: "refresh" },
+      { name: "Sign in / reconnect", description: "Native Carthagent Ship device sign-in; not grading consent", value: "signin" },
+      { name: "Back to Voyages", description: "Discard unsent editor contents", value: "back" },
+    ];
+    if (!state.snapshot) return basic;
+    return [...basic,
+      ...(replayID() ? [
+        { name: "Confirm exact saved replay…", description: "Review the scrollable recovery preview first; explicit same-ID replay", value: "confirm-replay" },
+        { name: "Close recovery preview", description: "No replay; keep saved payload", value: "close-replay" },
+      ] : []),
+      ...state.snapshot.slate.items.map((q) => ({ name: `${q.definition.title} · ${q.status}`, description: `${q.definition.kind} · UTC window ends ${q.endsAt}`, value: `quest:${q.id}` })),
+      ...(detail?.status === "open" && !state.draft ? [{ name: "Choose evidence for selected quest", description: "Select local report data or write a manual claim; no upload", value: "compose" }] : []),
+      ...(state.phase === "edit" ? [{ name: "Validate and preview exact payload", description: "Ctrl+G; canonical UTF-8 limits, no network", value: "preview" }] : []),
+      ...(state.phase === "preview" ? [
+        { name: "Consent and submit this preview…", description: "Fresh explicit consent dialog; no automatic acceptance or rewards", value: "submit" },
+        { name: "Edit / redact evidence again", description: "Invalidates the preview; requires validation and fresh consent", value: "edit" },
+      ] : []),
+      ...(state.draft ? [{ name: "Discard unsent evidence", description: "Clear local editor; no submission", value: "cancel" }] : []),
+      ...(detail?.latestSubmission ? [{ name: "Poll selected quest's latest submission", description: "Read-only authoritative status; no provider dispatch", value: `poll:${detail.latestSubmission.id}` }] : []),
+      ...state.snapshot.records.flatMap((r) => [
+        { name: `Poll saved ${r.id}`, description: r.submission ? dailySubmissionLabel(r.submission) : "Outcome unknown; stable ID retained, including previous UTC days", value: `poll:${r.id}` },
+        ...(r.request ? [
+          { name: `Review exact replay ${r.id}`, description: "Saved same ID/body; explicit confirmation, never automatic", value: `retry:${r.id}` },
+          { name: `Erase local payload ${r.id}`, description: "Keep ID for polling; cannot replay afterward", value: `forget:${r.id}` },
+        ] : []),
+      ]),
+    ];
+  };
+  const select = (value?: string) => {
+    // A stale native refocus must not turn editor Enter into an action.
+    if (!value || !focus.actionsEnabled()) return;
+    if (value === "back") { context.ui.router.navigate({ type: "plugin", name: "voyages", data: { ...(props.sessionID ? { sessionID: props.sessionID } : {}) } }); return; }
+    if (value === "signin") { controller.invalidate(); closeOwnDialog(); context.keymap.dispatch("provider.connect"); return; }
+    if (value === "refresh") { setReplayID(undefined); void controller.refresh(); return; }
+    if (value === "compose") { setCancellationNotice(""); setEditorFocus(true); void compose(); return; }
+    if (value === "preview") { preview(); return; }
+    if (value === "submit") { void submit(); return; }
+    if (value === "edit") { setEditorFocus(true); controller.backToEdit(); return; }
+    if (value === "cancel") { controller.cancelDraft(); return; }
+    if (value === "close-replay") { setReplayID(undefined); return; }
+    if (value === "confirm-replay") { const id = replayID(); if (id) { void retry(id).finally(() => setReplayID(undefined)); } return; }
+    const colon = value.indexOf(":"), id = value.slice(colon + 1);
+    if (value.startsWith("quest:")) void controller.select(id);
+    if (value.startsWith("poll:")) void controller.poll(id);
+    if (value.startsWith("retry:")) { setCancellationNotice(""); controller.cancelDraft(); setReplayID(id); }
+    if (value.startsWith("forget:")) void forget(id);
+  };
+  onMount(() => {
+    let binding = JSON.stringify(location());
+    const stop = context.data.listen(({ details }) => {
+      const nextBinding = JSON.stringify(location());
+      const changedLocation = binding !== nextBinding;
+      binding = nextBinding;
+      void handleDailyQuestsEvent({
+        controller, event: details, location: location(), changedLocation, actions,
+        interrupted: !!(view().draft || view().preview || replayID() || activeDialog),
+        clearReplay: () => setReplayID(undefined), closeDialog: closeOwnDialog, notice: setCancellationNotice,
+      });
+    });
+    // A navigator link selects only an assignment in the authenticated slate.
+    // It never composes evidence or opens a consent dialog.
+    void controller.refresh().then(() => { if (props.questID) return controller.select(props.questID); });
+    // The router reuses this page when another rail quest is opened.
+    createEffect(on(() => props.questID, (questID) => { if (questID) void controller.select(questID); }, { defer: true }));
+    onCleanup(() => { focus.dispose(); stop(); actions = undefined; controller.dispose(); closeOwnDialog(); });
+  });
+  return <box flexDirection="column" flexGrow={1} padding={1}>
+    <text flexShrink={0} fg={context.theme.text.action.primary.base}>CARTHAGENT · DAILY CODING QUESTS</text>
+    <scrollbox ref={summary} flexBasis={0} flexGrow={1} minHeight={1} contentOptions={{ flexDirection: "column" }}>
+      <text flexShrink={0} fg={context.theme.text.muted}>Classifier-assessed submitted evidence, not independent verification. No rewards. Refresh/poll never uploads evidence.</text>
+      <Show when={cancellationNotice()}><text flexShrink={0} fg={context.theme.text.feedback.warning.base}>{cancellationNotice()}</text></Show>
+      <Show when={view().busy}><text flexShrink={0} fg={context.theme.text.feedback.warning.base}>Awaiting response / explicit selection or consent. Other actions locked.</text></Show>
+      <Show when={view().error}><text flexShrink={0} fg={context.theme.text.feedback.error.base}>{view().error}</text></Show>
+      <Show when={view().snapshot} fallback={<text flexShrink={0} fg={context.theme.text.muted}>Protected assignments and evidence hidden until successful authentication and refresh.</text>}>{(snapshot) => <box flexDirection="column" flexShrink={0}>
+        <text flexShrink={0} fg={context.theme.text.base}>UTC day {snapshot().slate.day} · closes {snapshot().slate.endsAt} · policy {snapshot().slate.policyVersion}</text>
+        <text flexShrink={0} fg={context.theme.text.muted}>New submissions close at the server's UTC boundary. Accepted jobs can finish afterward. Select a quest below for its actual criteria.</text>
+        <For each={snapshot().records}>{(r) => <text flexShrink={0} fg={context.theme.text.muted}>{r.submission ? statusText(r.submission) : `Outcome unknown / no confirmed acceptance · submission ${r.id} · quest ${r.questId}${r.request ? " · exact replay payload available" : " · payload erased; poll ID only"}`}</text>}</For>
+      </box>}</Show>
+      <Show when={view().detail}>{(detail) => <box flexDirection="column" flexShrink={0}>
+        <text flexShrink={0} fg={context.theme.text.action.primary.base}>{detail().definition.title} · {detail().status}</text>
+        <text flexShrink={0} fg={context.theme.text.muted}>Quest {detail().id} · {detail().definition.kind} · ends {detail().endsAt} · rubric {detail().definition.rubricVersion}</text>
+        <For each={detail().definition.criteria}>{(c) => <text flexShrink={0} fg={context.theme.text.base}>{c.id}: {c.text}</text>}</For>
+        <Show when={detail().latestSubmission}>{(s) => <text flexShrink={0} fg={context.theme.text.base}>{statusText(s())}</text>}</Show>
+      </box>}</Show>
+      <Show when={view().draft}><text flexShrink={0} fg={context.theme.text.muted}>{view().draft?.provenance}</text></Show>
+      <Show when={view().phase === "preview" && view().preview}>
+        <text flexShrink={0} fg={context.theme.text.base}>{privacy}</text>
+        <text flexShrink={0} fg={context.theme.text.base}>{`Exact request for quest ${view().draft?.questId}:\n${JSON.stringify(view().preview, null, 2)}`}</text>
+      </Show>
+      <Show when={view().snapshot?.records.find((r) => r.id === replayID() && r.request)}>{(record) => <box flexDirection="column" flexShrink={0}>
+        <text flexShrink={0} fg={context.theme.text.base}>{privacy}</text>
+        <text flexShrink={0} fg={context.theme.text.base}>{`Exact saved recovery request · quest ${record().questId}:\n${JSON.stringify(record().request, null, 2)}`}</text>
+      </box>}</Show>
+    </scrollbox>
+    <Show when={view().phase === "edit" && view().draft}>
+      <text flexShrink={0} fg={context.theme.text.faint}>Ctrl+J newline · Tab actions · Ctrl+G preview, never sends</text>
+      <textarea ref={editor} flexBasis={0} flexGrow={1} minHeight={2} initialValue={view().draft?.text ?? ""} focused={focus.editorEnabled()} onContentChange={() => syncDailyEditor(editor, controller)} keyBindings={[{ name: "g", ctrl: true, action: "submit" }]} onSubmit={preview} />
+    </Show>
+    <text flexShrink={0} fg={context.theme.text.faint}>↑/↓ Enter · PgUp/Dn · Ctrl+U/D details · Cancel: no send</text>
+    <select ref={(node) => { actions = node; focus.attachActions(node); }} onMouseUp={(event) => { if (focus.actionsEnabled()) clickSelect(actions, event); }} flexBasis={0} flexGrow={1} flexShrink={0} minHeight={3} showScrollIndicator options={options()} focused={focus.actionsEnabled()} keyBindings={[{ name: "pageup", action: "move-up-fast" }, { name: "pagedown", action: "move-down-fast" }]} onSelect={(_index, option) => select(option?.value)} />
+  </box>;
+}