@zq-silk/yui 2.2.0 → 2.4.0

package/dist/web/assets/client/domain/context.js

@@ -0,0 +1,96 @@
+export const CONTEXT_SCRIPT = String.raw `
+// Context access. Every business fact keeps its Context reference; an
+// expanded value is a current read, never a mutation of the snapshot.
+
+export function entriesOf(core, store) {
+  return core.records.filter(function (entry) { return entry.ref.store === store; });
+}
+
+export function valuesOf(core, store) {
+  return entriesOf(core, store).filter(function (entry) { return !entry.omitted; }).map(function (entry) { return entry.value; });
+}
+
+// The family total from the same bounded read as its samples. The current
+// view counts current records only: open work, active runs, open questions.
+export function totalOf(core, store) {
+  const row = (core.collections || []).find(function (item) { return item.store === store; });
+  return row ? row.total : entriesOf(core, store).length;
+}
+
+// List and omitted-value summaries join known fields in a fixed order
+// ("title: …; status: …"). Split them for display only; the exact record
+// stays one read away.
+const SUMMARY_KEYS = ["title", "scope", "expiresWhen", "version", "objective", "question", "summary", "body", "status", "type"];
+export function summaryFields(summary) {
+  const fields = {};
+  if (!summary) return fields;
+  const pattern = new RegExp("(?:^|; )(" + SUMMARY_KEYS.join("|") + "): ", "g");
+  const marks = [];
+  let match;
+  while ((match = pattern.exec(summary))) {
+    const rank = SUMMARY_KEYS.indexOf(match[1]);
+    if (marks.length && rank <= marks[marks.length - 1].rank) continue;
+    marks.push({ key: match[1], rank: rank, start: match.index, from: match.index + match[0].length });
+  }
+  marks.forEach(function (mark, index) {
+    fields[mark.key] = summary.slice(mark.from, index + 1 < marks.length ? marks[index + 1].start : summary.length);
+  });
+  return fields;
+}
+
+// --- Exact reads -------------------------------------------------------------
+// One inspect per reference digest, held in the Task's view state so a
+// refresh with an unchanged reference never reads again. A changed digest is
+// a new read.
+export function exactCache(view) {
+  view.exact = view.exact || {};
+  return view.exact;
+}
+
+export function readExact(entry, taskId, actions, cache) {
+  const key = entry.ref.store + "/" + entry.ref.refId;
+  const hit = cache[key];
+  if (hit && hit.digest === entry.ref.digest) return hit.promise;
+  const promise = actions.inspect(taskId, entry.ref);
+  const slot = { digest: entry.ref.digest, promise: promise, result: null };
+  cache[key] = slot;
+  promise.then(function (result) { slot.result = result; }, function () { if (cache[key] === slot) delete cache[key]; });
+  return promise;
+}
+
+// The settled exact read for this exact reference, or null.
+export function cachedExact(cache, entry) {
+  const hit = cache[entry.ref.store + "/" + entry.ref.refId];
+  return hit && hit.digest === entry.ref.digest && hit.result ? hit.result : null;
+}
+
+// --- Paged family discovery --------------------------------------------------
+// Pages of one Context family for the current Context cursor. A continuation
+// never mixes versions: after the cursor changes, the first page is re-read.
+export function familyState(view, store) {
+  view.families = view.families || {};
+  if (!view.families[store]) view.families[store] = { items: [], total: null, nextCursor: null, pages: 0, key: null, error: null, pending: null };
+  return view.families[store];
+}
+
+export function loadFamily(view, taskId, store, key, actions, options) {
+  const state = familyState(view, store);
+  const more = !!(options && options.more);
+  if (state.pending) return state.pending;
+  if (more ? !state.nextCursor : state.key === key && state.pages && !state.error) return Promise.resolve(state);
+  state.pending = actions.list(taskId, store, { limit: (options && options.limit) || 40, cursor: more ? state.nextCursor : null })
+    .then(function (page) {
+      if (!more) { state.items = []; state.pages = 0; }
+      state.items = state.items.concat(page.items);
+      state.total = page.total;
+      state.nextCursor = page.nextCursor;
+      state.pages += 1;
+      state.key = more ? state.key : key;
+      state.error = null;
+      state.errorKey = null;
+      return state;
+    }, function (error) { state.error = error.message; state.errorKey = more ? state.key : key; return state; })
+    .then(function (result) { state.pending = null; return result; });
+  return state.pending;
+}
+`;

package/dist/web/assets/client/domain/records.js

@@ -0,0 +1,126 @@
+export const RECORDS_SCRIPT = String.raw `
+// Record rows and cards. A row keeps its Context reference: an omitted value
+// is shown as the honest summary until its exact read arrives, and reading
+// never acknowledges or accepts anything.
+import { h, icon } from "/assets/js/lib/dom.js";
+import { button, jsonBlock, mono, note } from "/assets/js/ui/primitives.js";
+import { rawDisclosure } from "/assets/js/ui/containers.js";
+import { richText } from "/assets/js/ui/text.js";
+import { cachedExact, readExact, summaryFields } from "/assets/js/domain/context.js";
+
+// A row drawn from its exact value: synchronously when cached, otherwise the
+// summary card until the read returns and replaces it in place.
+export function exactRow(entry, taskId, t, actions, cache, render) {
+  if (!entry.omitted) return render(entry.value, null);
+  const hit = cachedExact(cache, entry);
+  if (hit) return render(hit.value, hit);
+  const placeholder = recordCard(entry, taskId, t, actions);
+  placeholder.dataset.reading = "true";
+  readExact(entry, taskId, actions, cache).then(function (result) {
+    if (placeholder.isConnected) placeholder.replaceWith(render(result.value, result));
+  }, function () { placeholder.dataset.reading = "false"; });
+  return placeholder;
+}
+
+// A closed row drawn from a list summary; its exact value is read on first
+// open. Open rows are remembered in view state and reopen after a redraw.
+export function lazyRow(item, taskId, t, actions, options) {
+  const opts = options || {};
+  const key = item.ref.store + ":" + item.ref.refId;
+  const element = h("details.lazy-row");
+  if (item.status) element.dataset.status = item.status;
+  const body = h("div.lazy-body");
+  element.append(h("summary.lazy-head", null, icon("chevron", "disclosure-chevron"), opts.head), body);
+  let state = "idle";
+  function load() {
+    if (state !== "idle") return;
+    state = "reading";
+    element.dataset.reading = "true";
+    body.replaceChildren(h("p.faint.small", null, t("record.reading")));
+    readExact({ ref: item.ref }, taskId, actions, opts.cache || {}).then(function (result) {
+      state = "done";
+      body.replaceChildren();
+      body.append(h("div.lazy-content", null, opts.render ? opts.render(result.value, result) : null), rawDisclosure(t, result.value));
+    }, function (error) {
+      state = "idle";
+      body.replaceChildren(note(t("record.changed") + " · " + error.message, "bad"));
+    }).then(function () { element.dataset.reading = "false"; });
+  }
+  element.addEventListener("toggle", function () {
+    if (opts.openRows) { if (element.open) opts.openRows[key] = true; else delete opts.openRows[key]; }
+    if (element.open) load();
+  });
+  if (opts.openRows && opts.openRows[key]) element.open = true;
+  return element;
+}
+
+// A generic card for any record: omitted values say so and can be read by
+// reference.
+export function recordCard(entry, taskId, t, actions, options) {
+  const opts = options || {};
+  const element = h("article.record" + (opts.compact ? ".is-compact" : ""));
+  element.append(h("header.record-head", null,
+    h("span.record-store", null, t("store." + entry.ref.store, entry.ref.store)),
+    mono(entry.ref.refId),
+    h("span.spacer"),
+    h("span.faint.small", { title: t("record.revision") }, String(entry.ref.revision).slice(0, 24))));
+  element.append.apply(element, !entry.omitted && entry.value ? valueLines(entry, t) : summaryLines(entry, t));
+  element.append(recordReader(entry, taskId, t, actions));
+  return element;
+}
+
+function valueLines(entry, t) {
+  const value = entry.value;
+  const lines = [];
+  const text = value.content || value.summary || value.body || value.objective || value.title || value.leaderSummary;
+  if (text) lines.push(richText(null, text, t, { threshold: 360 }));
+  if (entry.ref.store === "task-decision" && value.rationale) lines.push(richText(t("record.rationale"), value.rationale, t, { muted: true }));
+  const facts = [value.status, value.roleName].filter(Boolean);
+  if (facts.length) lines.push(h("p.faint.small", null, facts.join(" · ")));
+  if (entry.ref.store === "job") {
+    lines.push(note(t("job." + value.status + ".note", t("job.terminal.note")), value.status === "unknown-needs-attention" ? "warn" : ""));
+  }
+  return lines;
+}
+
+function summaryLines(entry, t) {
+  const fields = summaryFields(entry.summary);
+  const lead = fields.title || fields.question || fields.objective;
+  const text = fields.summary || fields.body || (lead === fields.objective ? null : fields.objective);
+  const lines = [];
+  if (lead) lines.push(h("p.record-lead", null, lead));
+  if (text) lines.push(h("p.faint", null, text));
+  if (!lead && !text) lines.push(h("p.faint", null, entry.summary || t("record.omitted")));
+  return lines;
+}
+
+// Shared source access for cards, history and discussion, including records
+// whose compact value is present but does not display every durable field.
+// With a renderer, the exact value is drawn richly and the raw record stays
+// available behind a disclosure.
+export function recordReader(entry, taskId, t, actions, render) {
+  const element = h("div.stack");
+  const expand = button(t("record.read"), { icon: "eye", variant: "link" });
+  expand.addEventListener("click", async function () {
+    expand.disabled = true;
+    element.dataset.reading = "true";
+    try {
+      const result = await actions.inspect(taskId, entry.ref);
+      const rich = render ? render(result.value, result) : null;
+      if (rich) element.append(rich, rawDisclosure(t, result.value));
+      else {
+        if (result.result && result.result.output) element.append(richText(t("record.output"), result.result.output, t));
+        if (result.result && result.result.diagnostic) element.append(richText(t("record.diagnostic"), result.result.diagnostic, t));
+        element.append(jsonBlock(result.value));
+        if (result.execution) element.append(jsonBlock(result.execution));
+      }
+      expand.remove();
+    } catch {
+      expand.disabled = false;
+      expand.replaceChildren(icon("refresh"), h("span", null, t("record.changed")));
+    } finally { element.dataset.reading = "false"; }
+  });
+  element.append(h("div.record-actions", null, expand));
+  return element;
+}
+`;

package/dist/web/assets/client/domain/runs.js

@@ -0,0 +1,119 @@
+export const RUNS_SCRIPT = String.raw `
+// Execution records, review rounds and Roles.
+import { h } from "/assets/js/lib/dom.js";
+import { formatDateTime } from "/assets/js/lib/format.js";
+import { button, chip, dot, kv, mono, note, timeTag } from "/assets/js/ui/primitives.js";
+import { richText } from "/assets/js/ui/text.js";
+import { agentChips, label, statusBadge, tone } from "/assets/js/domain/vocab.js";
+
+export function runCard(run, t, locale) {
+  const element = h("article.run-card");
+  element.dataset.status = run.status;
+  element.append(h("header.run-head", null,
+    dot(tone("run", run.status)),
+    h("span.run-role", null, run.roleName),
+    mono(run.id),
+    run.purpose ? chip(label(t, "run.purpose", run.purpose)) : null,
+    run.workItemId ? chip(run.workItemId) : null,
+    h("span.spacer"),
+    statusBadge(t, "run", "run", run.status)), runBody(run, t, locale));
+  return element;
+}
+
+// What one execution record says: delivery, instruction, report, failure.
+export function runBody(run, t, locale) {
+  const parts = [];
+  const input = run.inputs && run.inputs.length ? run.inputs[0].input : null;
+  parts.push(h("div.meta-line", null,
+    h("span", null, t("run.delivery") + ": " + label(t, "run.delivery", (run.execution && run.execution.delivery) || "unobserved")),
+    run.mode ? h("span", null, label(t, "mode", run.mode)) : null,
+    timeTag((run.result && run.result.completedAt) || run.updatedAt, locale, t),
+    agentChips(run.effective || (run.agentId ? run : null))));
+  const directive = input && (input.directive || input.action);
+  if (directive) parts.push(richText(t("run.instruction"), directive, t, { threshold: 320 }));
+  if (run.result && run.result.output) parts.push(richText(t("run.output"), run.result.output, t, { threshold: 320, className: "callout" }));
+  if (run.result && run.result.diagnostic) parts.push(richText(t("run.failure"), run.result.diagnostic, t, { threshold: 320, className: "callout.tone-bad" }));
+  if (run.executionGroupId) {
+    parts.push(h("p.faint.mono-line", null, t("run.lineage") + " " + run.executionGroupId + (run.executionLaneId ? "/" + run.executionLaneId : "")));
+  }
+  parts.push(skillPackageDetails(run.effective && run.effective.skillPackages, t));
+  return parts.filter(Boolean);
+}
+
+function skillPackageDetails(packages, t) {
+  const details = h("details", null, h("summary", null, t("role.skills") + " · " + (packages ? packages.length : t("skills.unrecorded"))));
+  if (!packages) {
+    details.append(note(t("skills.legacyNote")));
+    return details;
+  }
+  packages.forEach(function (skill) {
+    details.append(h("div.record", null, h("strong", null, skill.id),
+      h("p.small.mono-line", null, skill.digest),
+      h("p.small", null, skill.source.kind + " · " + skill.fileCount + " " + t("skills.files") + " · " + skill.byteSize + " B"),
+      h("p.small.mono-line", null, t("skills.source") + ": " + skill.source.path),
+      h("p.small.mono-line", null, t("skills.snapshot") + ": " + skill.path),
+      h("p.small.mono-line", null, t("skills.inventory") + ": " + skill.manifestPath)));
+  });
+  return details;
+}
+
+export function reviewCard(round, t, locale) {
+  const element = h("article.review-card");
+  element.append(h("header.run-head", null,
+    dot(tone("review", round.status)),
+    h("span.run-role", null, round.reviewerRoleName || t("review.reviewer")),
+    mono(round.id),
+    round.scope ? chip(label(t, "review.scope", round.scope)) : null,
+    h("span.spacer"),
+    statusBadge(t, "review", "review", round.status)));
+  element.append(h("div.meta-line", null,
+    round.workItemId ? mono(round.workItemId + (round.candidateId ? " · " + round.candidateId : "")) : null,
+    round.taskCandidate && round.taskCandidate.projects ? round.taskCandidate.projects.map(function (project) {
+      return mono(project.projectId + " @ " + String(project.commit).slice(0, 12));
+    }) : null,
+    round.reviewBaseCommit ? h("span", null, t("review.base") + " ", mono(String(round.reviewBaseCommit).slice(0, 12))) : null,
+    round.reviewerRunId ? h("span", null, t("review.run") + " ", mono(round.reviewerRunId)) : null,
+    timeTag(round.createdAt, locale, t)));
+  if (round.failure) element.append(note(round.failure.kind + ": " + round.failure.message, "bad"));
+  return element;
+}
+
+export function roleCard(role, t, locale, options) {
+  const opts = options || {};
+  const element = h("article.role-card");
+  const binding = role.agentBindings && role.agentBindings[role.activeAgentId];
+  element.append(h("header.role-head", null,
+    h("span.avatar", { "aria-hidden": "true" }, String(role.name || "?").slice(0, 1).toUpperCase()),
+    h("div.role-title", null, h("strong", null, role.name),
+      h("span.faint", null, role.activeAgentId || "")),
+    opts.status ? statusBadge(t, "role", "role", opts.status) : null));
+  if (binding) element.append(agentChips({
+    adapterId: binding.adapterId, component: binding.component,
+    model: binding.config && binding.config.model, effort: binding.config && binding.config.effort
+  }));
+  if (role.description) element.append(richText(null, role.description, t, { muted: true, threshold: 280 }));
+  element.append(kv(roleFacts(role, t, locale, opts)));
+  if (opts.runtimeRole && opts.runtimeRole.runtimeSession) {
+    element.append(skillPackageDetails(opts.runtimeRole.runtimeSession.skillPackages, t));
+  }
+  if (opts.onOpen) {
+    element.append(h("div.role-actions", null, button(t("role.openSession"), {
+      icon: "terminal", variant: "ghost", onClick: function () { opts.onOpen(role.name); }
+    })));
+  }
+  return element;
+}
+
+function roleFacts(role, t, locale, opts) {
+  const session = opts.runtimeRole && opts.runtimeRole.runtimeSession;
+  const rows = [];
+  rows.push([t("role.session"), session && session.nativeSessionId ? mono(session.nativeSessionId) : t("role.noSession")]);
+  if (role.launchRevision !== undefined) rows.push([t("role.desired"), "r" + role.launchRevision + (opts.launchDrift ? " · " + t("role.drift") : "")]);
+  if (role.defaultAccess !== undefined) rows.push([t("role.access"), role.defaultAccess]);
+  if (opts.retry) rows.push([t("role.providerRetry"), label(t, "retry", opts.retry.status) + " · "
+    + opts.retry.attempts + "/" + opts.retry.limit
+    + (opts.retry.status === "waiting" && opts.retry.nextEligibleAt ? " · " + formatDateTime(opts.retry.nextEligibleAt, locale) : "")]);
+  if (role.skills && role.skills.length) rows.push([t("role.skills"), h("span.chip-row", null, role.skills.map(function (s) { return chip(s); }))]);
+  return rows;
+}
+`;

package/dist/web/assets/client/domain/taskForms.js

@@ -0,0 +1,197 @@
+export const TASK_FORMS_SCRIPT = String.raw `
+// Task write forms: the discussion composer, queue / steer / interrupt and
+// the title editor. Submission plumbing (requestId, unsent flag, receipts,
+// never replaying an unknown outcome) lives in ui/forms submitWrite().
+import { h, icon, clear } from "/assets/js/lib/dom.js";
+import { fill } from "/assets/js/lib/format.js";
+import { button } from "/assets/js/ui/primitives.js";
+import { segmented } from "/assets/js/ui/controls.js";
+import { field, receiptLine, setReceipt, submitWrite } from "/assets/js/ui/forms.js";
+
+function isOpen(task) {
+  return ["active", "draft"].includes(task.status);
+}
+
+// --- Discussion composer -----------------------------------------------------
+export function messageComposer(task, t, actions) {
+  let intent = "discuss";
+  const form = h("form.composer");
+  const message = h("textarea.composer-input", {
+    required: true, maxLength: 8000, rows: 3, placeholder: t("composer.placeholder"),
+    "aria-label": t("composer.label")
+  });
+  const open = isOpen(task);
+  const send = h("button.btn.btn-primary.composer-send", { type: "submit", disabled: !open, title: t("composer.sendHint") },
+    icon("send"), h("span", null, t("composer.send")));
+  const intents = segmented("intent", ["discuss", "record", "develop"].map(function (value) {
+    return { value: value, label: t("intent." + value), title: t("intent." + value + ".hint") };
+  }), intent, function (value) { intent = value; });
+  const receipt = receiptLine(open ? t("receipt.notSubmitted") : t("composer.closed"));
+  const facets = h("div.facets");
+  form.append(h("div.composer-box", null, message, h("div.composer-bar", null, intents, h("span.spacer"), send)), receipt, facets);
+  form.addEventListener("input", function () { form.dataset.unsent = message.value ? "true" : "false"; });
+  message.addEventListener("keydown", function (event) {
+    if (event.key === "Enter" && (event.metaKey || event.ctrlKey)) { event.preventDefault(); form.requestSubmit(); }
+  });
+  form.addEventListener("submit", function (event) {
+    event.preventDefault();
+    if (send.disabled || !message.value.trim()) return;
+    clear(facets);
+    // requestId is the submission key: the same key retried returns the
+    // original Message and routing, never a second submission.
+    submitWrite({
+      control: send, receipt: receipt, form: form, t: t,
+      send: function (requestId) { return actions.sendMessage(task.id, message.value, requestId, intent); },
+      saved: function (result) {
+        setReceipt(receipt, t("receipt.saved") + " · " + result.record.id, "ok");
+        renderSubmissionFacets(facets, result.submission, t);
+        message.value = "";
+      },
+      rejectedKey: "receipt.notSubmittedBecause", unknownKey: "receipt.unknownMessage", afterWrite: actions.afterWrite
+    });
+  });
+  return form;
+}
+
+// Each submission facet is reported on its own line, never collapsed into a
+// single "started". A missing facet block is a contract violation and is
+// reported as such rather than reinterpreted.
+export function renderSubmissionFacets(container, submission, t) {
+  clear(container);
+  if (!submission) { container.append(h("p.faint.small", null, t("facet.missing"))); return; }
+  const rows = [
+    ["facet.phase", "phase." + submission.phase, submission.phase],
+    ["facet.planning", "planningFacet." + submission.planning, submission.planning],
+    ["facet.activation", "activation." + submission.activation, submission.activation],
+    ["facet.delivery", "deliveryFacet." + submission.delivery, submission.delivery]
+  ];
+  container.append(h("dl.kv.kv-compact", null, rows.map(function (row) {
+    return [h("dt", null, t(row[0])), h("dd", null, t(row[1], row[2]))];
+  })));
+  const step = submission.nextStep;
+  const text = step ? nextStepText(step, t) : "";
+  if (text) container.append(h("p.next-step", { dataset: { nextStep: step.kind } }, icon("flag", "icon-sm"), h("span", null, text)));
+}
+
+function nextStepText(step, t) {
+  if (step.kind === "activate-manually") return fill(t("next.activateManually"), { task: step.taskId });
+  if (step.kind === "start-execution") return fill(t("next.startExecution"), { task: step.taskId });
+  if (step.kind === "await-pending-activation") return fill(t("next.awaitActivation"), { ref: step.activationRef });
+  if (step.kind === "resolve-failed-activation") return fill(t("next.resolveFailed"), { failure: step.failure, ref: step.activationRef });
+  return "";
+}
+
+// --- Queue / steer / interrupt ----------------------------------------------
+// The same three application-layer actions the CLI drives. Steer and
+// interrupt name an exact current Turn; a mismatch is a visible failure
+// receipt, never a silent downgrade to a queue.
+export function controlForm(task, t, actions, roleNames) {
+  let kind = "queue";
+  const form = h("form.stack");
+  const inputs = controlInputs(task, t, roleNames);
+  const fields = controlFields(inputs, t);
+  const submit = button(t("control.submit"), { type: "submit", variant: "primary", icon: "send", disabled: !isOpen(task) });
+  const receipt = receiptLine(t("receipt.notSubmitted"));
+  const apply = function () { applyControlKind(kind, inputs, fields); };
+  const actionsSeg = segmented("action", ["queue", "steer", "interrupt"].map(function (value) {
+    return { value: value, label: t("control." + value), title: t("control." + value + ".hint") };
+  }), kind, function (value) { kind = value; apply(); });
+  form.append(h("div.field", null, h("span", null, t("control.action")), actionsSeg),
+    h("div.field-row", null, fields.role, fields.workItem), inputs.roles, fields.body, fields.expected, fields.then,
+    h("div.form-actions", null, submit), receipt);
+  apply();
+  form.addEventListener("input", function () { form.dataset.unsent = "true"; });
+  form.addEventListener("submit", function (event) {
+    event.preventDefault();
+    if (submit.disabled) return;
+    submitWrite({
+      control: submit, receipt: receipt, form: form, t: t,
+      send: function (requestId) { return actions.control(task.id, controlPayload(kind, inputs, requestId)); },
+      // The receipt states exactly what settled; none of these states implies
+      // the Provider executed the input.
+      saved: function (result) { setReceipt(receipt, controlReceipt(result, t), "ok"); },
+      rejectedKey: "receipt.notSubmittedBecause", unknownKey: "receipt.unknownControl", afterWrite: actions.afterWrite
+    });
+  });
+  return form;
+}
+
+function controlInputs(task, t, roleNames) {
+  return {
+    role: h("input", { list: "control-roles-" + task.id, placeholder: t("control.rolePlaceholder") }),
+    roles: h("datalist", { id: "control-roles-" + task.id }, (roleNames || []).map(function (name) { return h("option", { value: name }); })),
+    body: h("textarea", { maxLength: 8000, rows: 3 }),
+    expected: h("input.mono", { placeholder: t("control.expectedPlaceholder") }),
+    workItem: h("input.mono"),
+    then: h("input.mono", { placeholder: t("control.thenPlaceholder") })
+  };
+}
+
+function controlFields(inputs, t) {
+  return {
+    role: field(t("control.role"), inputs.role),
+    body: field(t("control.message"), inputs.body),
+    expected: field(t("control.expectedTurn"), inputs.expected, t("control.expectedHint")),
+    workItem: field(t("control.workItem"), inputs.workItem),
+    then: field(t("control.then"), inputs.then)
+  };
+}
+
+function applyControlKind(kind, inputs, fields) {
+  fields.body.hidden = kind === "interrupt";
+  fields.expected.hidden = kind === "queue";
+  fields.then.hidden = kind !== "interrupt";
+  fields.workItem.hidden = kind === "interrupt";
+  inputs.role.required = kind !== "queue";
+  inputs.body.required = kind !== "interrupt";
+  inputs.expected.required = kind !== "queue";
+}
+
+function controlPayload(kind, inputs, requestId) {
+  const payload = { action: kind, requestId: requestId };
+  const role = inputs.role.value.trim();
+  if (kind === "interrupt") {
+    payload.role = role;
+    payload.expectedTarget = inputs.expected.value.trim();
+    if (inputs.then.value.trim()) payload.thenMessage = inputs.then.value.trim();
+    return payload;
+  }
+  payload.body = inputs.body.value;
+  if (kind === "steer") { payload.to = role; payload.expectedTarget = inputs.expected.value.trim(); }
+  else if (role) payload.to = role;
+  if (inputs.workItem.value.trim()) payload.workItem = inputs.workItem.value.trim();
+  return payload;
+}
+
+function controlReceipt(result, t) {
+  const settled = result.steer || result.interrupt || result.delivery || { state: result.disposition };
+  return t("receipt.receipt") + " " + result.action + " · " + settled.state
+    + (settled.outcome ? " · " + settled.outcome : "") + (settled.detail ? " · " + settled.detail : "")
+    + (result.record ? " · " + result.record.id : "");
+}
+
+// --- Title -------------------------------------------------------------------
+export function titleForm(task, t, actions) {
+  const form = h("form.inline-form");
+  const archived = task.status === "archived";
+  const input = h("input", { value: task.title, required: true, maxLength: 500, disabled: archived, "aria-label": t("details.title") });
+  const save = button(t("actions.save"), { type: "submit", variant: "primary", disabled: archived });
+  const receipt = receiptLine(t("receipt.notSubmitted"));
+  form.append(h("div.inline-row", null, input, save), receipt);
+  form.addEventListener("input", function () { form.dataset.unsent = input.value !== task.title ? "true" : "false"; });
+  form.addEventListener("submit", function (event) {
+    event.preventDefault();
+    if (save.disabled) return;
+    submitWrite({
+      control: save, receipt: receipt, form: form, t: t,
+      send: function (requestId) { return actions.updateTask(task.id, { title: input.value }, requestId); },
+      saved: function (result) {
+        setReceipt(receipt, t("receipt.savedRevision") + " " + result.revision, "ok");
+        input.value = result.record.title;
+      },
+      rejectedKey: "receipt.notSavedBecause", unknownKey: "receipt.unknownSave", afterWrite: actions.afterWrite
+    });
+  });
+  return form;
+}
+`;

package/dist/web/assets/client/domain/vocab.js

@@ -0,0 +1,69 @@
+import { AGENT_ADAPTER_CATALOG } from "../../../../agent/adapterCatalog.js";
+import { AGENT_EXECUTION_COMPONENT_CATALOG } from "../../../../agent/executionComponents.js";
+export const VOCAB_SCRIPT = String.raw `
+// Domain vocabulary: translated labels, semantic tones and the status badges
+// built from them. Unknown values stay visible verbatim, never hidden or
+// guessed.
+import { h } from "/assets/js/lib/dom.js";
+import { badge, chip } from "/assets/js/ui/primitives.js";
+
+// Generated from the server catalogs, not a second product registry.
+const adapterLabels = ${JSON.stringify(Object.fromEntries(AGENT_ADAPTER_CATALOG.map(({ id, label }) => [id, label])))};
+const componentLabels = ${JSON.stringify(Object.fromEntries(AGENT_EXECUTION_COMPONENT_CATALOG.map(({ id, label }) => [id, label])))};
+export function agentLabel(component, adapterId) {
+  return component ? componentLabels[component] || component : adapterLabels[adapterId] || adapterId;
+}
+
+export function label(t, prefix, value) {
+  if (value === undefined || value === null || value === "") return "—";
+  return t(prefix + "." + value, String(value).replace(/[-_]/g, " "));
+}
+
+const TONES = {
+  task: { draft: "warn", active: "info", completed: "ok", cancelled: "idle", archived: "idle" },
+  exec: {
+    "needs-leader-action": "accent", "waiting-on-agents": "info", "waiting-user": "warn",
+    recovering: "warn", attention: "bad", "progressing-with-attention": "warn", blocked: "bad",
+    conflicted: "warn", working: "info", completed: "ok", retired: "idle", cancelled: "idle",
+    accepted: "ok", open: "info", archived: "idle"
+  },
+  run: { active: "info", completed: "ok", failed: "bad" },
+  work: { open: "info", accepted: "ok", retired: "idle" },
+  review: { pending: "idle", running: "info", completed: "ok", failed: "bad" },
+  job: { queued: "idle", running: "info", succeeded: "ok", failed: "bad", "timed-out": "bad",
+    cancelled: "idle", "unknown-needs-attention": "warn" },
+  session: { active: "ok", waiting: "warn", quiet: "idle", diagnostic: "bad", unknown: "idle",
+    stopped: "bad", idle: "idle", background: "warn" },
+  role: { running: "ok", waiting: "warn", idle: "idle", unknown: "idle", failed: "bad", exited: "idle", detached: "idle" },
+  decision: { active: "ok", superseded: "idle" },
+  input: { open: "warn", answered: "ok", cancelled: "idle", "auto-resolved": "ok" },
+  integration: { running: "info", validating: "info", committed: "ok", conflicted: "warn", blocked: "bad",
+    failed: "bad", superseded: "idle" }
+};
+export function tone(kind, value) {
+  return (TONES[kind] && TONES[kind][value]) || "idle";
+}
+
+export function statusBadge(t, kind, prefix, value) {
+  const element = badge(label(t, prefix, value), tone(kind, value), { dot: true });
+  element.dataset.status = value;
+  return element;
+}
+
+// Native Session groups in display order, and one badge per non-empty group.
+export const SESSION_GROUPS = ["active", "waiting", "background", "quiet", "diagnostic", "stopped", "unknown", "idle"];
+export function sessionBadges(counts, t) {
+  return SESSION_GROUPS.filter(function (group) { return counts && counts[group]; }).map(function (group) {
+    return badge(counts[group] + " " + t("session." + group), tone("session", group), { dot: true });
+  });
+}
+
+export function agentChips(agent) {
+  if (!agent) return null;
+  const chips = [];
+  if (agent.adapterId || agent.component) chips.push(chip(agentLabel(agent.component, agent.adapterId), "chip-strong"));
+  if (agent.model) chips.push(chip(agent.model));
+  if (agent.effort) chips.push(chip(agent.effort));
+  return chips.length ? h("span.chip-row", null, chips) : null;
+}
+`;