@zq-silk/yui 2.0.0 → 2.2.0

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

@@ -0,0 +1,172 @@
+export const EVIDENCE_SCRIPT = String.raw `
+// Results and evidence. Files are read on request at a fixed revision; the
+// selected revision survives refreshes. Reading never accepts, publishes or
+// executes a result.
+import { h, icon, clear } from "/assets/js/dom.js";
+import { formatBytes } from "/assets/js/format.js";
+import { card, button, note, mono, emptyState, richText, badge, observabilityMetricCard } from "/assets/js/components.js";
+
+export function renderEvidence(container, data, t, locale, actions) {
+  const state = data.viewState;
+  const files = card({ title: t("evidence.files"), icon: "file", hint: t("evidence.filesHint") });
+  const list = h("div.file-list");
+  const viewer = h("div.file-viewer");
+  const load = button(state.artifactList ? t("evidence.reload") : t("evidence.load"), { icon: "refresh", variant: "ghost" });
+  files.querySelector(".card-head").append(h("div.card-actions", null, load));
+  let readSequence = 0;
+  async function read(path, commit) {
+    const sequence = ++readSequence;
+    viewer.dataset.reading = "true";
+    clear(viewer);
+    viewer.append(h("p.faint", null, t("evidence.reading")));
+    try {
+      const result = await actions.readArtifact(data.task.id, path, commit);
+      if (sequence !== readSequence) return;
+      state.artifact = result;
+      drawViewer();
+    } catch (error) {
+      if (sequence === readSequence) { clear(viewer); viewer.append(note(t("evidence.unavailable") + " " + error.message, "bad")); }
+    } finally { if (sequence === readSequence) viewer.dataset.reading = "false"; }
+  }
+  function drawViewer() {
+    clear(viewer);
+    const value = state.artifact;
+    if (!value) return;
+    const ref = "git:" + value.commit + ":" + value.relativePath;
+    const copy = button(t("evidence.copy"), { icon: "copy", variant: "ghost" });
+    copy.addEventListener("click", async function () {
+      try { await navigator.clipboard.writeText(data.task.id + " " + ref); copy.lastChild.textContent = t("evidence.copied"); }
+      catch { copy.lastChild.textContent = t("evidence.copyManual"); }
+    });
+    viewer.append(h("header.viewer-head", null, icon("file"), h("strong", null, value.relativePath), h("span.spacer"), copy));
+    viewer.append(h("p.viewer-ref", null, mono(ref)));
+    viewer.append(h("p.faint.small", null, t("evidence.fixedNote")));
+    const content = h("pre.code-block.artifact-text", { tabIndex: 0, "aria-label": t("evidence.fixedText") }, value.content);
+    viewer.append(content);
+  }
+  function drawList() {
+    clear(list);
+    const current = state.artifactList;
+    if (!current) return;
+    if (state.artifact && current.commit !== state.artifact.commit) list.append(note(t("evidence.differentRevision")));
+    if (!current.entries.length) { list.append(emptyState(t("evidence.noFiles"), "file")); return; }
+    current.entries.forEach(function (entry) {
+      list.append(h("button.file-row", {
+        type: "button",
+        "aria-current": String(!!state.artifact && state.artifact.relativePath === entry.relativePath && state.artifact.commit === current.commit),
+        onclick: function () { read(entry.relativePath, current.commit); }
+      }, icon("file", "icon-sm"), h("span.file-name", null, entry.relativePath), h("span.faint.small", null, formatBytes(entry.size))));
+    });
+  }
+  load.addEventListener("click", async function () {
+    load.disabled = true;
+    list.dataset.reading = "true";
+    try {
+      state.artifactList = await actions.artifacts(data.task.id);
+      drawList();
+    } catch (error) {
+      clear(list);
+      list.append(note(t("evidence.listUnavailable") + " " + error.message, "bad"));
+    } finally { load.disabled = false; list.dataset.reading = "false"; }
+  });
+  // Explicit frozen references stay attached to their original revision.
+  const sources = [data.task.completionArtifactRefs || [],
+    data.core.records.filter(function (entry) { return !entry.omitted && ["task-brief", "task-decision"].includes(entry.ref.store); })
+      .map(function (entry) { return JSON.stringify(entry.value); })].flat().join(" ");
+  const refs = Array.from(sources.matchAll(/git:([0-9a-f]{40}):([^\s"\\]+?)(?=[\s"\\]|$)/g));
+  const seen = new Set();
+  const referenced = h("div.file-list");
+  refs.forEach(function (match) {
+    if (seen.has(match[0])) return;
+    seen.add(match[0]);
+    referenced.append(h("button.file-row", { type: "button", onclick: function () { read(match[2], match[1]); } },
+      icon("flag", "icon-sm"), h("span.file-name", null, match[2]), badge(t("evidence.referenced"), "accent")));
+  });
+  if (!state.artifactList && !seen.size) files.body.append(emptyState(t("evidence.notLoaded"), "file"));
+  files.body.append(referenced, list, viewer);
+  drawList();
+  drawViewer();
+  container.append(files);
+
+  const delivery = card({ title: t("evidence.delivery"), icon: "layers", hint: t("evidence.deliveryHint") });
+  const output = h("div.stack");
+  const open = button(t("evidence.readDelivery"), { icon: "eye", variant: "ghost" });
+  delivery.querySelector(".card-head").append(h("div.card-actions", null, open));
+  delivery.body.append(output);
+  open.addEventListener("click", function () {
+    open.disabled = true;
+    drawDelivery(output, data, t, actions).finally(function () { open.disabled = false; });
+  });
+  container.append(delivery);
+}
+
+async function drawDelivery(output, data, t, actions) {
+  clear(output);
+  const runtime = data.runtimeStatus === "available" ? data.runtime : null;
+  if (!runtime) output.append(note(t("evidence.observationUnavailable")));
+  const remote = runtime && runtime.remoteDelivery;
+  if (remote) {
+    output.append(h("h4.sub-head", null, t("evidence.remote"), badge(t("remoteDelivery." + remote.status, remote.status), remote.status === "merged" ? "ok" : "idle")));
+    remote.projects.forEach(function (project) {
+      output.append(h("article.record", null,
+        h("header.record-head", null, h("strong", null, project.directory), h("span.faint.small", null, project.coverage)),
+        h("p.small", null, project.reason),
+        h("p.faint.small", null, t("evidence.expectedCommit") + " ", mono(project.expectedLocalCommit || t("common.unknown"))),
+        h("p.faint.small", null, "PR/MR · " + (project.state || "none") + " · " + t("evidence.verification") + " " + (project.verification || "unverified")),
+        project.adoption ? h("p.faint.small", null, t("evidence.adoption") + " ", mono(project.adoption.id)) : null));
+    });
+  }
+  const original = h("div.stack", null, h("p.faint", null, t("evidence.readingOriginal")));
+  output.append(original);
+  try {
+    const evidence = await actions.evidence(data.task.id);
+    clear(original);
+    original.append(h("h4.sub-head", null, t("evidence.integrations")));
+    if (!evidence.integrations.length) original.append(note(t("evidence.noIntegrations")));
+    evidence.integrations.forEach(function (attempt) {
+      const element = h("article.record", null,
+        h("header.record-head", null, mono(attempt.id), h("span.spacer"), badge(attempt.status, attempt.status === "succeeded" ? "ok" : "idle")),
+        h("p.faint.small", null, t("evidence.candidate") + " ", mono(attempt.candidateCommit || t("evidence.noCandidate"))));
+      if (!attempt.checks || !attempt.checks.length) element.append(h("p.faint.small", null, t("evidence.noChecks")));
+      (attempt.checks || []).forEach(function (check) {
+        element.append(h("p.small", null, check.name + " · " + check.outcome));
+        if (check.details) element.append(h("p.faint.small", null, check.details));
+      });
+      original.append(element);
+    });
+    original.append(h("h4.sub-head", null, t("evidence.reviews")));
+    if (!evidence.reviews.length) original.append(note(t("evidence.noReviews")));
+    evidence.reviews.forEach(function (round) {
+      const element = h("article.record", null,
+        h("header.record-head", null, mono(round.id), h("span.spacer"), badge(round.status, round.status === "completed" ? "ok" : "idle")),
+        h("p.faint.small.mono-line", null, round.taskCandidate
+          ? round.taskCandidate.projects.map(function (p) { return p.projectId + " · " + p.commit; }).join("  ")
+          : [round.workItemId, round.candidateId, round.reviewBaseCommit].filter(Boolean).join(" · ")));
+      if (round.reviewerRunId) {
+        const report = button(t("evidence.readReport"), { icon: "eye", variant: "link" });
+        report.addEventListener("click", async function () {
+          report.disabled = true;
+          try {
+            const source = await actions.inspect(data.task.id, { store: "run", refId: round.reviewerRunId });
+            element.append(richText(round.reviewerRunId, (source.value.result && source.value.result.output) || t("evidence.noReport"), t));
+            report.remove();
+          } catch (error) { element.append(note(error.message, "bad")); report.disabled = false; }
+        });
+        element.append(report);
+      }
+      original.append(element);
+    });
+    original.append(h("h4.sub-head", null, t("evidence.workspaces")));
+    if (!evidence.workspaces.length) original.append(note(t("evidence.noWorkspaces")));
+    evidence.workspaces.forEach(function (workspace) {
+      original.append(h("p.small.mono-line", null, workspace.owner.type + " · " + workspace.root));
+    });
+    original.append(note(t("evidence.cleanupNote")), h("pre.code-block", null, "yui task archive-preflight " + data.task.id + " --integrated"));
+  } catch (error) {
+    clear(original);
+    original.append(note(t("evidence.originalUnavailable") + " " + error.message, "bad"));
+  }
+  const metrics = runtime && observabilityMetricCard(runtime.observability, t);
+  if (metrics) output.append(h("h4.sub-head", null, t("evidence.usage")), metrics);
+}
+`;

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

@@ -1,20 +1,13 @@
-export const FORMAT_SCRIPT = `
-// Date / time formatting helpers shared by cards and views.
+export const FORMAT_SCRIPT = String.raw `
+// Date / number formatting shared by every view.
 export function relativeTime(iso, locale, t) {
   const seconds = Math.round((Date.parse(iso) - Date.now()) / 1000);
-  if (!Number.isFinite(seconds) || Math.abs(seconds) < 45) return t("time.justNow");
-  const units = [
-    ["year", 31536000],
-    ["month", 2592000],
-    ["day", 86400],
-    ["hour", 3600],
-    ["minute", 60]
-  ];
+  if (!Number.isFinite(seconds)) return "—";
+  if (Math.abs(seconds) < 45) return t("time.justNow");
+  const units = [["year", 31536000], ["month", 2592000], ["day", 86400], ["hour", 3600], ["minute", 60]];
   const selected = units.find(function (entry) { return Math.abs(seconds) >= entry[1]; }) || ["second", 1];
-  return new Intl.RelativeTimeFormat(locale, { numeric: "auto" }).format(
-    Math.round(seconds / selected[1]),
-    selected[0]
-  );
+  return new Intl.RelativeTimeFormat(locale, { numeric: "auto", style: "short" })
+    .format(Math.round(seconds / selected[1]), selected[0]);
 }
 
 export function formatDateTime(iso, locale) {
@@ -22,6 +15,24 @@ export function formatDateTime(iso, locale) {
   return new Intl.DateTimeFormat(locale, { dateStyle: "medium", timeStyle: "short" }).format(new Date(iso));
 }
 
+export function formatClock(iso, locale) {
+  if (!iso || !Number.isFinite(Date.parse(iso))) return "—";
+  return new Intl.DateTimeFormat(locale, { hour: "2-digit", minute: "2-digit", second: "2-digit" }).format(new Date(iso));
+}
+
+export function formatShort(iso, locale) {
+  if (!iso || !Number.isFinite(Date.parse(iso))) return "";
+  return new Intl.DateTimeFormat(locale, { month: "short", day: "numeric", hour: "2-digit", minute: "2-digit" })
+    .format(new Date(iso));
+}
+
+export function formatBytes(value) {
+  if (!Number.isFinite(value)) return "—";
+  if (value < 1024) return value + " B";
+  if (value < 1024 * 1024) return (value / 1024).toFixed(1) + " KB";
+  return (value / 1024 / 1024).toFixed(1) + " MB";
+}
+
 export function byNewest(left, right) {
   return Date.parse(right.updatedAt || right.createdAt) - Date.parse(left.updatedAt || left.createdAt);
 }

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

@@ -0,0 +1,230 @@
+export const FORMS_SCRIPT = String.raw `
+// Write forms. Each submission carries a fresh requestId, marks itself unsent
+// until a receipt settles, and reports an unknown outcome as unknown: nothing
+// here ever replays a write automatically.
+import { h, icon, clear } from "/assets/js/dom.js";
+import { button } from "/assets/js/components.js";
+
+function receiptLine(text, state) {
+  const line = h("p.receipt", { role: "status" }, text);
+  if (state) line.dataset.state = state;
+  return line;
+}
+function setReceipt(line, text, state) {
+  line.textContent = text;
+  line.dataset.state = state || "";
+}
+
+function segmented(name, options, value, onChange) {
+  const group = h("div.seg.seg-sm", { role: "radiogroup" });
+  options.forEach(function (option) {
+    const item = h("button.seg-btn", {
+      type: "button", role: "radio", title: option.title || null,
+      "aria-checked": String(option.value === value),
+      dataset: { value: option.value },
+      onclick: function () {
+        group.querySelectorAll(".seg-btn").forEach(function (other) { other.setAttribute("aria-checked", String(other === item)); });
+        onChange(option.value);
+      }
+    }, option.label);
+    group.append(item);
+  });
+  group.dataset.name = name;
+  return group;
+}
+
+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 = ["active", "draft"].includes(task.status);
+  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", [
+    { value: "discuss", label: t("intent.discuss"), title: t("intent.discuss.hint") },
+    { value: "record", label: t("intent.record"), title: t("intent.record.hint") },
+    { value: "develop", label: t("intent.develop"), title: t("intent.develop.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", async function (event) {
+    event.preventDefault();
+    if (send.disabled || !message.value.trim()) return;
+    send.disabled = true;
+    form.dataset.unsent = "true";
+    const requestId = crypto.randomUUID();
+    clear(facets);
+    setReceipt(receipt, t("receipt.waiting") + " · " + requestId, "pending");
+    try {
+      // requestId is the submission key: the same key retried returns the
+      // original Message and routing, never a second submission.
+      const result = await actions.sendMessage(task.id, message.value, requestId, intent);
+      setReceipt(receipt, t("receipt.saved") + " · " + result.record.id, "ok");
+      renderSubmissionFacets(facets, result.submission, t);
+      message.value = "";
+      form.dataset.unsent = "false";
+      send.disabled = false;
+      if (actions.afterWrite) actions.afterWrite();
+    } catch (error) {
+      if (error.disposition === "not-submitted") {
+        setReceipt(receipt, t("receipt.notSubmittedBecause") + " " + error.message, "bad");
+        send.disabled = false;
+        return;
+      }
+      setReceipt(receipt, t("receipt.unknownMessage") + " · " + requestId, "warn");
+    }
+  });
+  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;
+  if (!step) return;
+  const text = step.kind === "activate-manually" ? t("next.activateManually").replace("{task}", step.taskId)
+    : step.kind === "start-execution" ? t("next.startExecution").replace("{task}", step.taskId)
+    : step.kind === "await-pending-activation" ? t("next.awaitActivation").replace("{ref}", step.activationRef)
+    : step.kind === "resolve-failed-activation" ? t("next.resolveFailed").replace("{failure}", step.failure).replace("{ref}", step.activationRef)
+    : "";
+  if (text) container.append(h("p.next-step", { dataset: { nextStep: step.kind } }, icon("flag", "icon-sm"), h("span", null, text)));
+}
+
+// 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 role = h("input", { list: "control-roles-" + task.id, placeholder: t("control.rolePlaceholder") });
+  const roles = h("datalist", { id: "control-roles-" + task.id }, (roleNames || []).map(function (name) { return h("option", { value: name }); }));
+  const body = h("textarea", { maxLength: 8000, rows: 3 });
+  const expected = h("input.mono", { placeholder: t("control.expectedPlaceholder") });
+  const workItem = h("input.mono");
+  const then = h("input.mono", { placeholder: t("control.thenPlaceholder") });
+  const field = function (text, control, hint) {
+    return h("label.field", null, h("span", null, text), control, hint ? h("small.faint", null, hint) : null);
+  };
+  const roleField = field(t("control.role"), role);
+  const bodyField = field(t("control.message"), body);
+  const expectedField = field(t("control.expectedTurn"), expected, t("control.expectedHint"));
+  const workItemField = field(t("control.workItem"), workItem);
+  const thenField = field(t("control.then"), then);
+  const open = ["active", "draft"].includes(task.status);
+  const submit = button(t("control.submit"), { type: "submit", variant: "primary", icon: "send", disabled: !open });
+  const receipt = receiptLine(t("receipt.notSubmitted"));
+  function apply() {
+    bodyField.hidden = kind === "interrupt";
+    expectedField.hidden = kind === "queue";
+    thenField.hidden = kind !== "interrupt";
+    workItemField.hidden = kind === "interrupt";
+    role.required = kind !== "queue";
+    body.required = kind !== "interrupt";
+    expected.required = kind !== "queue";
+  }
+  const actionsSeg = segmented("action", [
+    { value: "queue", label: t("control.queue"), title: t("control.queue.hint") },
+    { value: "steer", label: t("control.steer"), title: t("control.steer.hint") },
+    { value: "interrupt", label: t("control.interrupt"), title: t("control.interrupt.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, roleField, workItemField), roles, bodyField, expectedField, thenField,
+    h("div.form-actions", null, submit), receipt);
+  apply();
+  form.addEventListener("input", function () { form.dataset.unsent = "true"; });
+  form.addEventListener("submit", async function (event) {
+    event.preventDefault();
+    if (submit.disabled) return;
+    submit.disabled = true;
+    form.dataset.unsent = "true";
+    const requestId = crypto.randomUUID();
+    const payload = { action: kind, requestId };
+    if (kind === "interrupt") {
+      payload.role = role.value.trim();
+      payload.expectedTarget = expected.value.trim();
+      if (then.value.trim()) payload.thenMessage = then.value.trim();
+    } else {
+      payload.body = body.value;
+      if (kind === "steer") { payload.to = role.value.trim(); payload.expectedTarget = expected.value.trim(); }
+      else if (role.value.trim()) payload.to = role.value.trim();
+      if (workItem.value.trim()) payload.workItem = workItem.value.trim();
+    }
+    setReceipt(receipt, t("receipt.waiting") + " · " + requestId, "pending");
+    try {
+      // The receipt states exactly what settled; none of these states implies
+      // the Provider executed the input.
+      const result = await actions.control(task.id, payload);
+      const settled = result.steer || result.interrupt || result.delivery || { state: result.disposition };
+      setReceipt(receipt, t("receipt.receipt") + " " + result.action + " · " + settled.state
+        + (settled.outcome ? " · " + settled.outcome : "") + (settled.detail ? " · " + settled.detail : "")
+        + (result.record ? " · " + result.record.id : ""), "ok");
+      form.dataset.unsent = "false";
+      submit.disabled = false;
+      if (actions.afterWrite) actions.afterWrite();
+    } catch (error) {
+      if (error.disposition === "not-submitted") {
+        setReceipt(receipt, t("receipt.notSubmittedBecause") + " " + error.message, "bad");
+        submit.disabled = false;
+        return;
+      }
+      setReceipt(receipt, t("receipt.unknownControl") + " · " + requestId, "warn");
+    }
+  });
+  return form;
+}
+
+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", async function (event) {
+    event.preventDefault();
+    if (save.disabled) return;
+    save.disabled = true;
+    form.dataset.unsent = "true";
+    const requestId = crypto.randomUUID();
+    setReceipt(receipt, t("receipt.waiting") + " · " + requestId, "pending");
+    try {
+      const result = await actions.updateTask(task.id, { title: input.value }, requestId);
+      setReceipt(receipt, t("receipt.savedRevision") + " " + result.revision, "ok");
+      input.value = result.record.title;
+      form.dataset.unsent = "false";
+      save.disabled = false;
+      if (actions.afterWrite) actions.afterWrite();
+    } catch (error) {
+      if (error.disposition === "not-submitted") {
+        setReceipt(receipt, t("receipt.notSavedBecause") + " " + error.message, "bad");
+        save.disabled = false;
+        return;
+      }
+      // A lost response must never automatically replay a write.
+      setReceipt(receipt, t("receipt.unknownSave") + " · " + requestId, "warn");
+    }
+  });
+  return form;
+}
+`;