@zq-silk/yui 2.3.0 → 2.5.0

package/dist/storage/taskSearch.js

@@ -0,0 +1,35 @@
+export const TASK_SEARCH_KINDS = ["brief", "message", "decision", "result", "completion"];
+/** A read-only view of authoritative JSON, not a persisted index. Apply Task
+ * scope before body matching and return only page-sized snippets/identities.
+ * No derived state needs rebuilding when a source changes or is removed. */
+export function queryTaskSearch(db, input) {
+    if (!Number.isSafeInteger(input.limit) || input.limit < 1 || input.limit > 101) {
+        throw new Error("Task search query exceeds its bounded contract.");
+    }
+    const branches = [
+        `SELECT task_id AS taskId, 'brief' AS kind, 'task-brief' AS store, task_id AS refId,
+      j.fullkey AS field, j.value AS body FROM task_records, json_tree(brief) j
+      WHERE j.type = 'text' AND (j.key IN ('objective','technicalApproach','currentFocus','leaderSummary')
+        OR j.path = '$.boundaries')`,
+        `SELECT task_id, 'message', 'task-message', message_id, '$.body', json_extract(payload, '$.body') FROM messages`,
+        `SELECT task_id, 'decision', 'task-decision', decision_id, j.fullkey, j.value
+      FROM decisions, json_each(payload) j WHERE j.key IN ('title','rationale','supersededReason') AND j.type = 'text'`,
+        `SELECT task_id, 'result', 'run', turn_id, '$.result.output', json_extract(payload, '$.result.output') FROM turns`,
+        `SELECT task_id, 'completion', 'task', task_id, '$.completionSummary',
+      json_extract(payload, '$.completionSummary') FROM task_records`
+    ];
+    const params = {
+        query: input.query, taskId: input.taskId ?? null, kind: input.kind ?? null, limit: input.limit,
+        afterTask: input.after?.taskId ?? "", afterKind: input.after?.kind ?? "",
+        afterRef: input.after?.refId ?? "", afterField: input.after?.field ?? ""
+    };
+    // SQLite lower() folds ASCII only; other Unicode is matched literally.
+    // Positions and substr use Unicode code points, not UTF-16 units or bytes.
+    return db.prepare(`WITH sources AS (${branches.join(" UNION ALL ")}),
+    matches AS (SELECT *, instr(lower(body), lower(@query)) AS hit FROM sources
+      WHERE (@taskId IS NULL OR taskId = @taskId) AND (@kind IS NULL OR kind = @kind)
+        AND (taskId, kind, refId, field) > (@afterTask, @afterKind, @afterRef, @afterField))
+    SELECT taskId, kind, store, refId, field, max(0, hit - 81) AS offset,
+      substr(body, max(1, hit - 80), 320) AS snippet
+    FROM matches WHERE hit > 0 ORDER BY taskId, kind, refId, field LIMIT @limit`).all(params);
+}

package/dist/storage/upgrade/projectKnowledgeMigration.js

@@ -0,0 +1,52 @@
+import { createHash } from "node:crypto";
+import { knowledgeProposalFingerprint, validateProject } from "../../repository/project.js";
+/**
+ * The declared 1.3 -> 1.4 payload transition. Never used by ordinary readers.
+ * Version 1 is the observed pre-migration head, not a claim that no earlier
+ * edits happened. Existing proposals and frozen Context snapshots retain their
+ * original identities, decisions and evidence; snapshots are never rewritten.
+ */
+export function migrateProjectKnowledge(db) {
+    const rows = db.prepare("SELECT id, payload FROM projects ORDER BY id").all();
+    for (const row of rows) {
+        const project = JSON.parse(row.payload);
+        if (project.id !== row.id || !Array.isArray(project.knowledge) || !Array.isArray(project.knowledgeProposals)) {
+            throw new Error(`Invalid 1.3 Project knowledge container: ${row.id}.`);
+        }
+        const knowledgeProposals = project.knowledgeProposals.map(proposal => {
+            if (proposal.schemaVersion !== 1)
+                throw new Error(`Invalid 1.3 Knowledge proposal: ${proposal.id}.`);
+            const sourceKey = [proposal.projectId, proposal.source.taskId, proposal.source.decisionId ?? "",
+                proposal.source.milestoneId ?? "", proposal.source.commitSha ?? ""].join("|");
+            const previousFingerprint = createHash("sha256")
+                .update(`${sourceKey}\u0000${proposal.title}\u0000${proposal.body}`).digest("hex");
+            if (proposal.fingerprint !== previousFingerprint) {
+                throw new Error(`Invalid 1.3 Knowledge fingerprint: ${proposal.id}.`);
+            }
+            return { ...proposal, schemaVersion: 2, fingerprint: knowledgeProposalFingerprint(proposal) };
+        });
+        const knowledge = project.knowledge.map(entry => {
+            if (entry.schemaVersion !== 1 || "version" in entry || "history" in entry
+                || "scope" in entry || "expiresWhen" in entry) {
+                throw new Error(`Invalid 1.3 Project knowledge: ${entry.id}.`);
+            }
+            const proposal = knowledgeProposals.find(candidate => candidate.id === entry.provenance?.proposalId);
+            const backed = proposal !== undefined && proposal.status === "accepted"
+                && proposal.knowledgeId === entry.id && proposal.title === entry.title && proposal.body === entry.body
+                && proposal.source.taskId === entry.provenance?.taskId
+                && proposal.source.decisionId === entry.provenance?.decisionId
+                && proposal.source.milestoneId === entry.provenance?.milestoneId
+                && proposal.source.commitSha === entry.provenance?.commitSha;
+            return {
+                ...entry, schemaVersion: 2, version: 1, history: [],
+                ...(backed ? {
+                    ...(proposal.scope === undefined ? {} : { scope: proposal.scope }),
+                    ...(proposal.expiresWhen === undefined ? {} : { expiresWhen: proposal.expiresWhen }),
+                    provenance: { ...entry.provenance, fingerprint: proposal.fingerprint }
+                } : {})
+            };
+        });
+        const migrated = validateProject({ ...project, knowledge, knowledgeProposals });
+        db.prepare("UPDATE projects SET payload=? WHERE id=?").run(JSON.stringify(migrated), row.id);
+    }
+}

package/dist/task/ordinaryArchive.js

@@ -0,0 +1,42 @@
+import { runTaskCommand, validateTaskArchiveRequest } from "../commands/taskCommands.js";
+import { taskArchiveDiagnostics } from "./archiveDiagnostics.js";
+import { assertTaskRemoteDeliveryIntegrated, createTaskRemoteDeliveryProof } from "./remoteDeliveryService.js";
+/** Read-only admission shared by CLI and Web. Cancelled Project Tasks need a
+ * workspace snapshot before delivery can be proved; that later preparation
+ * may have effects and must not be reported as a known non-submission. */
+export function validateOrdinaryTaskArchive(store, taskId, options) {
+    validateTaskArchiveRequest([taskId, "--integrated"], store, options);
+    const task = store.getTask(taskId);
+    if (task.status !== "archived" && (task.status === "completed" || !task.projectBindings.length)) {
+        assertTaskRemoteDeliveryIntegrated(createTaskRemoteDeliveryProof(store, task).delivery);
+    }
+}
+/** The local user's ordinary archive path. No force, abandonment, source
+ * impersonation, or private cleanup policy is accepted by this port. */
+export async function archiveOrdinaryTask(coordinator, taskId, options) {
+    const { store, preparer } = coordinator;
+    const args = [taskId, "--integrated"];
+    validateOrdinaryTaskArchive(store, taskId, options);
+    const task = store.getTask(taskId);
+    if (task.status !== "archived") {
+        let candidate = null;
+        if (task.status === "cancelled" && task.projectBindings.length) {
+            await preparer.prepareTaskWorkspace(taskId);
+            const workspace = store.getTaskWorkspace(taskId);
+            if (!workspace || workspace.owner.type !== "task" || workspace.owner.taskId !== taskId) {
+                throw new Error(`Task has no authoritative main workspace: ${taskId}.`);
+            }
+            const snapshot = await preparer.snapshotDirectTaskMain(workspace, task.projectBindings.map(binding => binding.projectId));
+            candidate = { schemaVersion: 1, projects: snapshot.projects.map(project => ({
+                    projectId: project.projectId, commit: project.headCommit
+                })) };
+        }
+        const proof = createTaskRemoteDeliveryProof(store, task, candidate);
+        assertTaskRemoteDeliveryIntegrated(proof.delivery);
+        await coordinator.prepareTaskForArchive(taskId);
+        runTaskCommand(["archive", ...args], store, { ...options, archiveRemoteDeliveryProof: proof });
+        await coordinator.cleanupArchivedTask(taskId, "integrated");
+    }
+    const current = store.getTask(taskId);
+    return { task: current, ...taskArchiveDiagnostics(store, current) };
+}

package/dist/tmux/tmuxManager.js

@@ -263,16 +263,16 @@ export class TmuxManager {
             // with terminal output that predates this attach.
             this.run(["set-option", "-t", clientSession, "status", "off"]);
             this.run(["set-option", "-t", clientSession, "mouse", "on"]);
+            // Arm automatic release only after a client has attached. Enabling it
+            // on the initially detached session would destroy it before attach.
+            // A client-detached hook is unsafe: after explicit session destruction,
+            // tmux can resolve that notification in a surviving session's context
+            // and execute its hook, cascading into unrelated viewer/writer leases.
             this.run([
-                "set-hook", "-t", clientSession, "client-detached",
-                `kill-session -t ${clientSession}`
+                "set-hook", "-t", clientSession, "client-attached",
+                `set-option -t ${clientSession} destroy-unattached on`
+                    + (attachedNotice === undefined ? "" : ` ; display-message -d 10000 ${tmuxWord(attachedNotice)}`)
             ]);
-            if (attachedNotice !== undefined) {
-                this.run([
-                    "set-hook", "-t", clientSession, "client-attached",
-                    `display-message -d 10000 ${tmuxWord(attachedNotice)}`
-                ]);
-            }
             return clientSession;
         }
         catch (error) {

package/dist/web/assets/assetManifest.js

@@ -1,63 +1,23 @@
+// Every asset the dashboard serves, keyed by URL path. Stylesheets come from
+// the ordered styles registry, client modules from the client registry, and
+// fonts and xterm from their packages; the shell links them in this order.
 import { readFileSync } from "node:fs";
 import { createRequire } from "node:module";
-import { API_SCRIPT } from "./client/api.js";
-import { APP_SCRIPT } from "./client/app.js";
-import { COMPONENTS_SCRIPT } from "./client/components.js";
-import { DETAIL_SCRIPT } from "./client/detail.js";
-import { DOCK_SCRIPT } from "./client/dock.js";
-import { DOM_SCRIPT } from "./client/dom.js";
-import { EVIDENCE_SCRIPT } from "./client/evidence.js";
-import { FORMAT_SCRIPT } from "./client/format.js";
-import { FORMS_SCRIPT } from "./client/forms.js";
-import { I18N_SCRIPT } from "./client/i18n.js";
-import { MARKDOWN_SCRIPT } from "./client/markdown.js";
-import { OVERVIEW_SCRIPT } from "./client/overview.js";
-import { RECORDS_SCRIPT } from "./client/records.js";
-import { SECTIONS_SCRIPT } from "./client/sections.js";
-import { SIDEBAR_SCRIPT } from "./client/sidebar.js";
-import { THEME_SCRIPT } from "./client/theme.js";
-import { DASHBOARD_HTML } from "./shell.js";
-import { FONT_FACE_STYLES } from "./fonts.js";
+import { APP_SCRIPT, CLIENT_MODULES } from "./client/index.js";
 import { FONT_WOFF2_BASE64 } from "./fontData.js";
-import { BASE_STYLES } from "./styles/base.js";
-import { COMPONENT_STYLES } from "./styles/components.js";
-import { LAYOUT_STYLES } from "./styles/layout.js";
-import { MARKDOWN_STYLES } from "./styles/markdown.js";
-import { RESPONSIVE_STYLES } from "./styles/responsive.js";
-import { TOKEN_STYLES } from "./styles/tokens.js";
-import { VIEW_STYLES } from "./styles/views.js";
+import { DASHBOARD_HTML } from "./shell/index.js";
+import { STYLESHEETS } from "./styles/index.js";
 const require = createRequire(import.meta.url);
 const CSS = "text/css; charset=utf-8";
 const JS = "text/javascript; charset=utf-8";
 export const WEB_ASSETS = Object.freeze({
-    "/assets/css/fonts.css": { contentType: CSS, body: FONT_FACE_STYLES },
-    "/assets/css/tokens.css": { contentType: CSS, body: TOKEN_STYLES },
-    "/assets/css/base.css": { contentType: CSS, body: BASE_STYLES },
-    "/assets/css/layout.css": { contentType: CSS, body: LAYOUT_STYLES },
-    "/assets/css/components.css": { contentType: CSS, body: COMPONENT_STYLES },
-    "/assets/css/views.css": { contentType: CSS, body: VIEW_STYLES },
-    "/assets/css/markdown.css": { contentType: CSS, body: MARKDOWN_STYLES },
-    "/assets/css/responsive.css": { contentType: CSS, body: RESPONSIVE_STYLES },
-    "/assets/js/dom.js": { contentType: JS, body: DOM_SCRIPT },
-    "/assets/js/format.js": { contentType: JS, body: FORMAT_SCRIPT },
-    "/assets/js/i18n.js": { contentType: JS, body: I18N_SCRIPT },
-    "/assets/js/markdown.js": { contentType: JS, body: MARKDOWN_SCRIPT },
-    "/assets/js/theme.js": { contentType: JS, body: THEME_SCRIPT },
-    "/assets/js/api.js": { contentType: JS, body: API_SCRIPT },
-    "/assets/js/components.js": { contentType: JS, body: COMPONENTS_SCRIPT },
-    "/assets/js/records.js": { contentType: JS, body: RECORDS_SCRIPT },
-    "/assets/js/forms.js": { contentType: JS, body: FORMS_SCRIPT },
-    "/assets/js/evidence.js": { contentType: JS, body: EVIDENCE_SCRIPT },
-    "/assets/js/sidebar.js": { contentType: JS, body: SIDEBAR_SCRIPT },
-    "/assets/js/overview.js": { contentType: JS, body: OVERVIEW_SCRIPT },
-    "/assets/js/sections.js": { contentType: JS, body: SECTIONS_SCRIPT },
-    "/assets/js/detail.js": { contentType: JS, body: DETAIL_SCRIPT },
-    "/assets/js/dock.js": { contentType: JS, body: DOCK_SCRIPT },
+    ...Object.fromEntries(STYLESHEETS.map(({ name, body }) => [`/assets/css/${name}.css`, { contentType: CSS, body }])),
+    ...Object.fromEntries(Object.entries(CLIENT_MODULES).map(([path, body]) => [`/assets/js/${path}.js`, { contentType: JS, body }])),
     "/assets/app.js": { contentType: JS, body: APP_SCRIPT },
     ...fontAssets(),
-    "/assets/vendor/xterm.mjs": vendorAsset("@xterm/xterm/lib/xterm.mjs", "text/javascript; charset=utf-8"),
-    "/assets/vendor/addon-fit.mjs": vendorAsset("@xterm/addon-fit/lib/addon-fit.mjs", "text/javascript; charset=utf-8"),
-    "/assets/vendor/xterm.css": vendorAsset("@xterm/xterm/css/xterm.css", "text/css; charset=utf-8")
+    "/assets/vendor/xterm.mjs": vendorAsset("@xterm/xterm/lib/xterm.mjs", JS),
+    "/assets/vendor/addon-fit.mjs": vendorAsset("@xterm/addon-fit/lib/addon-fit.mjs", JS),
+    "/assets/vendor/xterm.css": vendorAsset("@xterm/xterm/css/xterm.css", CSS)
 });
 export { DASHBOARD_HTML };
 export function findWebAsset(pathname) {

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

@@ -0,0 +1,215 @@
+export const CATALOG_SCRIPT = String.raw `
+// The Task catalog: the refresh loop over the dashboard read, the sidebar
+// (attention, status tabs, search, paged list), its filters from the URL and
+// the explicit Session read of the current catalog page. This module is the
+// only writer of the catalog fields of state. Only the newest request may
+// apply its result.
+import { fill, formatClock } from "/assets/js/lib/format.js";
+import { h } from "/assets/js/lib/dom.js";
+import { loadingBlock } from "/assets/js/ui/primitives.js";
+import { renderAttentionBar, renderFilters, renderTasks, STATUS_FILTERS, ATTENTION_KINDS } from "/assets/js/views/sidebar.js";
+import { syncUrl } from "/assets/js/layout/router.js";
+
+// deps: { el, state, t, locale, api, toast, selectTask, showOverview, reloadSelected }
+//   el     the sidebar elements, the sync state and the refresh button
+//   state  writes the catalog fields; reads state.selected
+//   selectTask(taskId)  a task row was chosen (app/selection)
+//   showOverview()      redraw the center overview while nothing is selected
+//   reloadSelected()    re-read the selected Task; rejects when the read fails
+export function createCatalog(deps) {
+  // progress: whether a refresh is in flight and the newest request number.
+  const progress = { refreshing: false, request: 0 };
+  const catalog = {
+    refresh: function (options) { return refresh(deps, progress, options); },
+    reset: function () { reset(deps, progress); },
+    renderSidebar: function () { renderSidebar(deps, progress); },
+    renderTaskList: function () { renderTaskList(deps); },
+    pickAttention: function (kind) { pickAttention(deps, progress, kind); },
+    readPageSessions: function () { return readPageSessions(deps); },
+    applyFilters: function (params) { applyFilters(deps, params); }
+  };
+  bindCatalogControls(deps.el, deps.state, catalog);
+  return catalog;
+}
+
+function reset(deps, progress) {
+  deps.state.catalogCursor = null;
+  deps.state.nextCursor = null;
+  refresh(deps, progress);
+}
+
+async function refresh(deps, progress, options) {
+  const el = deps.el;
+  const state = deps.state;
+  const quiet = options && options.quiet;
+  if (progress.refreshing && quiet) return;
+  const request = ++progress.request;
+  progress.refreshing = true;
+  beginRefresh(el, state, deps.t, quiet);
+  const previousInputs = state.counts ? state.counts.openInputs : null;
+  try {
+    const query = catalogQuery(state);
+    const dashboard = await deps.api.dashboard(query);
+    if (request !== progress.request) return;
+    applyDashboard(state, dashboard, query);
+    showDashboard(deps, progress, previousInputs);
+    // A selected Task may live on another page or outside current filters;
+    // only its own read can establish that it no longer exists.
+    if (state.selected) {
+      try { await deps.reloadSelected(); }
+      catch { deps.toast(deps.t("errors.disconnected")); }
+    }
+  } catch {
+    if (request !== progress.request) return;
+    dashboardFailed(deps, quiet);
+  } finally {
+    if (request === progress.request) {
+      progress.refreshing = false;
+      el.refresh.disabled = false;
+      el.catalogNext.disabled = !state.nextCursor;
+    }
+  }
+}
+
+function showDashboard(deps, progress, previousInputs) {
+  deps.el.sync.dataset.state = "ok";
+  renderSidebar(deps, progress);
+  if (!deps.state.selected) deps.showOverview();
+  if (previousInputs !== null && deps.state.counts.openInputs > previousInputs) deps.toast(deps.t("input.new"));
+}
+
+function dashboardFailed(deps, quiet) {
+  deps.el.sync.dataset.state = "error";
+  if (quiet) return;
+  deps.el.tasks.replaceChildren(h("div.list-empty.is-error", null, h("p", null, deps.t("errors.dashboard"))));
+  deps.toast(deps.t("errors.dashboard"));
+}
+
+function renderSidebar(deps, progress) {
+  const el = deps.el;
+  const state = deps.state;
+  const t = deps.t;
+  renderAttentionBar(el.attention, state, t, function (kind) { pickAttention(deps, progress, kind); });
+  renderFilters(el.filters, state, t, function (filter) {
+    state.filter = filter;
+    state.attentionFilter = null;
+    state.catalogAll = false;
+    syncUrl(state, false);
+    reset(deps, progress);
+  });
+  el.catalogCount.textContent = fill(t("catalog.count"), { shown: state.tasks.length, total: state.catalogTotal });
+  el.catalogReset.hidden = !state.catalogCursor;
+  el.catalogNext.hidden = !state.nextCursor && !state.catalogCursor;
+  el.catalogAttentionReset.hidden = !state.attentionFilter;
+  renderTaskList(deps);
+  el.lastSync.textContent = state.generatedAt ? formatClock(state.generatedAt, deps.locale()) : "—";
+}
+
+// Redraw the list in place, keeping its scroll position.
+function renderTaskList(deps) {
+  const scroll = deps.el.tasks.scrollTop;
+  renderTasks(deps.el.tasks, deps.state, deps.t, deps.locale(), deps.selectTask);
+  deps.el.tasks.scrollTop = scroll;
+}
+
+function pickAttention(deps, progress, kind) {
+  const state = deps.state;
+  state.attentionFilter = kind;
+  state.catalogAll = !!kind && !!state.catalogScope && state.catalogScope.archived === "included";
+  state.filter = "all";
+  state.query = "";
+  deps.el.search.value = "";
+  syncUrl(state, false);
+  reset(deps, progress);
+}
+
+function beginRefresh(el, state, t, quiet) {
+  el.catalogNext.disabled = true;
+  el.sync.dataset.state = "syncing";
+  if (quiet) return;
+  el.refresh.disabled = true;
+  if (!state.tasks.length) el.tasks.replaceChildren(loadingBlock(t("loading.dashboard")));
+}
+
+function catalogQuery(state) {
+  const query = new URLSearchParams();
+  if (state.catalogAll) query.set("all", "true");
+  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);
+  if (state.catalogCursor) query.set("cursor", state.catalogCursor);
+  return query.toString();
+}
+
+function taskIds(tasks, key) {
+  return JSON.stringify(tasks.map(function (task) { return task[key]; }));
+}
+
+function applyDashboard(state, dashboard, query) {
+  state.tasks = dashboard.tasks;
+  // A Session read describes exactly one catalog page.
+  if (state.catalogQuery !== query || (state.sessionOverview
+    && taskIds(state.sessionOverview.tasks, "taskId") !== taskIds(dashboard.tasks, "id"))) {
+    state.sessionOverview = null;
+  }
+  state.catalogQuery = query;
+  state.counts = { ...dashboard.counts, openInputs: dashboard.attention.openInputs.count };
+  state.catalogAttention = dashboard.attention;
+  state.catalogScope = dashboard.scope;
+  state.catalogTotal = dashboard.total;
+  state.nextCursor = dashboard.nextCursor;
+  state.attention = dashboard.attention.openInputs.refs.map(function (ref) {
+    const task = state.tasks.find(function (entry) { return entry.id === ref.taskId; });
+    return { taskId: ref.taskId, taskTitle: task ? task.title : ref.taskId };
+  });
+  state.generatedAt = new Date().toISOString();
+}
+
+async function readPageSessions(deps) {
+  const state = deps.state;
+  if (state.sessionLoading) return;
+  const query = state.catalogQuery;
+  state.sessionLoading = true;
+  deps.showOverview();
+  try {
+    const result = await deps.api.pageSessions(query);
+    if (query !== state.catalogQuery) return;
+    if (taskIds(result.tasks, "taskId") !== taskIds(state.tasks, "id")) throw new Error(deps.t("overview.sessionsPageChanged"));
+    state.sessionOverview = result;
+    state.sessionError = null;
+  } catch (error) { state.sessionError = error.message; }
+  finally {
+    state.sessionLoading = false;
+    if (!state.selected) deps.showOverview();
+  }
+}
+
+// Filters from the URL, on load and on back/forward.
+function applyFilters(deps, params) {
+  const state = deps.state;
+  const filter = params.get("filter");
+  state.filter = STATUS_FILTERS.includes(filter) ? filter : "all";
+  state.query = params.get("q") || "";
+  state.attentionFilter = ATTENTION_KINDS.includes(params.get("attention")) ? params.get("attention") : null;
+  state.catalogAll = params.get("all") === "true";
+  deps.el.search.value = state.query;
+}
+
+function bindCatalogControls(el, state, catalog) {
+  let searchTimer = null;
+  el.search.addEventListener("input", function () {
+    state.query = el.search.value;
+    syncUrl(state, true);
+    window.clearTimeout(searchTimer);
+    searchTimer = window.setTimeout(catalog.reset, 200);
+  });
+  el.catalogNext.addEventListener("click", function () {
+    if (!state.nextCursor) return;
+    state.catalogCursor = state.nextCursor;
+    catalog.refresh();
+  });
+  el.catalogReset.addEventListener("click", catalog.reset);
+  el.catalogAttentionReset.addEventListener("click", function () { catalog.pickAttention(null); });
+  el.refresh.addEventListener("click", function () { catalog.refresh(); });
+}
+`;

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

@@ -0,0 +1,148 @@
+export const APP_SCRIPT = String.raw `
+// Composition root (served as /assets/app.js). It binds the static shell,
+// owns the view state object and is the only place where controllers are
+// wired to each other. Each controller receives one explicit deps object,
+// documented at its factory: services, controllers created before it, and
+// named callbacks into controllers created after it (bound here, late).
+// Everything kept in the browser is view state; Task facts always come from
+// the loopback API.
+//
+//   layout/workspace  sidebar | center | dock columns, dock modes, sizing
+//   app/taskView      draws the selected Task, the dock discussion, the overview
+//   app/selection     selected Task, its detail reads, URL-driven navigation
+//   app/catalog       refresh loop, sidebar, catalog paging and filters
+//   layout/shortcuts  keyboard shortcuts
+//
+// Flows:
+//   refresh  catalog.refresh → sidebar, then the overview (nothing selected)
+//            or selection.reload → taskView.render
+//   select   sidebar row / overview row / URL → selection.selectTask
+//   leave    back button 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";
+import { createThemeController } from "/assets/js/lib/theme.js";
+import { api } from "/assets/js/lib/api.js";
+import { createToast } from "/assets/js/ui/toast.js";
+import { createTerminalController } from "/assets/js/views/dock/terminal.js";
+import { createConversationController } from "/assets/js/views/dock/conversation.js";
+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 { createWorkspace } from "/assets/js/layout/workspace.js";
+import { bindShortcuts } from "/assets/js/layout/shortcuts.js";
+import { createTaskView } from "/assets/js/app/taskView.js";
+import { createSelection } from "/assets/js/app/selection.js";
+import { createCatalog } from "/assets/js/app/catalog.js";
+
+const $ = function (selector) { return document.querySelector(selector); };
+const el = {
+  sidebar: $(".sidebar"), sidebarDivider: $("#sidebar-divider"), center: $("#center"), detail: $("#detail"),
+  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"),
+  operator: $("#operator-terminal"), settingsOpen: $("#settings-open"), settings: $("#settings-dialog"),
+  locale: $("#locale-select"), themeOptions: $("#theme-options"),
+  dock: $("#dock"), divider: $("#dock-divider"), dockSwap: $("#dock-swap"), dockClose: $("#dock-close"),
+  dockTabDiscussion: $("#dock-tab-discussion"), dockTabSession: $("#dock-tab-session"),
+  dockTabConversation: $("#dock-tab-conversation"), conversation: $("#dock-conversation"),
+  dockTabPreview: $("#dock-tab-preview"), preview: $("#dock-preview"),
+  discussion: $("#dock-discussion"), session: $("#dock-session"),
+  terminalHost: $("#terminal-host"), terminalEmpty: $("#terminal-empty"), terminalState: $("#terminal-state"),
+  sessionTargets: $("#session-targets"), terminalCli: $("#terminal-cli")
+};
+
+// View state. Each group has exactly one writer.
+const state = {
+  // app/catalog: the dashboard read, its filters and paging, the Session read.
+  tasks: [], counts: null, attention: [], catalogAttention: null, catalogScope: null, catalogQuery: "",
+  catalogAll: false, catalogTotal: 0, catalogCursor: null, nextCursor: null,
+  sessionOverview: null, sessionLoading: false, sessionError: null,
+  attentionFilter: null, generatedAt: null, filter: "all", query: "",
+  // app/selection: the selected Task and its loaded detail.
+  selected: null, detail: null, detailKey: null,
+  // app/taskView: the tab the reader is on.
+  activeTab: "overview"
+};
+
+const i18n = createI18n(el.locale);
+const t = i18n.t;
+const locale = i18n.getLocale;
+const theme = createThemeController(el.themeOptions, t);
+const toast = createToast(el.toast);
+const conversation = createConversationController(el.conversation, t, locale);
+const preview = createPreviewController(el.preview, t);
+const terminal = createTerminalController({
+  host: el.terminalHost, empty: el.terminalEmpty, state: el.terminalState, targets: el.sessionTargets, cli: el.terminalCli
+}, t, locale, toast);
+theme.subscribe(function () { terminal.retheme(); });
+
+// Controllers are created in dependency order; the arrow callbacks below are
+// the only edges pointing at controllers created later.
+let taskView = null;
+let selection = null;
+let catalog = null;
+const workspace = createWorkspace({
+  el: el, state: state, terminal: terminal, conversation: conversation, preview: preview,
+  sessionOpened: function () { taskView.updateSessionTargets(); }
+});
+taskView = createTaskView({
+  el: el, state: state, t: t, locale: locale, api: api, toast: toast, terminal: terminal, workspace: workspace,
+  selectTask: function (taskId) { return selection.selectTask(taskId); },
+  clearSelection: function () { selection.clearSelection(); },
+  pickAttention: function (kind) { catalog.pickAttention(kind); },
+  readPageSessions: function () { return catalog.readPageSessions(); },
+  refreshCatalog: function () { return catalog.refresh({ quiet: true }); }
+});
+selection = createSelection({
+  state: state, t: t, api: api, toast: toast, workspace: workspace, taskView: taskView,
+  renderTaskList: function () { catalog.renderTaskList(); }
+});
+catalog = createCatalog({
+  el: el, state: state, t: t, locale: locale, api: api, toast: toast,
+  selectTask: selection.selectTask,
+  showOverview: taskView.showOverview,
+  reloadSelected: selection.reload
+});
+const globalInput = bindGlobalInput({ t: t, api: api });
+bindCreateTask({ t: t, api: api, selectTask: selection.selectTask,
+  afterWrite: function () { catalog.refresh({ quiet: true }); } });
+bindBodySearch({ t: t, api: api, selectTask: selection.selectTask,
+  currentTask: function () { return state.selected; },
+  captureDraftTarget: conversation.captureDraftTarget, insertReference: conversation.insertReference });
+bindShortcuts({
+  el: el, state: state, globalInput: globalInput, workspace: workspace,
+  selection: selection, catalog: catalog, taskView: taskView
+});
+el.settingsOpen.addEventListener("click", function () { window.location.assign("/settings"); });
+
+// The URL names the catalog filters and the selected Task (with its section).
+function applyStateFromUrl() {
+  const params = readQuery();
+  catalog.applyFilters(params);
+  selection.followUrl(params);
+}
+window.addEventListener("popstate", function () {
+  applyStateFromUrl();
+  catalog.reset();
+});
+
+i18n.subscribe(function () {
+  theme.render();
+  terminal.relabel();
+  catalog.renderSidebar();
+  taskView.relabel();
+  workspace.updateLayout();
+});
+
+workspace.updateLayout();
+taskView.showOverview();
+conversation.open({ scope: "global", roleName: "operator" });
+applyStateFromUrl();
+workspace.restoreDefaultMode();
+catalog.refresh();
+window.setInterval(function () { catalog.refresh({ quiet: true }); }, 5000);
+`;