@zq-silk/yui 2.17.0 → 2.18.0

package/dist/storage/storeRpc.js

@@ -20,7 +20,8 @@
  * SQLite is the only product Store. `YUI_STORE_WORKER` selects the observer
  * execution boundary; it does not select another authority.
  */
-import { BoundedRpcClient, nextRequestId } from "../core/boundedRpc.js";
+import { BoundedRpcClient, deserializeError as deserializeRpcError, nextRequestId } from "../core/boundedRpc.js";
+import { ControllerWorkObserver } from "../core/controllerTelemetry.js";
 import { StorageCancelledError, StorageConflictError, StorageRecordError } from "./taskStore.js";
 // -- Read-only classification ------------------------------------------------
 /**
@@ -37,6 +38,8 @@ const READ_ONLY_STORE_METHODS = new Set([
     "getHomeIdentity",
     "getReviewConfig",
     "getRevision",
+    "getStateRevision",
+    "getTaskReadRevision",
     "listConfiguredAgents",
     "getConfiguredAgent",
     "listProjects",
@@ -57,6 +60,7 @@ const READ_ONLY_STORE_METHODS = new Set([
     "queryTaskSearch",
     "latestEventSequence",
     "listEventsByType",
+    "hasRuntimeObservation",
     "readTaskUsageFacts",
     "listTaskRunWorkspaceBases",
     "contextInputReferences",
@@ -72,6 +76,7 @@ const READ_ONLY_STORE_METHODS = new Set([
     "listActiveDurableJobs",
     "getJobDefinition",
     "listJobDefinitions",
+    "listJobScopeSummaries",
     "getGlobalJobRun",
     "getAgentJobRun",
     "listAgentJobRuns",
@@ -137,12 +142,10 @@ function deserializeError(serialized) {
     if (name === "StorageCancelledError" || name === "AbortError") {
         return new StorageCancelledError(message);
     }
-    const error = new Error(message);
-    error.name = name;
-    return error;
+    return deserializeRpcError(serialized);
 }
 // -- Storage protocol adapter -------------------------------------------------
-function storageProtocol(home, options) {
+function storageProtocol(home, options, observe) {
     return {
         initRequest: () => ({
             kind: "init",
@@ -162,6 +165,8 @@ function storageProtocol(home, options) {
             return response.requestId;
         },
         settle: (response, settlement) => {
+            if (response.observation !== undefined)
+                observe(response.observation);
             if (response.kind === "result") {
                 settlement.resolve(response.result);
                 return;
@@ -188,8 +193,17 @@ function storageProtocol(home, options) {
  */
 export class AsyncTaskStoreClient {
     #rpc;
+    #waits = new ControllerWorkObserver();
+    #worker = null;
+    /** Cached observations only: status never waits on a busy persistence worker. */
+    observationMetrics() {
+        return { roundTrips: this.#waits.snapshot(), worker: this.#worker,
+            inFlight: this.inFlight, queueDepth: this.queueDepth };
+    }
     constructor(home, options = {}) {
-        this.#rpc = new BoundedRpcClient(storageProtocol(home, options), {
+        this.#rpc = new BoundedRpcClient(storageProtocol(home, options, observation => {
+            this.#worker = observation;
+        }), {
             maxInFlight: options.maxInFlight,
             maxQueue: options.maxQueue,
             workerScript: options.workerScript ?? new URL("./persistenceWorker.js", import.meta.url)
@@ -198,13 +212,13 @@ export class AsyncTaskStoreClient {
     /** Invoke a TaskStore method over the RPC (used by the Proxy). */
     callStore(method, args, options) {
         const requestId = options?.requestId ?? nextRequestId();
-        return this.#rpc.send(requestId, {
+        return this.#waits.observe("store-call", requestId, () => this.#rpc.send(requestId, {
             kind: "call",
             requestId,
             method,
             args,
             readOnly: isReadOnlyMethod(method)
-        }, { signal: options?.signal });
+        }, { signal: options?.signal }));
     }
     /** Run a command batch atomically in the worker (§3.2). */
     transactionAsync(commands, options) {
@@ -213,12 +227,12 @@ export class AsyncTaskStoreClient {
             op: command.op,
             args: command.args
         }));
-        return this.#rpc.send(requestId, {
+        return this.#waits.observe("store-transaction", requestId, () => this.#rpc.send(requestId, {
             kind: "transaction",
             requestId,
             commands: wireCommands,
             ...(options?.expectedRevision === undefined ? {} : { expectedRevision: options.expectedRevision })
-        }, { signal: options?.signal });
+        }, { signal: options?.signal }));
     }
     /**
      * Invoke a controller observer method hosted by the worker (the
@@ -227,7 +241,7 @@ export class AsyncTaskStoreClient {
      */
     invokeObserver(method, args, options) {
         const requestId = options?.requestId ?? nextRequestId();
-        return this.#rpc.send(requestId, { kind: "observer", requestId, method, args }, { signal: options?.signal });
+        return this.#waits.observe("store-observer", requestId, () => this.#rpc.send(requestId, { kind: "observer", requestId, method, args }, { signal: options?.signal }));
     }
     /** Close the worker and release its connections. */
     close() {

package/dist/storage/taskReadRevisionSchema.js

@@ -0,0 +1,39 @@
+/** Storage 1.24 definition: immutable once published. These are cache tokens,
+ * not a second Task state or a CAS/authorization source. Triggers cover every
+ * source family, including direct SQL, deletions and rolled-back transactions.
+ */
+export const TASK_READ_REVISION_SOURCES = [
+    "events", "turns", "work_items", "review_rounds", "change_sets",
+    "integration_attempts", "input_requests", "durable_jobs", "messages"
+];
+export const TASK_READ_REVISION_SCHEMA_SQL = `
+CREATE TABLE task_read_revisions (
+  task_id TEXT PRIMARY KEY,
+  revision INTEGER NOT NULL
+);
+CREATE INDEX idx_runtime_observation_semantic
+  ON events(task_id, json_extract(payload, '$.payload.semanticKey'))
+  WHERE type = 'runtime.observation';
+CREATE INDEX idx_runtime_observation_event
+  ON events(task_id, json_extract(payload, '$.payload.eventId'))
+  WHERE type = 'runtime.observation';
+${TASK_READ_REVISION_SOURCES.map(table => `
+CREATE TRIGGER ${table}_read_ai AFTER INSERT ON ${table}
+BEGIN
+  INSERT INTO task_read_revisions VALUES (NEW.task_id, 1)
+  ON CONFLICT(task_id) DO UPDATE SET revision = revision + 1;
+END;
+CREATE TRIGGER ${table}_read_ad AFTER DELETE ON ${table}
+BEGIN
+  INSERT INTO task_read_revisions VALUES (OLD.task_id, 1)
+  ON CONFLICT(task_id) DO UPDATE SET revision = revision + 1;
+END;
+CREATE TRIGGER ${table}_read_au AFTER UPDATE ON ${table}
+BEGIN
+  INSERT INTO task_read_revisions VALUES (NEW.task_id, 1)
+  ON CONFLICT(task_id) DO UPDATE SET revision = revision + 1;
+  INSERT INTO task_read_revisions
+    SELECT OLD.task_id, 1 WHERE OLD.task_id != NEW.task_id
+  ON CONFLICT(task_id) DO UPDATE SET revision = revision + 1;
+END;
+`).join("")}`;

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

@@ -111,10 +111,6 @@ function renderSidebar(deps, progress) {
     reset(deps, progress);
   });
   el.catalogCount.textContent = fill(t("catalog.count"), { shown: state.tasks.length, total: state.catalogTotal });
-  renderSource(el.source, state, t, function (value) {
-    state.source = value; state.attentionFilter = null; state.query = ""; el.search.value = "";
-    syncUrl(state, false); reset(deps, progress);
-  });
   el.catalogReset.hidden = !state.catalogCursor;
   el.catalogNext.hidden = !state.nextCursor && !state.catalogCursor;
   el.catalogAttentionReset.hidden = !state.attentionFilter;
@@ -122,27 +118,6 @@ function renderSidebar(deps, progress) {
   el.lastSync.textContent = state.generatedAt ? formatClock(state.generatedAt, deps.locale()) : "—";
 }
 
-// Task category: search and attention are cross-category, so they show "all";
-// picking a category clears them, as the server filter then applies again.
-function renderSource(container, state, t, onPick) {
-  const current = state.query.trim() || state.attentionFilter ? "all" : state.source || "ordinary";
-  // Bound once; the handler reads the live state, not this render's snapshot.
-  if (!container.childElementCount) {
-    ["ordinary", "job", "all"].forEach(function (value) {
-      container.append(h("button.seg-btn", { type: "button", role: "radio", dataset: { source: value },
-        onclick: function () {
-          if (value !== (state.source || "ordinary") || state.query.trim() || state.attentionFilter) onPick(value);
-        } }));
-    });
-  }
-  container.querySelectorAll("[data-source]").forEach(function (button) {
-    const value = button.dataset.source;
-    button.textContent = t("jobs.categoryShort." + value);
-    button.title = t("jobs.category." + value);
-    button.setAttribute("aria-checked", String(value === current));
-  });
-}
-
 // Redraw the list in place, keeping its scroll position.
 function renderTaskList(deps) {
   const scroll = deps.el.tasks.scrollTop;
@@ -175,9 +150,6 @@ function catalogQuery(state) {
   if (state.filter !== "all") query.set("status", state.filter);
   if (state.query.trim()) query.set("search", state.query.trim());
   if (state.attentionFilter) query.set("attention", state.attentionFilter);
-  // Search and attention remain cross-category discovery; the server owns filtering.
-  if (!state.query.trim() && !state.attentionFilter && state.source !== "all")
-    query.set("source", state.source || "ordinary");
   if (state.catalogCursor) query.set("cursor", state.catalogCursor);
   return query.toString();
 }
@@ -233,7 +205,6 @@ function applyFilters(deps, params) {
   state.query = params.get("q") || "";
   state.attentionFilter = ATTENTION_KINDS.includes(params.get("attention")) ? params.get("attention") : null;
   state.catalogAll = params.get("all") === "true";
-  state.source = ["ordinary", "job", "all"].includes(params.get("source")) ? params.get("source") : "ordinary";
   deps.el.search.value = state.query;
 }
 

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

@@ -0,0 +1,115 @@
+export const JOBS_APP_SCRIPT = String.raw `
+import { h, icon } from "/assets/js/lib/dom.js";
+import { formatClock } from "/assets/js/lib/format.js";
+import { requestJson } from "/assets/js/lib/api.js";
+import { i18n, registerManagePage, navigateManage, replaceManageRoute, pushManageRoute } from "/assets/js/layout/manageShell.js";
+import { mountJobs } from "/assets/js/views/jobs.js";
+
+// The Jobs entry: one shared Job module (the same one the Task page uses)
+// over exactly one scope at a time, global or one owning Task. The scope,
+// the selected Job and Run live in the URL, so deep links, refresh and
+// Back/Forward all reopen the same view. One view is live at a time: a
+// replaced view is retired, so its late reads cannot write this page.
+const t = i18n.t;
+const root = document.querySelector("#jobs-root");
+const index = document.querySelector("#jobs-index");
+const scopeSelect = h("select", { id: "jobs-scope", "aria-describedby": "jobs-scope-help" });
+const scopeLabel = h("label", { for: "jobs-scope" });
+const scopeHelp = h("p.jobs-scope-help", { id: "jobs-scope-help" });
+const listMount = h("div.jobs-index-body");
+// The list head works as on the workbench: one primary "new" action at the
+// top of the list (creating in the selected scope), the last read time and
+// a refresh control in the head. The page itself carries no second title.
+const createLabel = h("span");
+const create = h("button.btn.btn-primary.side-create", { id: "jobs-create", type: "button",
+  onclick: () => { if (view) view.create(); } }, icon("plus"), createLabel);
+const sync = document.querySelector("#jobs-sync");
+const lastSync = document.querySelector("#jobs-last-sync");
+const refreshButton = document.querySelector("#jobs-refresh");
+if (refreshButton) refreshButton.addEventListener("click", () => { if (view && !view.isBusy()) void view.refresh(); });
+index.replaceChildren(create, h("div.jobs-scope", null, scopeLabel, scopeSelect, scopeHelp), listMount);
+let route = null, view = null, mountedScope, scopes = null, scopesError = null;
+
+scopeSelect.addEventListener("change", () => {
+  const task = scopeSelect.value || null;
+  if ((route && route.task) === task) return;
+  if (!navigateManage({ page: "jobs", section: "jobs", task })) drawScopes();
+});
+
+function drawScopes() {
+  createLabel.textContent = t("jobs.newJob");
+  create.title = t("jobs.newJobIn") + " · " + (route && route.task ? route.task : t("jobs.ownerGlobal"));
+  scopeLabel.textContent = t("jobs.scopeLabel");
+  scopeHelp.textContent = scopesError ? t("jobs.scopesError") + " " + scopesError : t("jobs.scopeHelp");
+  scopeHelp.classList.toggle("is-error", !!scopesError);
+  const current = route ? route.task : null;
+  const tasks = scopes ? scopes.tasks.slice() : [];
+  // A deep-linked Task stays selectable even when it has no Job yet.
+  if (current && !tasks.some(item => item.taskId === current)) tasks.unshift({ taskId: current, title: "" });
+  scopeSelect.replaceChildren(h("option", { value: "" }, t("jobs.ownerGlobal")),
+    ...tasks.map(item => h("option", { value: item.taskId }, item.taskId + (item.title ? " · " + item.title : ""))));
+  scopeSelect.value = current || "";
+}
+async function loadScopes() {
+  try { scopes = await requestJson("/api/jobs/scopes"); scopesError = null; }
+  catch (error) { scopesError = error.message; }
+  drawScopes();
+}
+function mount(next) {
+  if (view) view.dispose();
+  mountedScope = next.task || null;
+  let self = null;
+  self = view = mountJobs(root, t, mountedScope || undefined, {
+    index: listMount,
+    navigate: selection => navigateManage({ ...route, job: selection.job, jobRun: null, artifact: null, moved: undefined }),
+    pin: (selection, step) => pin(self, selection, step),
+    sync: observation => observe(self, observation),
+    notice: next.moved ? t("jobs.moved") : "",
+    locale: i18n.getLocale
+  });
+}
+// The last read of the live view, in the list head (as the workbench's sync).
+function observe(owner, observation) {
+  if (owner !== view || !sync) return;
+  sync.dataset.state = observation.state;
+  if (observation.at) lastSync.textContent = formatClock(observation.at, i18n.getLocale());
+  sync.title = observation.text;
+}
+// Only the live view, while Jobs is the shown page, records its selection.
+// A Run the reader opened or closed in place is a history step; anything else
+// the view settles on refines the current entry.
+function pin(owner, selection, step) {
+  if (owner !== view || root.hidden || !route || route.page !== "jobs") return;
+  route = { ...route, ...selection, moved: undefined };
+  if (step) pushManageRoute(route); else replaceManageRoute(route);
+}
+function show(next) {
+  route = next;
+  drawScopes();
+  if (!view || mountedScope !== (next.task || null)) mount(next);
+  else { view.resume(); view.select(next.job, next.jobRun, next.artifact); }
+}
+// Leaving Jobs sets a modal editor aside (its draft is kept for the return).
+function hide() { if (view) view.suspend(); }
+// Asked before any route change that leaves or enters Jobs, whatever its
+// source. Leaving Jobs keeps its view (hidden) as it is; a change of scope or
+// Job replaces the editor, so a draft needs confirmation; while a write is in
+// flight the selection stays put so its receipt remains observable.
+function canNavigate(next) {
+  if (!view || next.page !== "jobs" || !route) return true;
+  const same = key => (next[key] || null) === (route[key] || null);
+  if ((next.task || null) === mountedScope && same("job") && same("jobRun") && same("artifact")) return true;
+  if (view.isBusy() && root.hidden) { window.alert(t("jobs.leaveBusy")); return false; }
+  return view.leave((next.task || null) !== mountedScope || !same("job"));
+}
+registerManagePage("jobs", { show, hide, canNavigate, crumb: () => route && route.task ? route.task : t("jobs.ownerGlobal") });
+void loadScopes();
+i18n.subscribe(() => {
+  drawScopes();
+  if (route && route.page === "jobs" && view && !view.isDirty() && !view.isBusy()) mount({ ...route, moved: false });
+});
+window.addEventListener("beforeunload", event => {
+  if (!view || !view.isDirty()) return;
+  event.preventDefault(); event.returnValue = "";
+});
+`;

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

@@ -18,7 +18,7 @@ export const APP_SCRIPT = String.raw `
 //   refresh  catalog.refresh → sidebar, then the overview (nothing selected)
 //            or selection.reload → taskView.render
 //   select   sidebar row / overview row / URL → selection.selectTask
-//   leave    rail Workbench or Escape → selection.clearSelection
+//   leave    rail Tasks or Escape → selection.clearSelection
 //   write    Task page or discussion afterWrite → quiet catalog refresh
 //   URL      load and back/forward → catalog.applyFilters + selection.followUrl
 import { createI18n } from "/assets/js/lib/i18n.js";
@@ -30,7 +30,7 @@ import { createPreviewController } from "/assets/js/views/dock/preview.js";
 import { bindGlobalInput } from "/assets/js/views/globalInput.js";
 import { bindCreateTask } from "/assets/js/views/createTask.js";
 import { bindBodySearch } from "/assets/js/views/bodySearch.js";
-import { readQuery } from "/assets/js/layout/router.js";
+import { readQuery, applyUrl } from "/assets/js/layout/router.js";
 import { rememberPlace, linkPlaces, readSessionAccessMode } from "/assets/js/lib/prefs.js";
 import { createWorkspace } from "/assets/js/layout/workspace.js";
 import { createSidebarNav } from "/assets/js/layout/sidebarNav.js";
@@ -43,7 +43,7 @@ const $ = function (selector) { return document.querySelector(selector); };
 const el = {
   sidebar: $(".sidebar"), rail: $(".app-rail"), railWorkbench: $("#rail-workbench"),
   sidebarScrim: $("#sidebar-scrim"), sidebarCollapse: $("#sidebar-collapse"), sidebarDivider: $("#sidebar-divider"), center: $("#center"), detail: $("#detail"),
-  search: $("#search"), source: $("#catalog-source"), filters: $("#status-filters"), attention: $("#attention-bar"), tasks: $("#task-list"),
+  search: $("#search"), filters: $("#status-filters"), attention: $("#attention-bar"), tasks: $("#task-list"),
   catalogNext: $("#catalog-next"), catalogReset: $("#catalog-reset"), catalogCount: $("#catalog-count"),
   catalogAttentionReset: $("#catalog-attention-reset"),
   refresh: $("#refresh"), sync: $("#sync-state"), lastSync: $("#last-sync"), toast: $("#toast"),
@@ -119,11 +119,11 @@ bindShortcuts({
   el: el, state: state, globalInput: globalInput, workspace: workspace, sidebarNav: sidebarNav,
   selection: selection, catalog: catalog, taskView: taskView
 });
-// Workbench <-> Models/Settings: each side remembers where the user was, so a
+// Tasks <-> Jobs/Models/Settings: each side remembers where the user was, so a
 // round trip returns to the same filters, Task and management section.
 function rememberWorkbench() { rememberPlace("workbench", window.location.pathname + window.location.search); }
 el.rail.querySelectorAll("a[data-nav-area]").forEach(function (link) { link.addEventListener("click", rememberWorkbench); });
-// The rail's Workbench entry on the workbench itself returns to the overview.
+// The rail's Tasks entry on the Task workbench itself returns to the overview.
 el.railWorkbench.addEventListener("click", function (event) {
   if (event.button !== 0 || event.metaKey || event.ctrlKey || event.shiftKey || event.altKey) return;
   event.preventDefault();
@@ -135,9 +135,20 @@ function linkAll() { linkPlaces(el.rail); linkPlaces(el.sidebar); }
 window.addEventListener("pageshow", linkAll);
 linkAll();
 
+// The retired Task category filter (?source=ordinary|job|all): the Task
+// list now always shows every real Task, so drop the parameter in place
+// (no extra history step) and say why once; Jobs have their own entry.
+let sourceHinted = false;
+function stripRetiredSource(params) {
+  if (!params.has("source")) return params;
+  params.delete("source");
+  applyUrl(params, true);
+  if (!sourceHinted) { sourceHinted = true; toast(t("catalog.sourceRemoved")); }
+  return params;
+}
 // The URL names the catalog filters and the selected Task (with its section).
 function applyStateFromUrl() {
-  const params = readQuery();
+  const params = stripRetiredSource(readQuery());
   catalog.applyFilters(params);
   selection.followUrl(params);
 }

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

@@ -1,6 +1,7 @@
 export const MANAGE_SCRIPT = String.raw `
 import "/assets/js/app/settings.js";
 import "/assets/js/app/models.js";
+import "/assets/js/app/jobs.js";
 import { startManagement } from "/assets/js/layout/manageShell.js";
 import { createSidebarNav } from "/assets/js/layout/sidebarNav.js";
 import { isEditing } from "/assets/js/lib/dom.js";

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

@@ -8,7 +8,6 @@ import { createThemeController } from "/assets/js/lib/theme.js";
 import { clearPreference, readSessionAccessMode, writeSessionAccessMode } from "/assets/js/lib/prefs.js";
 import { i18n, createManageShell, pageSections, registerManagePage, navigateManage } from "/assets/js/layout/manageShell.js";
 import { mountSkills } from "/assets/js/views/skills.js";
-import { mountJobs } from "/assets/js/views/jobs.js";
 import { mountPermissions } from "/assets/js/views/permissions.js";
 
 const $ = selector => document.querySelector(selector);
@@ -20,14 +19,12 @@ function readSection() {
   return SECTIONS.includes(section) ? section : SECTIONS[0];
 }
 let section = readSection();
-let jobs;
 let permissions;
 const shell = createManageShell({ page: "settings", t, onNavigate: navigate });
 function showSection(next) {
   section = next;
   document.querySelectorAll("#settings-root > .manage-section[data-section]").forEach(panel => { panel.hidden = panel.dataset.section !== next; });
   shell.set(next);
-  if (next === "jobs" && !jobs) jobs = mountJobs($("#global-jobs"), t);
   if (next === "permissions" && !permissions) permissions = mountPermissions($("#permission-browser"), t);
 }
 function navigate(next) {
@@ -41,7 +38,6 @@ function markDirty(name, value) {
 registerManagePage("settings", { show: next => showSection(next.section) });
 i18n.subscribe(() => shell.render());
 i18n.subscribe(() => {
-  if (jobs && !jobs.isDirty() && !jobs.isBusy()) jobs = mountJobs($("#global-jobs"), t);
   permissions?.translate();
 });
 showSection(section);
@@ -69,7 +65,7 @@ let searchTimer;
 const more = h("button.btn", { type: "button", hidden: true }, t("settings.more"));
 container.after(more);
 window.addEventListener("beforeunload", event => {
-  if (!groups.some(g => g.dirty) && !jobs?.isDirty()) return;
+  if (!groups.some(g => g.dirty)) return;
   event.preventDefault(); event.returnValue = "";
 });