@zq-silk/yui 0.15.7 → 0.15.8

package/dist/telemetry/sqliteTelemetryStore.js

@@ -1,7 +1,7 @@
 import { existsSync } from "node:fs";
 import { join } from "node:path";
 import Database from "better-sqlite3";
-import { DEFAULT_TURN_CAP, DEFAULT_TERMINAL_KEEP } from "./telemetryConfig.js";
+import { DEFAULT_RUN_CAP, DEFAULT_TERMINAL_KEEP } from "./telemetryConfig.js";
 import { migrateSqliteSchema } from "../storage/sqliteSchema.js";
 import { CURRENT_DATABASE_FILENAME as COMMITTED_DATABASE_FILENAME } from "../storage/currentTaskStore.js";
 /**
@@ -18,7 +18,7 @@ import { CURRENT_DATABASE_FILENAME as COMMITTED_DATABASE_FILENAME } from "../sto
  *
  * The telemetry tables are maintained by the centralized schema baseline:
  * `telemetry` holds the bounded latest-per-key window and
- * `telemetry_aggregate` holds the authoritative per-Turn/generation
+ * `telemetry_aggregate` holds the authoritative per-AgentRun
  * summary, maintained by triggers so it survives window pruning.
  */
 const MAX_PAGE_LIMIT = 500;
@@ -41,7 +41,7 @@ export class SqliteTelemetryStore {
         this.mode = options.mode ?? "on";
         this.#path = join(home, COMMITTED_DATABASE_FILENAME);
         this.#terminalKeep = options.terminalKeep ?? DEFAULT_TERMINAL_KEEP;
-        this.#turnCap = options.turnCap ?? DEFAULT_TURN_CAP;
+        this.#turnCap = options.runCap ?? DEFAULT_RUN_CAP;
         this.#maxPending = options.maxPending ?? 10_000;
     }
     // -- TelemetrySink -------------------------------------------------------------
@@ -89,53 +89,52 @@ export class SqliteTelemetryStore {
         this.#db = null;
     }
     // -- TelemetryReader -----------------------------------------------------------
-    count(taskId, turnId) {
+    count(taskId, runId) {
         const db = this.#ensureDb();
         if (db === null)
             return 0;
         if (taskId === undefined) {
             return db.prepare("SELECT COUNT(*) AS n FROM telemetry").get().n;
         }
-        if (turnId === undefined) {
+        if (runId === undefined) {
             return db.prepare("SELECT COUNT(*) AS n FROM telemetry WHERE task_id = ?").get(taskId).n;
         }
-        return db.prepare("SELECT COUNT(*) AS n FROM telemetry WHERE task_id = ? AND turn_id = ?").get(taskId, turnId).n;
+        return db.prepare("SELECT COUNT(*) AS n FROM telemetry WHERE task_id = ? AND turn_id = ?").get(taskId, runId).n;
     }
-    list(taskId, turnId, page = { limit: 100, offset: 0 }) {
+    list(taskId, runId, page = { limit: 100, offset: 0 }) {
         const db = this.#ensureDb();
         if (db === null)
             return { items: [], nextOffset: null };
         const limit = Math.min(Math.max(1, Math.trunc(page.limit)), MAX_PAGE_LIMIT);
         const offset = Math.max(0, Math.trunc(page.offset));
-        const rows = turnId === undefined
-            ? db.prepare("SELECT task_id, role_name, turn_id, generation, progress_id, sequence, payload, received_at FROM telemetry WHERE task_id = ? ORDER BY received_at, progress_id LIMIT ? OFFSET ?").all(taskId, limit, offset)
-            : db.prepare("SELECT task_id, role_name, turn_id, generation, progress_id, sequence, payload, received_at FROM telemetry WHERE task_id = ? AND turn_id = ? ORDER BY received_at, progress_id LIMIT ? OFFSET ?").all(taskId, turnId, limit, offset);
+        const rows = runId === undefined
+            ? db.prepare("SELECT task_id, role_name, turn_id, progress_id, sequence, payload, received_at FROM telemetry WHERE task_id = ? ORDER BY received_at, progress_id LIMIT ? OFFSET ?").all(taskId, limit, offset)
+            : db.prepare("SELECT task_id, role_name, turn_id, progress_id, sequence, payload, received_at FROM telemetry WHERE task_id = ? AND turn_id = ? ORDER BY received_at, progress_id LIMIT ? OFFSET ?").all(taskId, runId, limit, offset);
         const items = rows.map(rowToEntry);
-        const total = this.count(taskId, turnId);
+        const total = this.count(taskId, runId);
         const nextOffset = offset + items.length < total ? offset + items.length : null;
         return { items, nextOffset };
     }
-    aggregate(taskId, turnId) {
+    aggregate(taskId, runId) {
         const db = this.#ensureDb();
         if (db === null)
             return null;
-        const rows = db.prepare("SELECT task_id, role_name, turn_id, generation, first_at, last_at, count, max_sequence, error_count FROM telemetry_aggregate WHERE task_id = ? AND turn_id = ?").all(taskId, turnId);
+        const rows = db.prepare("SELECT task_id, role_name, turn_id, first_at, last_at, count, max_sequence, error_count FROM telemetry_aggregate WHERE task_id = ? AND turn_id = ?").all(taskId, runId);
         if (rows.length === 0)
             return null;
         return mergeAggregates(rows);
     }
-    aggregateGeneration(taskId, roleName, turnId, generation) {
+    aggregateRoleRun(taskId, roleName, runId) {
         const db = this.#ensureDb();
         if (db === null)
             return null;
-        const row = db.prepare("SELECT task_id, role_name, turn_id, generation, first_at, last_at, count, max_sequence, error_count FROM telemetry_aggregate WHERE task_id = ? AND role_name = ? AND turn_id = ? AND generation = ?").get(taskId, roleName, turnId, generation);
+        const row = db.prepare("SELECT task_id, role_name, turn_id, first_at, last_at, count, max_sequence, error_count FROM telemetry_aggregate WHERE task_id = ? AND role_name = ? AND turn_id = ?").get(taskId, roleName, runId);
         if (row === undefined)
             return null;
         return {
             taskId: row.task_id,
             roleName: row.role_name,
-            turnId: row.turn_id,
-            generation: row.generation,
+            runId: row.turn_id,
             firstAt: row.first_at,
             lastAt: row.last_at,
             count: row.count,
@@ -143,16 +142,15 @@ export class SqliteTelemetryStore {
             errorCount: row.error_count
         };
     }
-    listTurnAggregates(taskId) {
+    listRunAggregates(taskId) {
         const db = this.#ensureDb();
         if (db === null)
             return [];
-        const rows = db.prepare("SELECT task_id, role_name, turn_id, generation, first_at, last_at, count, max_sequence, error_count FROM telemetry_aggregate WHERE task_id = ? ORDER BY turn_id, generation").all(taskId);
+        const rows = db.prepare("SELECT task_id, role_name, turn_id, first_at, last_at, count, max_sequence, error_count FROM telemetry_aggregate WHERE task_id = ? ORDER BY turn_id").all(taskId);
         return rows.map((row) => ({
             taskId: row.task_id,
             roleName: row.role_name,
-            turnId: row.turn_id,
-            generation: row.generation,
+            runId: row.turn_id,
             firstAt: row.first_at,
             lastAt: row.last_at,
             count: row.count,
@@ -164,52 +162,51 @@ export class SqliteTelemetryStore {
         return this.#applied;
     }
     // -- retention -----------------------------------------------------------------
-    pruneGeneration(taskId, roleName, turnId, generation, keep = this.#terminalKeep) {
+    pruneRun(taskId, roleName, runId, keep = this.#terminalKeep) {
         const db = this.#ensureDb();
         if (db === null)
             return 0;
         const result = db.prepare(`DELETE FROM telemetry
-       WHERE task_id = ? AND role_name = ? AND turn_id = ? AND generation = ?
-         AND (task_id, role_name, turn_id, generation, progress_id) NOT IN (
-           SELECT task_id, role_name, turn_id, generation, progress_id FROM telemetry
-           WHERE task_id = ? AND role_name = ? AND turn_id = ? AND generation = ?
-           ORDER BY COALESCE(sequence, -1) DESC, received_at DESC, progress_id ASC
+       WHERE task_id = ? AND role_name = ? AND turn_id = ?
+         AND (task_id, role_name, turn_id, progress_id) NOT IN (
+           SELECT task_id, role_name, turn_id, progress_id FROM telemetry
+           WHERE task_id = ? AND role_name = ? AND turn_id = ?
+           ORDER BY received_at DESC, COALESCE(sequence, -1) DESC, progress_id ASC
            LIMIT ?
-         )`).run(taskId, roleName, turnId, generation, taskId, roleName, turnId, generation, keep);
+         )`).run(taskId, roleName, runId, taskId, roleName, runId, keep);
         return result.changes;
     }
-    capTurn(taskId, turnId, cap = this.#turnCap) {
+    capRun(taskId, runId, cap = this.#turnCap) {
         const db = this.#ensureDb();
         if (db === null)
             return 0;
         const result = db.prepare(`DELETE FROM telemetry
        WHERE task_id = ? AND turn_id = ?
-         AND (task_id, role_name, turn_id, generation, progress_id) NOT IN (
-           SELECT task_id, role_name, turn_id, generation, progress_id FROM telemetry
+         AND (task_id, role_name, turn_id, progress_id) NOT IN (
+           SELECT task_id, role_name, turn_id, progress_id FROM telemetry
            WHERE task_id = ? AND turn_id = ?
-           ORDER BY COALESCE(sequence, -1) DESC, received_at DESC, progress_id ASC
+           ORDER BY received_at DESC, COALESCE(sequence, -1) DESC, progress_id ASC
            LIMIT ?
-         )`).run(taskId, turnId, taskId, turnId, cap);
+         )`).run(taskId, runId, taskId, runId, cap);
         return result.changes;
     }
-    importGeneration(entries, aggregate) {
+    importRun(entries, aggregate) {
         const db = this.#ensureDb();
         if (db === null) {
             this.#dropped += entries.length;
             return;
         }
-        const upsert = db.prepare(`INSERT INTO telemetry (task_id, role_name, turn_id, generation, progress_id, sequence, payload, received_at)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-       ON CONFLICT(task_id, role_name, turn_id, generation, progress_id) DO UPDATE SET
+        const upsert = db.prepare(`INSERT INTO telemetry (task_id, role_name, turn_id, progress_id, sequence, payload, received_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(task_id, role_name, turn_id, progress_id) DO UPDATE SET
          sequence = excluded.sequence,
          payload = excluded.payload,
          received_at = excluded.received_at
-       WHERE COALESCE(excluded.sequence, -1) > COALESCE(telemetry.sequence, -1)
-          OR (excluded.sequence IS telemetry.sequence AND excluded.received_at >= telemetry.received_at)`);
+       WHERE excluded.received_at >= telemetry.received_at`);
         const upsertAggregate = db.prepare(`INSERT INTO telemetry_aggregate
-         (task_id, role_name, turn_id, generation, first_at, last_at, count, max_sequence, error_count, updated_at)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-       ON CONFLICT(task_id, role_name, turn_id, generation) DO UPDATE SET
+         (task_id, role_name, turn_id, first_at, last_at, count, max_sequence, error_count, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(task_id, role_name, turn_id) DO UPDATE SET
          first_at = excluded.first_at,
          last_at = excluded.last_at,
          count = excluded.count,
@@ -218,9 +215,9 @@ export class SqliteTelemetryStore {
          updated_at = excluded.updated_at`);
         db.transaction(() => {
             for (const entry of entries) {
-                upsert.run(entry.taskId, entry.roleName, entry.turnId, entry.generation, entry.progressId, entry.sequence ?? null, JSON.stringify(entry.payload), entry.receivedAt);
+                upsert.run(entry.taskId, entry.roleName, entry.runId, entry.progressId, entry.sequence ?? null, JSON.stringify(entry.payload), entry.receivedAt);
             }
-            upsertAggregate.run(aggregate.taskId, aggregate.roleName, aggregate.turnId, aggregate.generation, aggregate.firstAt, aggregate.lastAt, aggregate.count, aggregate.maxSequence, aggregate.errorCount, aggregate.lastAt);
+            upsertAggregate.run(aggregate.taskId, aggregate.roleName, aggregate.runId, aggregate.firstAt, aggregate.lastAt, aggregate.count, aggregate.maxSequence, aggregate.errorCount, aggregate.lastAt);
         })();
         this.#applied += entries.length;
     }
@@ -277,26 +274,25 @@ export class SqliteTelemetryStore {
         }
         const batch = new Map(this.#pending);
         this.#pending.clear();
-        const upsert = db.prepare(`INSERT INTO telemetry (task_id, role_name, turn_id, generation, progress_id, sequence, payload, received_at)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-       ON CONFLICT(task_id, role_name, turn_id, generation, progress_id) DO UPDATE SET
+        const upsert = db.prepare(`INSERT INTO telemetry (task_id, role_name, turn_id, progress_id, sequence, payload, received_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(task_id, role_name, turn_id, progress_id) DO UPDATE SET
          sequence = excluded.sequence,
          payload = excluded.payload,
          received_at = excluded.received_at
-       WHERE COALESCE(excluded.sequence, -1) > COALESCE(telemetry.sequence, -1)
-          OR (excluded.sequence IS telemetry.sequence AND excluded.received_at >= telemetry.received_at)`);
+       WHERE excluded.received_at >= telemetry.received_at`);
         try {
-            const touchedTurns = new Map();
+            const touchedRuns = new Map();
             db.transaction(() => {
                 for (const entry of batch.values()) {
-                    upsert.run(entry.taskId, entry.roleName, entry.turnId, entry.generation, entry.progressId, entry.sequence ?? null, JSON.stringify(entry.payload), entry.receivedAt);
-                    touchedTurns.set(`${entry.taskId}\0${entry.turnId}`, {
+                    upsert.run(entry.taskId, entry.roleName, entry.runId, entry.progressId, entry.sequence ?? null, JSON.stringify(entry.payload), entry.receivedAt);
+                    touchedRuns.set(`${entry.taskId}\0${entry.runId}`, {
                         taskId: entry.taskId,
-                        turnId: entry.turnId
+                        runId: entry.runId
                     });
                 }
-                for (const { taskId, turnId } of touchedTurns.values()) {
-                    this.capTurn(taskId, turnId);
+                for (const { taskId, runId } of touchedRuns.values()) {
+                    this.capRun(taskId, runId);
                 }
             })();
             this.#applied += batch.size;
@@ -308,25 +304,17 @@ export class SqliteTelemetryStore {
     }
 }
 function pendingKey(entry) {
-    return `${entry.taskId}\u0000${entry.roleName}\u0000${entry.turnId}\u0000${entry.generation}\u0000${entry.progressId}`;
+    return `${entry.taskId}\u0000${entry.roleName}\u0000${entry.runId}\u0000${entry.progressId}`;
 }
-/** True when `candidate` should replace `current` (sequence/receivedAt only move forward). */
+/** Transport counters may restart; the later recorded observation wins. */
 function isNewer(candidate, current) {
-    if (candidate.sequence !== undefined && current.sequence !== undefined) {
-        return candidate.sequence > current.sequence;
-    }
-    if (candidate.sequence !== undefined)
-        return true;
-    if (current.sequence !== undefined)
-        return false;
     return Date.parse(candidate.receivedAt) >= Date.parse(current.receivedAt);
 }
 function rowToEntry(row) {
     return {
         taskId: row.task_id,
         roleName: row.role_name,
-        turnId: row.turn_id,
-        generation: row.generation,
+        runId: row.turn_id,
         progressId: row.progress_id,
         ...(row.sequence === null ? {} : { sequence: row.sequence }),
         payload: JSON.parse(row.payload),
@@ -356,8 +344,7 @@ function mergeAggregates(rows) {
     return {
         taskId: rows[0].task_id,
         roleName,
-        turnId: rows[0].turn_id,
-        generation: "*",
+        runId: rows[0].turn_id,
         firstAt,
         lastAt,
         count,

package/dist/telemetry/telemetryConfig.js

@@ -6,34 +6,34 @@
  * never changes canonical runtime-state persistence. Retention defaults are
  * the schema's own constants (§4.4); the environment only overrides them.
  */
-import { TELEMETRY_KEEP_PER_GENERATION, TELEMETRY_TURN_CAP } from "../storage/sqliteSchema.js";
+import { TELEMETRY_KEEP_PER_RUN, TELEMETRY_RUN_CAP } from "../storage/sqliteSchema.js";
 export const DEFAULT_TELEMETRY_MODE = "off";
-/** Terminal Turn/generation progress rows retained after prune. */
-export const DEFAULT_TERMINAL_KEEP = TELEMETRY_KEEP_PER_GENERATION;
-/** Hard cap of progress rows per Turn while it is still active. */
-export const DEFAULT_TURN_CAP = TELEMETRY_TURN_CAP;
+/** Terminal AgentRun progress rows retained after prune. */
+export const DEFAULT_TERMINAL_KEEP = TELEMETRY_KEEP_PER_RUN;
+/** Hard cap of progress rows per AgentRun while it is still active. */
+export const DEFAULT_RUN_CAP = TELEMETRY_RUN_CAP;
 /**
- * Absolute ceiling for the configurable Turn cap. Retention can be tuned but
+ * Absolute ceiling for the configurable AgentRun cap. Retention can be tuned but
  * never disabled: every Home keeps a computable upper bound on telemetry
- * rows (Tasks × Turns × cap).
+ * rows (Tasks × AgentRuns × cap).
  */
-export const MAX_TURN_CAP = 10_000_000;
+export const MAX_RUN_CAP = 10_000_000;
 /**
- * Resolve the terminal-Turn retention window from the durable config value
+ * Resolve the terminal-AgentRun retention window from the durable config value
  * (default 200). Must be a positive integer.
  */
 export function resolveTerminalKeep(value) {
     return resolvePositiveInteger(value, DEFAULT_TERMINAL_KEEP, "telemetryTerminalKeep");
 }
 /**
- * Resolve the active-Turn hard cap from the durable config value (default
+ * Resolve the active-AgentRun hard cap from the durable config value (default
  * 50,000). Must be a positive integer not exceeding {@link MAX_TURN_CAP};
  * the cap cannot be disabled.
  */
-export function resolveTurnCap(value) {
-    const cap = resolvePositiveInteger(value, DEFAULT_TURN_CAP, "telemetryTurnCap");
-    if (cap > MAX_TURN_CAP) {
-        throw new TypeError(`telemetryTurnCap must not exceed ${MAX_TURN_CAP.toLocaleString("en-US")} (retention cannot be disabled).`);
+export function resolveRunCap(value) {
+    const cap = resolvePositiveInteger(value, DEFAULT_RUN_CAP, "telemetryRunCap");
+    if (cap > MAX_RUN_CAP) {
+        throw new TypeError(`telemetryTurnCap must not exceed ${MAX_RUN_CAP.toLocaleString("en-US")} (retention cannot be disabled).`);
     }
     return cap;
 }

package/dist/telemetry/telemetryWiring.js

@@ -1,6 +1,6 @@
 import { existsSync } from "node:fs";
 import { join } from "node:path";
-import { resolveTurnCap, resolveTerminalKeep } from "./telemetryConfig.js";
+import { resolveRunCap, resolveTerminalKeep } from "./telemetryConfig.js";
 import { resolveTelemetryEnabled } from "../config/yuiConfig.js";
 import { SqliteTelemetryStore } from "./sqliteTelemetryStore.js";
 import { CURRENT_DATABASE_FILENAME as COMMITTED_DATABASE_FILENAME } from "../storage/currentTaskStore.js";
@@ -22,7 +22,7 @@ export function openSchedulerTelemetry(home, config) {
     const store = new SqliteTelemetryStore(home, {
         mode,
         terminalKeep: resolveTerminalKeep(config.telemetryTerminalKeep),
-        turnCap: resolveTurnCap(config.telemetryTurnCap)
+        runCap: resolveRunCap(config.telemetryRunCap)
     });
     return { mode, sink: store, reader: store, retention: store };
 }

package/dist/web/assets/assetManifest.js

@@ -8,6 +8,7 @@ import { I18N_SCRIPT } from "./client/i18n.js";
 import { MARKDOWN_SCRIPT } from "./client/markdown.js";
 import { THEME_SCRIPT } from "./client/theme.js";
 import { VIEW_SCRIPT } from "./client/view.js";
+import { TASK_SURFACE_SCRIPT } from "./client/taskSurface.js";
 import { DASHBOARD_HTML } from "./shell.js";
 import { FONT_FACE_STYLES } from "./fonts.js";
 import { FONT_WOFF2_BASE64 } from "./fontData.js";
@@ -33,6 +34,7 @@ export const WEB_ASSETS = Object.freeze({
     "/assets/js/theme.js": { contentType: "text/javascript; charset=utf-8", body: THEME_SCRIPT },
     "/assets/js/components.js": { contentType: "text/javascript; charset=utf-8", body: COMPONENTS_SCRIPT },
     "/assets/js/view.js": { contentType: "text/javascript; charset=utf-8", body: VIEW_SCRIPT },
+    "/assets/js/task-surface.js": { contentType: "text/javascript; charset=utf-8", body: TASK_SURFACE_SCRIPT },
     "/assets/app.js": { contentType: "text/javascript; charset=utf-8", body: APP_SCRIPT },
     ...fontAssets(),
     "/assets/vendor/xterm.mjs": vendorAsset("@xterm/xterm/lib/xterm.mjs", "text/javascript; charset=utf-8"),

package/dist/web/assets/client/app.js

@@ -47,9 +47,10 @@ const state = {
   detail: null,
   detailKey: null
 };
-const VALID_FILTERS = ["all", "active", "draft", "completed", "retired", "archived"];
+const VALID_FILTERS = ["all", "active", "draft", "completed", "cancelled", "archived"];
 let terminalSession = null;
 let terminalStateKey = "terminal.closed";
+const submittedRequests = new Set();
 
 const i18n = createI18n(elements.locale);
 createThemeController(elements.theme);
@@ -125,7 +126,18 @@ function syncUrlFromState(options) {
 function detailActions() {
   return {
     answerInput: answerInput,
-    openTerminal: openTerminal
+    openTerminal: openTerminal,
+    inspect: inspectRecord,
+    sendMessage: (taskId, body, requestId) => submitMutation(taskId + "/messages",
+      "/api/tasks/" + encodeURIComponent(taskId) + "/messages", { body, requestId }),
+    updateTask: (taskId, patch, requestId) => submitMutation(taskId + "/metadata",
+      "/api/tasks/" + encodeURIComponent(taskId) + "/metadata", { patch, requestId }),
+    panels: (taskId) => requestJson("/api/tasks/" + encodeURIComponent(taskId) + "/panels",
+      { signal: AbortSignal.timeout(3000) }),
+    readPanel: (taskId, ref, input) => requestJson("/api/tasks/" + encodeURIComponent(taskId) + "/panels", {
+      method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ ref, input }),
+      signal: AbortSignal.timeout(3000)
+    })
   };
 }
 
@@ -171,9 +183,30 @@ function detailKeyOf(detail) {
   return text.length + ":" + hash;
 }
 
+// The optional observation arrives after the core snapshot has already been
+// rendered, so the render key has to cover the observed facts the detail
+// actually draws or they would stay stale until the core snapshot changed.
+// Only the rendered identity is included: observation timestamps advance on
+// every poll and would re-render the detail continuously.
+function runtimeSignatureOf(detail) {
+  const roles = (detail.runtime && detail.runtime.roles) || [];
+  return detail.runtimeStatus + "|" + roles.map(function (role) {
+    const session = role.runtimeSession;
+    return role.name + ":" + (session
+      ? session.nativeSessionId + "/" + session.status
+      : "-");
+  }).join(",");
+}
+
 function renderCurrentDetail(force) {
   if (state.detail) {
-    const key = i18n.getLocale() + "|" + state.detailKey;
+    // Polling must not replace an unsent draft or an in-flight form, including
+    // after the user has moved focus. This is view state, never Task state.
+    if (elements.detail.dataset.taskId === state.detail.task.id
+      && (elements.detail.querySelector('[data-unsent="true"]')
+        || elements.detail.contains(document.activeElement))) return;
+    const key = i18n.getLocale() + "|" + state.detailKey
+      + "|" + runtimeSignatureOf(state.detail);
     if (!force && key === renderedDetailKey) return;
     renderTaskDetail(
       elements.detail,
@@ -275,31 +308,76 @@ async function requestJson(path, options) {
     ...options,
     headers: {
       accept: "application/json",
+      "x-yui-web-token": token,
       ...(options && options.headers ? options.headers : {})
     }
   });
   if (!response.ok) {
     let message = "HTTP " + response.status;
+    let disposition = "unknown";
     try {
       const body = await response.json();
       if (body && body.error) message = body.error;
+      if (body && body.disposition === "not-submitted") disposition = "not-submitted";
     } catch {}
-    throw new Error(message);
+    throw Object.assign(new Error(message), { disposition });
   }
   return response.json();
 }
 
+async function submitMutation(key, path, body) {
+  if (submittedRequests.has(key)) throw new Error("An earlier submission is unresolved; read current facts.");
+  submittedRequests.add(key);
+  try {
+    const receipt = await requestJson(path, {
+      method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(body)
+    });
+    submittedRequests.delete(key);
+    return receipt;
+  } catch (error) {
+    if (error.disposition === "not-submitted") submittedRequests.delete(key);
+    throw error;
+  }
+}
+
 async function loadTaskDetail(taskId, showLoading) {
   if (showLoading) {
     renderLoading(elements.detail, i18n.t, "loading.detail");
     elements.mainCol.scrollTop = 0;
   }
   const savedScrollTop = showLoading ? 0 : elements.mainCol.scrollTop;
-  const detail = await requestJson("/api/tasks/" + encodeURIComponent(taskId));
+  const base = "/api/tasks/" + encodeURIComponent(taskId);
+  // Rendering consumes the current snapshot, not event pages. Reconnect uses
+  // this same read; the independent delta API retains its fixed-bound contract.
+  const core = await requestJson(base + "/context");
+  const taskEntry = core.records.find(function (entry) { return entry.ref.store === "task"; });
+  if (!taskEntry) throw new Error("Task reference unavailable.");
+  const task = taskEntry.omitted ? (await inspectRecord(taskId, taskEntry.ref)).value : taskEntry.value;
+  const previous = state.detail && state.detail.task.id === taskId ? state.detail : null;
+  const detail = {
+    task, core,
+    runtime: previous && previous.runtime,
+    runtimeStatus: previous ? previous.runtimeStatus : "waiting",
+    runtimeObservedAt: previous ? previous.runtimeObservedAt : new Date().toISOString()
+  };
   if (state.selected !== taskId) return;
   state.detail = detail;
-  state.detailKey = detailKeyOf(detail);
-  renderCurrentDetail(true);
+  state.detailKey = detailKeyOf(core);
+  renderCurrentDetail();
+  // Optional observation does not participate in core readiness or cursor.
+  void requestJson(base, { signal: AbortSignal.timeout(1000) }).then(function (runtime) {
+    if (state.detail !== detail) return;
+    detail.runtime = runtime;
+    detail.runtimeStatus = "available";
+    detail.runtimeObservedAt = new Date().toISOString();
+    updateRuntimePanel(detail);
+  }).catch(function () {
+    if (state.detail !== detail) return;
+    detail.runtime = null;
+    detail.runtimeStatus = "unavailable";
+    detail.runtimeObservedAt = new Date().toISOString();
+    updateRuntimePanel(detail);
+  });
   // Reveal the tab bar before measuring/scroll so anchors land correctly.
   setDetailActive(true);
   updateStickyOffsets();
@@ -314,6 +392,25 @@ async function loadTaskDetail(taskId, showLoading) {
   syncTabHighlight();
 }
 
+function updateRuntimePanel(detail) {
+  const status = elements.detail.querySelector("[data-runtime-status]");
+  const value = elements.detail.querySelector("[data-runtime-value]");
+  if (status) status.textContent = detail.runtimeStatus + " · " + detail.runtimeObservedAt;
+  if (value) value.textContent = detail.runtime
+    ? JSON.stringify({ roles: detail.runtime.roles, runtimeHealth: detail.runtime.runtimeHealth }, null, 2)
+    : "";
+  // Patching the panel in place is not enough: the observation also feeds facts
+  // the detail rendered before it arrived. Re-render when the observed identity
+  // has actually changed — renderCurrentDetail still compares the render key,
+  // so an unchanged observation costs nothing and an unsent form is preserved.
+  if (state.detail === detail) renderCurrentDetail();
+}
+
+async function inspectRecord(taskId, ref) {
+  const query = new URLSearchParams({ store: ref.store, ref: ref.refId, digest: ref.digest });
+  return requestJson("/api/tasks/" + encodeURIComponent(taskId) + "/inspect?" + query);
+}
+
 async function selectTask(taskId) {
   // Switching tasks drops the previous section; staying on the same task
   // (URL-driven loads, popstate) keeps it.
@@ -345,27 +442,27 @@ async function selectTask(taskId) {
 async function answerInput(input, answer) {
   if (!state.detail) return;
   const taskId = state.detail.task.id;
+  const key = taskId + "/input/" + input.id;
   try {
-    await requestJson(
+    await submitMutation(key,
       "/api/tasks/" + encodeURIComponent(taskId)
         + "/inputs/" + encodeURIComponent(input.id) + "/answer",
-      {
-        method: "POST",
-        headers: {
-          "content-type": "application/json",
-          "x-yui-web-token": token
-        },
-        body: JSON.stringify(answer)
-      }
+      answer
     );
     showToast(i18n.t("input.answered"));
+    submittedRequests.delete(key);
     await refreshDashboard({ quiet: true });
-  } catch {
-    showToast(i18n.t("errors.answer"));
+  } catch (error) {
+    showToast(error.disposition === "not-submitted" ? error.message : i18n.getLocale().startsWith("zh")
+      ? "回答结果未知；请刷新检查原问题，不要盲目重发。"
+      : "Answer outcome unknown; refresh the original question before resubmitting.");
   }
 }
 
+let refreshing = false;
 async function refreshDashboard(options) {
+  if (refreshing) return;
+  refreshing = true;
   const quiet = options && options.quiet;
   if (!quiet) {
     elements.refresh.disabled = true;
@@ -386,8 +483,10 @@ async function refreshDashboard(options) {
     if (previousInputs !== null && dashboard.counts.openInputs > previousInputs) {
       showToast(i18n.t("input.new"));
     }
-    if (state.selected && !quiet) {
-      try { await loadTaskDetail(state.selected, false); } catch {}
+    if (state.selected) {
+      try { await loadTaskDetail(state.selected, false); } catch {
+        showToast(i18n.getLocale().startsWith("zh") ? "连接不可用；保留上次读取。" : "Disconnected; showing the last read.");
+      }
     }
   } catch {
     if (!quiet) {
@@ -395,6 +494,7 @@ async function refreshDashboard(options) {
       showToast(i18n.t("errors.dashboard"));
     }
   } finally {
+    refreshing = false;
     if (!quiet) elements.refresh.disabled = false;
   }
 }