carthagent 1.0.7 → 1.1.0-beta.2

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

@@ -0,0 +1,127 @@
+import type { Context } from "@opencode/plugin/tui/context";
+import type { LocationRef } from "@opencode/client";
+import { Workspace, type WorkspaceDelivery, type WorkspaceSnapshot } from "../workspace-rpc.js";
+import { SessionControls } from "../session-rpc.js";
+import { PullRequests, type PullRequestRecord } from "../pull-request-rpc.js";
+import { Archive } from "../archive-rpc.js";
+import { Carthagent } from "../rpc.js";
+import { Voyages, type VoyagesSnapshot, type VoyagesProfile, type VoyagesItem, type VoyagesQuote } from "../voyages-rpc.js";
+import { DailyQuests, type DailyEvidence, type DailySnapshot, type DailyQuestDetail } from "../daily-quests-rpc.js";
+import { DailySource, type DailySourceReport } from "../daily-source-rpc.js";
+import { formatCloudAccount, formatCloudUsage } from "../../../../lib/cloud/client.mjs";
+
+export { Workspace, SessionControls, PullRequests, Archive };
+export type { WorkspaceDelivery, WorkspaceSnapshot, PullRequestRecord };
+export type { VoyagesSnapshot, VoyagesProfile, VoyagesItem, VoyagesQuote };
+
+const REQUEST_TIMEOUT_MS = 15_000;
+
+type RpcContext = Pick<Context, "client" | "location" | "data">;
+
+type SelectedLocation = LocationRef | (() => LocationRef | undefined);
+
+function requestOptions(context: RpcContext, selectedLocation?: SelectedLocation, signal?: AbortSignal) {
+  const location = typeof selectedLocation === "function" ? selectedLocation() : selectedLocation;
+  return {
+    location: location ?? context.location ?? context.data.location.default(),
+    signal: signal ?? AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+  };
+}
+
+export function voyagesClient(context: RpcContext, selectedLocation?: SelectedLocation) {
+  const rpc = context.client.rpc(Voyages);
+  return {
+    previewReward: (input: { sessionID: string }, signal?: AbortSignal) => rpc.previewReward(input, requestOptions(context, selectedLocation, signal)),
+    claimReward: (input: { sessionID: string; runId: string; snapshot: string }, signal?: AbortSignal) => rpc.claimReward(input, requestOptions(context, selectedLocation, signal)),
+    snapshot: (signal?: AbortSignal) => rpc.snapshot({}, requestOptions(context, selectedLocation, signal)) as Promise<VoyagesSnapshot>,
+    customize: (input: { version: number; name?: string; shipName?: string; skin?: string; hair?: string; pattern?: string }, signal?: AbortSignal) => rpc.customize(input, requestOptions(context, selectedLocation, signal)),
+    equip: (input: { version: number; slot: string; item: string }, signal?: AbortSignal) => rpc.equip(input, requestOptions(context, selectedLocation, signal)),
+    quote: (input: { slot: string; item: string }, signal?: AbortSignal) => rpc.quote(input, requestOptions(context, selectedLocation, signal)),
+    purchase: (input: { quoteId: string }, signal?: AbortSignal) => rpc.purchase(input, requestOptions(context, selectedLocation, signal)),
+    retryPurchase: (input: { quoteId: string }, signal?: AbortSignal) => rpc.retryPurchase(input, requestOptions(context, selectedLocation, signal)),
+  };
+}
+
+export function dailyQuestsClient(context: RpcContext, selectedLocation?: SelectedLocation) {
+  const rpc = context.client.rpc(DailyQuests);
+  return {
+    snapshot: (signal?: AbortSignal) => rpc.snapshot({}, requestOptions(context, selectedLocation, signal)) as Promise<DailySnapshot>,
+    detail: (input: { id: string }, signal?: AbortSignal) => rpc.detail(input, requestOptions(context, selectedLocation, signal)) as Promise<DailyQuestDetail>,
+    submit: (input: { accountKey: string; questId: string; id: string; consent: true; evidence: DailyEvidence }, signal?: AbortSignal) => rpc.submit(input, requestOptions(context, selectedLocation, signal)),
+    retry: (input: { accountKey: string; id: string }, signal?: AbortSignal) => rpc.retry(input, requestOptions(context, selectedLocation, signal)),
+    poll: (input: { id: string }, signal?: AbortSignal) => rpc.poll(input, requestOptions(context, selectedLocation, signal)),
+    forgetPayload: (input: { accountKey: string; id: string }, signal?: AbortSignal) => rpc.forgetPayload(input, requestOptions(context, selectedLocation, signal)),
+  };
+}
+
+export function dailySourceClient(context: RpcContext, selectedLocation?: SelectedLocation) {
+  const rpc = context.client.rpc(DailySource);
+  return { report: (input: { sessionID: string }, signal?: AbortSignal) => rpc.report(input, requestOptions(context, selectedLocation, signal)) as Promise<{ source: DailySourceReport | null }> };
+}
+
+export function workspaceClient(context: RpcContext, selectedLocation?: SelectedLocation) {
+  const rpc = context.client.rpc(Workspace);
+  return {
+    snapshot: (input?: { projectID?: string }, signal?: AbortSignal) => rpc.snapshot(input ?? {}, requestOptions(context, selectedLocation, signal)) as Promise<WorkspaceSnapshot>,
+    open: (input: { sessionID: string }, signal?: AbortSignal) => rpc.open(input, requestOptions(context, selectedLocation, signal)) as Promise<{ opened: boolean; directory: string }>,
+    createWorktree: (input: { projectID: string; name: string }, signal?: AbortSignal) => rpc.createWorktree(input, requestOptions(context, selectedLocation, signal)) as Promise<{ directory: string }>,
+    createTask: (input: { task: string; branch?: string }, signal?: AbortSignal) => rpc.createTask(input, requestOptions(context, selectedLocation, signal)) as Promise<{ taskID: string; sessionID: string; directory: string }>,
+    delivery: (input: { sessionID: string }, signal?: AbortSignal) => rpc.delivery(input, requestOptions(context, selectedLocation, signal)) as Promise<WorkspaceDelivery>,
+    review: (input: { sessionID: string }, signal?: AbortSignal) => rpc.review(input, requestOptions(context, selectedLocation, signal)) as Promise<{ status: string; summary?: string }>,
+    startReview: (input: { sessionID: string }, signal?: AbortSignal) => rpc.startReview(input, requestOptions(context, selectedLocation, signal)) as Promise<{ status: string; summary: string; sessionID?: string }>,
+    events: rpc.events,
+  };
+}
+
+export function sessionControls(context: RpcContext, selectedLocation?: SelectedLocation) {
+  const rpc = context.client.rpc(SessionControls);
+  return {
+    framing: (input: { sessionID: string; enabled?: boolean }, signal?: AbortSignal) => rpc.framing(input, requestOptions(context, selectedLocation, signal)) as Promise<{ enabled: boolean }>,
+    compact: (input: { sessionID: string; notes?: string }, signal?: AbortSignal) => rpc.compact(input, requestOptions(context, selectedLocation, signal)) as Promise<{ admitted: boolean }>,
+  };
+}
+
+export function pullRequestClient(context: RpcContext, selectedLocation?: SelectedLocation) {
+  const rpc = context.client.rpc(PullRequests);
+  return {
+    list: (input: { sessionID: string; taskID: string }, signal?: AbortSignal) => rpc.list(input, requestOptions(context, selectedLocation, signal)) as Promise<{ pullRequests: PullRequestRecord[] }>,
+    associate: (input: { sessionID: string; taskID: string; number: number }, signal?: AbortSignal) => rpc.associate(input, requestOptions(context, selectedLocation, signal)) as Promise<{ pullRequest: PullRequestRecord }>,
+    refresh: (input: { sessionID: string; taskID: string; number?: number }, signal?: AbortSignal) => rpc.refresh(input, requestOptions(context, selectedLocation, signal)) as Promise<{ pullRequest: PullRequestRecord }>,
+  };
+}
+
+export function shipClient(context: RpcContext, selectedLocation?: SelectedLocation) {
+  const rpc = context.client.rpc(Carthagent);
+  return {
+    account: (signal?: AbortSignal) => rpc.shipAccount({}, requestOptions(context, selectedLocation, signal)),
+    usage: (input: { limit?: number } = {}, signal?: AbortSignal) => rpc.shipUsage(input, requestOptions(context, selectedLocation, signal)),
+    billing: (input: { action: "checkout" | "portal" | "quote"; plan?: "builder" | "pro" | "max" }, signal?: AbortSignal) => rpc.shipBilling(input, requestOptions(context, selectedLocation, signal)),
+    logout: (input: { session?: string } = {}, signal?: AbortSignal) => rpc.shipLogout(input, requestOptions(context, selectedLocation, signal)),
+  };
+}
+
+export function archiveClient(context: RpcContext, selectedLocation?: SelectedLocation) {
+  const rpc = context.client.rpc(Archive);
+  return {
+    list: (input: { offset?: number; limit?: number } = {}, signal?: AbortSignal) => rpc.list(input, requestOptions(context, selectedLocation, signal)),
+    search: (input: { query: string; offset?: number; limit?: number }, signal?: AbortSignal) => rpc.search(input, requestOptions(context, selectedLocation, signal)),
+    read: (input: { id: string }, signal?: AbortSignal) => rpc.read(input, requestOptions(context, selectedLocation, signal)),
+    export: (input: { id: string; format?: "json" | "jsonl" }, signal?: AbortSignal) => rpc.export(input, requestOptions(context, selectedLocation, signal)),
+  };
+}
+
+export function cloudAccountText(account: Record<string, unknown>) {
+  return formatCloudAccount(account);
+}
+
+export function cloudUsageText(usage: Record<string, unknown>, account?: Record<string, unknown>) {
+  return formatCloudUsage(usage, { account } as Parameters<typeof formatCloudUsage>[1]);
+}
+
+export function archiveItemText(item: Record<string, unknown>) {
+  return `${String(item.id)} · ${String(item.messageCount)} messages${item.createdAt ? ` · ${String(item.createdAt)}` : ""}${item.excerpt ? `\n${String(item.excerpt)}` : ""}`;
+}
+
+export function rpcEventOptions(_context: RpcContext, signal?: AbortSignal): { signal?: AbortSignal } {
+  return signal ? { signal } : {};
+}

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 Cloud 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 Cloud 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);
+      });
+    },
+  };
+}