@zq-silk/yui 2.11.0 → 2.12.0

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

@@ -1,6 +1,7 @@
 export const JOBS_SCRIPT = String.raw `
 import { h } from "/assets/js/lib/dom.js";
 import { requestJson, submitMutation } from "/assets/js/lib/api.js";
+import { drawArtifact } from "/assets/js/views/task/files.js";
 
 // One view for two server-fixed scopes. Refresh only reads facts; it never
 // admits due work, derives nextDue or replaces a selected exact Run with latest.
@@ -11,7 +12,17 @@ export function mountJobs(root, t, taskId) {
   const list = h("div.jobs-list");
   const detail = h("section.jobs-detail", { "aria-label": copy("details") });
   const editor = h("section");
-  let jobs = [], schedules = [], selected, selectedRun, generation = 0, pending = false, dirty = false;
+  const params = new URLSearchParams(location.search);
+  let jobs = [], schedules = [], selected = params.get("job") || undefined,
+    selectedRun = params.get("jobRun") || undefined, generation = 0, runGeneration = 0, pending = false, dirty = false;
+  const artifactState = {};
+  try { artifactState.reference = JSON.parse(params.get("artifact") || "null"); } catch {}
+  function pinSelection() {
+    const url = new URL(location.href);
+    if (selected) url.searchParams.set("job", selected); else url.searchParams.delete("job");
+    if (selectedRun) url.searchParams.set("jobRun", selectedRun); else url.searchParams.delete("jobRun");
+    history.replaceState(history.state, "", url);
+  }
   const blocked = new Set();
   const read = (family, input) => requestJson(base + "/" + family + "?" + new URLSearchParams(input));
   const button = (text, action, primary = false) => h("button.btn" + (primary ? ".btn-primary" : ""), {
@@ -40,6 +51,11 @@ export function mountJobs(root, t, taskId) {
     status(copy("submitting"));
     try {
       const result = await submitMutation(key, base + "/" + family, payload);
+      if (result.status === "saved-unregistered") {
+        status(copy("registerHelp") + "\n" + result.error, true);
+        await refresh(false);
+        return;
+      }
       status(payload.op === "run"
         ? (result.reason === "overlap" ? copy("overlap") : copy("admitted")) + " · " + result.run.id + " · " + result.run.status
         : payload.op === "run-cancel" ? copy("cancelRequested") : copy("saved"));
@@ -73,39 +89,53 @@ export function mountJobs(root, t, taskId) {
   function editJob(job) {
     const id = input(job?.id || "", { required: true, pattern: "[a-zA-Z0-9][a-zA-Z0-9._-]{0,127}", disabled: !!job });
     const title = input(job?.title || "", { required: true });
+    const kind = choose(taskId ? ["shell", "task", "agent"] : ["builtin", "task", "agent"], job?.configuration.kind);
+    kind.disabled = !!job;
     const action = choose(["system.noop", "project.refresh"], job?.configuration.action);
     const project = input(job?.configuration.projectId || "");
     const configuration = h("textarea", { rows: 12, required: true });
     configuration.value = JSON.stringify(job?.configuration || { kind: "shell", owner: { kind: "task" },
       projectId: "", head: "", workspace: "", env: {}, steps: [{ name: "check", command: "true" }] }, null, 2);
-    const fields = [field("ID", id), field(copy("name"), title)];
-    if (taskId) fields.push(h("p", null, copy("taskConfig")), field(copy("configuration"), configuration));
-    else {
-      fields.push(field(copy("action"), action), field(copy("project"), project), h("p", null, copy("rebind")));
-      const sync = () => { project.disabled = action.value !== "project.refresh"; project.required = !project.disabled; };
-      action.addEventListener("change", sync); sync();
-    }
+    const controlled = h("div", null, field(copy("action"), action), field(copy("project"), project), h("p", null, copy("rebind")));
+    const configured = h("div", null, h("p", null, copy("taskConfig")), field(copy("configuration"), configuration));
+    const fields = [field("ID", id), field(copy("name"), title), field(copy("executor"), kind), controlled, configured];
+    const sync = () => {
+      controlled.hidden = kind.value !== "builtin"; configured.hidden = !controlled.hidden;
+      project.disabled = controlled.hidden || action.value !== "project.refresh"; project.required = !project.disabled;
+      configuration.required = !configured.hidden;
+    };
+    kind.addEventListener("change", () => {
+      configuration.value = JSON.stringify(kind.value === "agent"
+        ? { kind: "agent", target: { kind: "job", agentId: "" }, input: "", concurrency: "serial" }
+        : kind.value === "task" ? { kind: "task", goal: "delivery", target: {
+          kind: "new", title: "", description: "", projectBindings: [] } }
+        : { kind: "shell", owner: { kind: "task" }, projectId: "", head: "", workspace: "", env: {},
+          steps: [{ name: "check", command: "true" }] }, null, 2);
+      sync();
+    });
+    action.addEventListener("change", sync); sync();
     form(job ? copy("editJob") : copy("newJob"), fields, () => {
-      const config = taskId ? JSON.parse(configuration.value) : {
+      const config = kind.value !== "builtin" ? JSON.parse(configuration.value) : {
         kind: "builtin", action: action.value, input: {},
         ...(action.value === "project.refresh" ? { projectId: project.value.trim() } : {})
       };
       void mutate("jobs", { op: job ? "update" : "define", id: id.value.trim(), title: title.value.trim(),
         configuration: config, ...(job ? { expectedRevision: job.revision } : {}) }, result => {
-        selected = result.id; selectedRun = undefined; closeEditor();
+          selected = result.id; selectedRun = undefined; pinSelection(); closeEditor();
       });
     });
   }
   function editSchedule(schedule) {
     const id = input(schedule?.id || "", { required: true, disabled: !!schedule });
-    const jobId = choose(jobs.map(j => j.id), schedule?.jobId || selected);
-    const kind = choose(["once", "interval", "cron"], schedule?.rule.kind || "interval");
+    const jobId = choose(jobs.filter(j => !j.builtin || j.id === schedule?.jobId).map(j => j.id), schedule?.jobId || selected);
+    jobId.disabled = !!schedule?.builtin;
+    const kind = choose(schedule?.builtin ? ["interval", "cron"] : ["once", "interval", "cron"], schedule?.rule.kind || "interval");
     const rule = schedule?.rule;
     const at = input(rule?.at || rule?.anchor || "", { placeholder: "2026-10-17T09:00:00+08:00" });
-    const every = input(String(rule?.everyMs || 3600000), { type: "number", min: 1000, step: 1 });
+    const every = input(String(rule?.everyMs || 3600000), { type: "number", min: schedule?.builtin ? 60000 : 1000, step: 1 });
     const expression = input(rule?.expression || "0 9 * * *");
     const timezone = input(rule?.timezone || Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC");
-    const when = field(copy("instant"), at), interval = field(copy("every"), every);
+    const when = field(copy("instant"), at), interval = field(copy(schedule?.builtin ? "syncEvery" : "every"), every);
     const cron = field(copy("cron"), expression), zone = field(copy("timezone"), timezone);
     const sync = () => {
       when.hidden = kind.value === "cron"; interval.hidden = kind.value !== "interval";
@@ -118,31 +148,119 @@ export function mountJobs(root, t, taskId) {
       const rule = kind.value === "once" ? { kind: "once", at: at.value }
         : kind.value === "interval" ? { kind: "interval", anchor: at.value, everyMs: Number(every.value) }
         : { kind: "cron", expression: expression.value, timezone: timezone.value };
-      void mutate("schedules", { op: schedule ? "update" : "create", id: id.value.trim(), jobId: jobId.value, rule,
+      void mutate("schedules", { op: schedule ? "update" : "create", id: id.value.trim(), rule,
+        ...(schedule?.builtin ? {} : { jobId: jobId.value, ...(!taskId ? { authorization: "service" } : {}) }),
         ...(schedule ? { expectedRevision: schedule.revision } : {}) }, closeEditor);
     });
   }
   async function showRun(jobId, runId, target) {
+    const epoch = ++runGeneration;
     selectedRun = runId;
+    pinSelection();
     target.replaceChildren(h("p", null, copy("loading")));
     try {
-      const [run, logs] = await Promise.all([read("jobs", { op: "run-get", id: jobId, runId }),
-        read("jobs", { op: "logs", id: jobId, runId })]);
-      if (selected !== jobId || selectedRun !== runId) return;
-      target.replaceChildren(h("h4", null, run.id), fact(copy("state"), run.status),
+      const run = await read("jobs", { op: "run-get", id: jobId, runId });
+      if (epoch !== runGeneration || selected !== jobId || selectedRun !== runId) return;
+      const evidence = h("section"), artifacts = h("section"), session = h("section");
+      target.replaceChildren(h("div.settings-stack", null, h("h4", null, run.id), fact(copy("state"), run.status),
+        fact(copy("executor"), run.executor || (run.delegation ? "task" : "process")),
+        run.delegation ? h("a.btn", { href: "/?task=" + encodeURIComponent(run.delegation.taskId) },
+          copy("executionTask") + " · " + run.delegation.taskId) : null,
+        ...(run.businessResult ? [h("div", null, fact(copy("result"), run.businessResult.summary),
+          raw(copy("result"), run.businessResult))] : []),
+        run.cancelRequestedAt ? fact(copy("cancelRequested"), run.cancelRequestedAt) : null,
         fact(copy("trigger"), run.trigger.source + " · " + run.trigger.key),
         fact(copy("created"), run.createdAt), fact(copy("finished"), run.terminalAt),
-        raw(copy("snapshot"), run),
-        h("h4", null, copy("logs")), logs.length ? h("div", null, logs.map(log => h("section", null,
-          h("h5", null, log.step + (log.truncated ? " · " + copy("truncated") : "")),
-          h("pre.settings-observation", null, log.text)))) : h("p", null, copy("noLogs")));
+        raw(copy("snapshot"), run), artifacts, evidence, session));
       if (["queued", "running", "unknown-needs-attention"].includes(run.status)) target.prepend(
-        button(copy("cancelRun"), () => void mutate("jobs", { op: "run-cancel", id: jobId, runId })));
-    } catch (error) { target.replaceChildren(h("p.settings-error", null, error.message)); }
+        button(copy("cancelRun"), () => {
+          if (window.confirm(copy("cancelBoundary") + "\n" + runId))
+            void mutate("jobs", { op: "run-cancel", id: jobId, runId });
+        }));
+      drawArtifacts(artifacts, jobId, run, epoch);
+      if (run.executor === "agent" && run.configuration.target.kind === "job") drawSession(session, jobId, runId);
+      try {
+        const value = await read("jobs", { op: "run-evidence", id: jobId, runId });
+        if (epoch !== runGeneration) return;
+        evidence.append(raw(copy("diagnostics"), value));
+        if (run.executor !== "agent" && !run.delegation) {
+          const logs = await read("jobs", { op: "logs", id: jobId, runId });
+          if (epoch !== runGeneration) return;
+          evidence.append(h("h4", null, copy("logs")), logs.length ? h("div", null, logs.map(log => h("section", null,
+            h("h5", null, log.step + (log.truncated ? " · " + copy("truncated") : "")),
+            h("pre.settings-observation", null, log.text)))) : h("p", null, copy("noLogs")));
+        }
+      } catch (error) { if (epoch === runGeneration) evidence.append(h("p.settings-error", null, copy("diagnostics") + ": " + error.message)); }
+    } catch (error) { if (epoch === runGeneration) target.replaceChildren(h("p.settings-error", null, error.message)); }
+  }
+  function drawArtifacts(target, jobId, run, epoch) {
+    const refs = run.artifacts || [];
+    const viewer = h("div.file-viewer");
+    const readRef = async (ref, offset = 0) => {
+      const value = await read("jobs", { op: "artifact-preview", id: jobId, runId: run.id,
+        reference: JSON.stringify(ref), offset: String(offset) });
+      return { ...value, relativePath: ref.relativePath, commit: ref.version };
+    };
+    const select = async (ref, offset = 0) => {
+      artifactState.reference = ref;
+      const url = new URL(location.href);
+      url.searchParams.set("artifact", JSON.stringify(ref));
+      history.replaceState(history.state, "", url);
+      const key = JSON.stringify(ref);
+      viewer.replaceChildren(h("p", null, copy("loading")));
+      try {
+        const value = await readRef(ref, offset);
+        if (epoch !== runGeneration || JSON.stringify(artifactState.reference) !== key) return;
+        drawArtifact(viewer, value, JSON.stringify(ref.owner), t, {
+          compare: false,
+          readArtifact: async (_owner, path, commit, page) => {
+            const exact = refs.find(r => r.relativePath === path && r.version === commit
+              && JSON.stringify(r.owner) === JSON.stringify(ref.owner));
+            if (!exact) throw new Error(copy("registeredOnly"));
+            return readRef(exact, page);
+          }
+        }, (_path, _commit, page) => void select(ref, page), artifactState);
+      } catch (error) { if (epoch === runGeneration && JSON.stringify(artifactState.reference) === key)
+        viewer.replaceChildren(h("p.settings-error", null, error.message)); }
+    };
+    target.append(h("h4", null, copy("artifacts")), h("p", null, copy("registeredOnly")),
+      ...refs.map(ref => button(ref.relativePath + " · " + ref.version.slice(0, 12), () => void select(ref))), viewer);
+    if (artifactState.reference && refs.some(ref => JSON.stringify(ref) === JSON.stringify(artifactState.reference)))
+      void select(artifactState.reference);
+    const recovery = h("div");
+    target.append(button(copy("inspectSaved"), async () => {
+      recovery.replaceChildren();
+      try {
+        const result = await read("jobs", { op: "artifact-list", id: jobId, runId: run.id });
+        const missing = result.repository.saved.filter(ref => !result.artifacts.some(r => JSON.stringify(r) === JSON.stringify(ref)));
+        recovery.append(raw(copy("artifacts"), result), h("p", null, copy("registerHelp")),
+          ...missing.map(ref => button(copy("register") + " · " + ref.relativePath, () => {
+            if (window.confirm(copy("registerHelp") + "\n" + ref.version))
+              void mutate("jobs", { op: "artifact-register", id: jobId, runId: run.id, reference: ref });
+          })));
+      } catch (error) { recovery.append(h("p.settings-error", null, error.message)); }
+    }), recovery);
+  }
+  function drawSession(target, jobId, runId) {
+    target.append(button(copy("inspectSession"), async () => {
+      try {
+        const value = await read("jobs", { op: "session-inspect", id: jobId, runId });
+        const set = value.sessions, current = set?.sessions?.[set.activeAgentId];
+        target.replaceChildren(raw(copy("inspectSession"), value), h("p", null, copy("sessionBoundary")));
+        if (current) target.append(...["session-stop", "session-new"].map(op =>
+          button(copy(op === "session-stop" ? "stopSession" : "newSession"), () => {
+            if (window.confirm(copy("sessionBoundary") + "\n" + current.nativeSessionId))
+              void mutate("jobs", { op, id: jobId, runId, expectedSessionId: current.nativeSessionId });
+          })));
+      } catch (error) { target.append(h("p.settings-error", null, error.message)); }
+    }));
   }
   async function showDetail(epoch) {
     const job = jobs.find(j => j.id === selected);
-    if (!job) { detail.replaceChildren(); return; }
+    if (!job) {
+      detail.replaceChildren(...(selected ? [h("p.settings-error", null, copy("unavailable") + " · " + selected)] : []));
+      return;
+    }
     const [runs, plans] = await Promise.all([
       read("jobs", { op: "runs", id: job.id }),
       Promise.all(schedules.filter(s => s.jobId === job.id).map(s => read("schedules", { op: "show", id: s.id })))
@@ -150,38 +268,43 @@ export function mountJobs(root, t, taskId) {
     if (epoch !== generation) return;
     runs.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
     const summary = run => run ? (run.id || run.runId) + " · " + run.status + " · "
-      + (run.terminalAt || run.finishedAt || run.createdAt || run.attemptedAt) : null;
+      + (run.terminalAt || run.finishedAt || run.createdAt || run.attemptedAt)
+      + (run.summary || run.businessResult?.summary ? " · " + (run.summary || run.businessResult.summary) : "") : null;
     const runDetail = h("section.job-run");
     detail.replaceChildren(h("div.settings-stack", null, h("h3", null, job.title), fact("ID", job.id),
       fact(copy("scope"), taskId || "global"), fact(copy("project"), job.configuration.projectId),
+      job.builtin ? h("p", null, copy("builtinSync")) : null,
       fact(copy("revision"), job.revision),
+      fact(copy("executor"), job.configuration.kind),
       fact(copy("recentRun"), summary(runs[0])),
+      fact(copy("recentSuccess"), summary(runs.find(run => run.businessResult?.outcome === "succeeded"))),
       job.refresh ? h("div", null,
         fact(copy("refreshAttempt"), summary(job.refresh.lastAttempt)),
         fact(copy("refreshSuccess"), summary(job.refresh.lastSuccessfulRefresh))) : null,
       h("div.settings-actions", null,
         button(copy("runNow"), () => void mutate("jobs", { op: "run", id: job.id, requestId: crypto.randomUUID() }, result => {
-          selectedRun = result.run.id;
+          selectedRun = result.run.id; pinSelection();
         }), true),
-        button(copy("editJob"), () => editJob(job)),
-        button(copy("newSchedule"), () => editSchedule())),
+        !job.builtin ? button(copy("editJob"), () => editJob(job)) : null,
+        !job.builtin && !["agent", "task"].includes(job.configuration.kind) ? button(copy("newSchedule"), () => editSchedule()) : null),
       raw(copy("configuration"), job.configuration),
       job.refresh ? raw(copy("refreshFacts"), job.refresh) : null,
       h("h3", null, copy("schedules")),
       plans.length ? h("div.settings-stack", null, plans.map(({ schedule: s, lastSuccess }) => h("article.settings-card", null,
         h("h4", null, s.id), fact(copy("state"), s.state),
+        s.builtin ? fact(copy("automatic"), copy(s.builtin.enabled ? "enabled" : "disabled")) : null,
         s.state === "completed" ? h("p", null, copy("onceCompleted")) : null,
         fact(copy("rule"), s.rule.kind === "cron" ? s.rule.expression : s.rule.kind === "once" ? s.rule.at : s.rule.anchor + " + " + s.rule.everyMs + " ms"),
         fact(copy("timezone"), s.rule.timezone || "UTC / offset"),
-        fact(copy("nextDue"), s.nextDue), fact(copy("lastAttempt"), s.lastAttempt
+        fact(copy("nextDue"), s.state === "enabled" ? s.nextDue : null), fact(copy("lastAttempt"), s.lastAttempt
           ? s.lastAttempt.at + " · " + s.lastAttempt.outcome + " · " + (s.lastAttempt.runId || s.lastAttempt.reason || "") : null),
         fact(copy("lastSuccess"), lastSuccess ? lastSuccess.id + " · " + (lastSuccess.terminalAt || lastSuccess.updatedAt) : null),
         s.reason ? h("p.settings-error", null, s.reason) : null,
         h("div.settings-actions", null,
           button(copy("editSchedule"), () => editSchedule(s)),
-          button(copy(s.state === "enabled" ? "disable" : "enable"), () => void mutate("schedules", {
-            op: s.state === "enabled" ? "disable" : "enable", id: s.id, expectedRevision: s.revision
-          })), s.lastAttempt?.runId ? button(copy("inspectRun"), () => void showRun(job.id, s.lastAttempt.runId, runDetail)) : null),
+          button(copy((s.builtin ? s.builtin.enabled : s.state === "enabled") ? "disable" : "enable"), () => void mutate("schedules", {
+            op: (s.builtin ? s.builtin.enabled : s.state === "enabled") ? "disable" : "enable", id: s.id, expectedRevision: s.revision
+          })), s.lastAttempt?.runId ? h("a.btn", { href: jobLink(taskId, s.lastAttempt.jobId || job.id, s.lastAttempt.runId) }, copy("inspectRun")) : null),
         raw(copy("details"), s)))) : h("p", null, copy("noSchedules")),
       h("h3", null, copy("history")),
       runs.length ? h("div.jobs-runs", null, runs.map(run =>
@@ -201,14 +324,14 @@ export function mountJobs(root, t, taskId) {
       list.replaceChildren(...(jobs.length ? jobs.map(job => h("button.job-choice", {
         type: "button", "aria-pressed": String(selected === job.id), onclick: () => {
           if (pending || !guardDraft()) return;
-          closeEditor(); selected = job.id; selectedRun = undefined; void refresh();
+          closeEditor(); selected = job.id; selectedRun = undefined; pinSelection(); void refresh();
         }
       }, h("strong", null, job.title), h("code", null, job.id),
-        h("small", null, job.configuration.action || job.configuration.kind),
+        h("small", null, job.builtin ? copy("builtinSync") : job.configuration.action || job.configuration.kind),
         h("small", null, job.configuration.projectId || "—"))) : [h("p", null, copy("empty"))]));
       await showDetail(epoch);
       if (announce && epoch === generation) status(copy("observed") + " · " + new Date().toISOString());
-    } catch (error) { if (epoch === generation) status(error.message, true); }
+    } catch (error) { if (epoch === generation) status(copy("stale") + " " + error.message, true); }
   }
   root.classList.add("jobs-manager");
   root.replaceChildren(h("h2", null, copy("heading")),
@@ -219,4 +342,10 @@ export function mountJobs(root, t, taskId) {
   void refresh();
   return { isDirty: () => dirty, isBusy: () => pending, refresh };
 }
+
+export function jobLink(taskId, jobId, runId) {
+  const query = new URLSearchParams({ job: jobId, ...(runId ? { jobRun: runId } : {}),
+    ...(taskId ? { task: taskId, section: "jobs" } : {}) });
+  return (taskId ? "/" : "/settings/jobs") + "?" + query;
+}
 `;

package/dist/web/assets/client/views/task/files.js

@@ -74,7 +74,7 @@ function artifactViewer(viewer, data, t, actions) {
   return { element: viewer, read: read, draw: draw };
 }
 
-function drawArtifact(viewer, value, taskId, t, actions, read, state = {}) {
+export function drawArtifact(viewer, value, taskId, t, actions, read, state = {}) {
   clear(viewer);
   if (!value) return;
   const selected = value.after || value;
@@ -121,12 +121,13 @@ function drawArtifact(viewer, value, taskId, t, actions, read, state = {}) {
   viewer.append(h("p.viewer-ref", null, mono("sha256:" + selected.digest)));
   if (value.before) viewer.append(h("p.viewer-ref", null, mono("← git:" + value.before.commit + ":" + value.before.relativePath + " · sha256:" + value.before.digest)));
   viewer.append(h("p.faint.small", null, t("evidence.fixedNote")));
-  viewer.append(h("div.record-actions", null, value.kind === "image" ? null : copyText, download, feedback));
+  viewer.append(h("div.record-actions", null, value.kind === "image" ? null : copyText, download,
+    actions.openConversation ? feedback : null));
   if (value.kind === "image") { viewer.append(imagePreview(value, t, undefined, preview)); return; }
   const before = h("input", { placeholder: t("materials.before"), "aria-label": t("materials.before"), maxLength: 64 });
   const compare = button(t("materials.compare"), { variant: "ghost" });
   compare.addEventListener("click", function () { read(selected.relativePath, selected.commit, 0, before.value); });
-  viewer.append(h("div.record-actions", null, before, compare));
+  if (actions.compare !== false) viewer.append(h("div.record-actions", null, before, compare));
   const source = h("pre.code-block.artifact-text", { tabIndex: 0, "aria-label": t("evidence.fixedText") }, value.content);
   if (!value.before && /\.md$|\.markdown$/i.test(selected.relativePath)) {
     viewer.append(markdownPreview(value, taskId, t, actions, preview));
@@ -207,7 +208,7 @@ function markdownPreview(value, taskId, t, actions, preview) {
       feedback.addEventListener("click", function () { actions.openConversation([artifactRef(value), artifactRef(image)]); });
       slot.append(imagePreview(image, t, entry.alt, saved), h("span.viewer-ref", null,
         path + " · git:" + image.commit + " · sha256:" + image.digest),
-        h("span.record-actions", null, download, feedback));
+        h("span.record-actions", null, download, actions.openConversation ? feedback : null));
     }
     async function observeRead() {
       load.disabled = true; body.dataset.reading = "true"; status.textContent = t("evidence.reading");

package/dist/web/assets/client/views/task/page.js

@@ -12,7 +12,7 @@ import { updateObservation } from "/assets/js/views/task/observation.js";
 import { renderDelivery } from "/assets/js/views/task/delivery.js";
 import { renderRuntime } from "/assets/js/views/task/runtime.js";
 import { renderRecords } from "/assets/js/views/task/records.js";
-import { mountJobs } from "/assets/js/views/jobs.js";
+import { mountJobs, jobLink } from "/assets/js/views/jobs.js";
 
 // Overview: where it stands. Delivery: what it produced. Runtime: what is
 // live now. Records: what happened. Retired section names stay addressable.
@@ -94,6 +94,10 @@ function dockToggle(mode, iconName, title, t, ctx) {
 
 function taskMeta(task, t, locale) {
   return h("div.task-meta", null,
+    task.source?.kind === "job-run" ? h("a.btn", {
+      href: jobLink(task.source.run.scope.kind === "task" ? task.source.run.scope.taskId : undefined,
+        task.source.jobId, task.source.run.runId)
+    }, t("jobs.sourceJob") + " · " + task.source.jobId + " / " + task.source.run.runId) : null,
     statusBadge(t, "task", "status", task.status),
     h("span", { dataset: { slot: "exec-badge" } }),
     task.priority ? badge(label(t, "priority", task.priority), task.priority === "urgent" || task.priority === "high" ? "accent" : "idle") : null,

package/dist/web/taskPreviews.js

@@ -25,7 +25,7 @@ export function createTaskPreviews(store, home) {
     };
     const registered = (taskId, jobId) => {
         const job = store.getDurableJob(taskId, jobId);
-        if (!store.getTask(taskId) || !job || job.taskId !== taskId || !isHttpPreview(job.env)) {
+        if (!store.getTask(taskId) || !job || job.delegation || job.taskId !== taskId || !isHttpPreview(job.env)) {
             throw new WebRequestRejected("Registered Task preview not found.");
         }
         validateHttpPreview(job.env, job.steps);
@@ -69,7 +69,7 @@ export function createTaskPreviews(store, home) {
         async list(taskId) {
             if (!store.getTask(taskId))
                 throw new WebRequestRejected("Task not found.");
-            const jobs = store.listDurableJobs(taskId).filter(job => isHttpPreview(job.env)).reverse();
+            const jobs = store.listDurableJobs(taskId).filter((job) => !job.delegation && isHttpPreview(job.env)).reverse();
             const services = await Promise.all(jobs.slice(0, 16).map(async (job) => {
                 let current = state(job);
                 let detail = job.result?.unknownReason ?? `Job: ${job.status}`;

package/dist/web/webJobs.js

@@ -5,8 +5,8 @@ import { requireKnownFields } from "../domain/validation.js";
 import { WebRequestRejected, webLocalMutation } from "./webMutation.js";
 /** Local-user ingress only, behind the Web token/origin boundary. Never use
  * this adapter for managed RPC callers. The route fixes scope; the server
- * resolves the current Operator binding on every request. No invented Session
- * or durable second authority: the public services revalidate the binding.
+ * uses public user authority for global controlled actions. Task shell access
+ * still resolves the current Operator binding; no invented Session.
  */
 export function createWebJobs(store, home) {
     function invoke(scope, family, value, write, now) {
@@ -14,21 +14,31 @@ export function createWebJobs(store, home) {
             if (!value || typeof value !== "object" || Array.isArray(value))
                 throw new Error("Expected an operation.");
             requireKnownFields(value, family === "jobs"
-                ? ["op", "id", "title", "configuration", "expectedRevision", "runId", "requestId"]
-                : ["op", "id", "jobId", "rule", "expectedRevision"], "Web Job/Schedule request");
+                ? ["op", "id", "title", "configuration", "expectedRevision", "runId", "requestId",
+                    "reference", "offset", "expectedSessionId"]
+                : ["op", "id", "jobId", "rule", "expectedRevision", "authorization", "target"], "Web Job/Schedule request");
             const input = value;
-            const reads = family === "jobs" ? ["list", "show", "runs", "run-get", "logs"] : ["list", "show"];
-            const writes = family === "jobs" ? ["define", "update", "run", "run-cancel"] : ["create", "update", "enable", "disable"];
+            const reads = family === "jobs" ? ["list", "show", "runs", "run-get", "run-result", "run-evidence",
+                "run-delegation", "logs", "artifact-list", "artifact-preview", "session-inspect"] : ["list", "show"];
+            const writes = family === "jobs" ? ["define", "update", "run", "run-cancel", "artifact-register",
+                "session-stop", "session-new"] : ["create", "update", "enable", "disable"];
             if (!(write ? writes : reads).includes(String(input.op)))
                 throw new Error("Operation is not available on this endpoint.");
             if (scope.kind === "task" && !tx.getTask(scope.taskId))
                 throw new Error("Task not found.");
-            const session = activeLiveRoleAgentSession(tx.getGlobalRoleSessionSet("operator"));
-            if (!session)
-                throw new Error("A current Operator Session is required for Job management.");
-            const caller = { scope: "global", role: "operator", nativeSessionId: session.nativeSessionId,
-                agentId: session.agentId, adapterId: session.adapterId };
+            const session = scope.kind === "task" ? activeLiveRoleAgentSession(tx.getGlobalRoleSessionSet("operator")) : null;
+            if (scope.kind === "task" && !session)
+                throw new Error("A current Operator Session is required for Task Job management.");
+            const caller = session ? { scope: "global", role: "operator", nativeSessionId: session.nativeSessionId,
+                agentId: session.agentId, adapterId: session.adapterId } : { scope: "user" };
             const { requestId, ...fields } = input;
+            if (typeof fields.reference === "string")
+                fields.reference = JSON.parse(fields.reference);
+            if (fields.offset !== undefined) {
+                if (!/^\d{1,9}$/u.test(String(fields.offset)))
+                    throw new Error("Invalid artifact offset.");
+                fields.offset = Number(fields.offset);
+            }
             if (input.op === "run" && (typeof requestId !== "string" || !requestId.trim() || requestId.length > 200)) {
                 throw new Error("Immediate execution requires a stable requestId.");
             }
@@ -36,6 +46,21 @@ export function createWebJobs(store, home) {
                 ...(input.op === "run" ? { trigger: { source: "manual", key: requestId } } : {}) };
             return (family === "jobs" ? createJobDefinitionControl(tx, home) : createScheduleControl(tx, home))(params, now);
         };
+        // Artifact Git I/O is asynchronous, with its own authorization recheck and
+        // short publication transaction. Never keep a SQLite transaction across it.
+        if (family === "jobs" && value && typeof value === "object"
+            && "op" in value && String(value.op).startsWith("artifact-")) {
+            try {
+                return Promise.resolve(apply(store)).catch(error => {
+                    if (!write)
+                        throw new WebRequestRejected(error instanceof Error ? error.message : String(error));
+                    throw error; // A Git/publication failure is not proof of non-submission.
+                });
+            }
+            catch (error) {
+                throw new WebRequestRejected(error instanceof Error ? error.message : String(error));
+            }
+        }
         if (write)
             return webLocalMutation(store, apply);
         try {

package/dist/web/webMaterials.js

@@ -30,24 +30,36 @@ async function fixedImage(home, taskId, input) {
 /** One selected immutable file, never a workspace path or a remote URL.
  * Markdown is bounded and whole so fences/tables are not split by pagination. */
 export async function readArtifactPreview(home, taskId, ref, offset = 0) {
-    if (/\.(svg|gif|avif|bmp|ico|tiff?)$/iu.test(ref.relativePath)) {
+    if (ref.taskId !== taskId)
+        throw new WebRequestRejected("Materials must belong to the same Task.");
+    const valid = validateGitArtifactRef(ref);
+    const file = await resolveGitArtifact(home, valid);
+    return { ...valid, ...previewArtifactContent(file, offset) };
+}
+/** Shared data-only preview for Task and Job evidence; no path lookup or authority. */
+export function previewArtifactContent(file, offset = 0) {
+    if (/\.(svg|gif|avif|bmp|ico|tiff?)$/iu.test(file.relativePath)) {
         throw new WebRequestRejected("Unsupported image format. Save a static PNG, JPEG or WebP instead.");
     }
-    if (isRasterArtifact(ref.relativePath)) {
+    if (file.relativePath.length > 512)
+        throw new WebRequestRejected("Artifact path is too long.");
+    if (isRasterArtifact(file.relativePath)) {
         if (offset !== 0)
             throw new WebRequestRejected("Images do not have text offsets.");
-        return fixedImage(home, taskId, ref);
+        return { digest: file.digest, kind: "image", byteSize: file.bytes.length,
+            ...rasterMetadata(file.bytes), base64: file.bytes.toString("base64") };
     }
-    if (/\.md$|\.markdown$/iu.test(ref.relativePath)) {
+    textPath(file.relativePath);
+    const text = decodeText(file.bytes);
+    if (/\.md$|\.markdown$/iu.test(file.relativePath)) {
         if (offset !== 0)
             throw new WebRequestRejected("Markdown previews start at offset zero.");
-        const file = await fixedText(home, taskId, ref);
-        if (file.bytes > MAX_MATERIAL_BYTES)
+        if (file.bytes.length > MAX_MATERIAL_BYTES)
             throw new WebRequestRejected("Markdown preview exceeds 256 KiB; split the document.");
-        return { ...file.ref, kind: "markdown", byteSize: file.bytes, content: file.text,
-            offset: 0, totalCharacters: file.text.length, nextOffset: null };
+        return { digest: file.digest, kind: "markdown", byteSize: file.bytes.length, content: text,
+            offset: 0, totalCharacters: text.length, nextOffset: null };
     }
-    return readTextArtifactPage(home, taskId, ref, offset);
+    return { digest: file.digest, byteSize: file.bytes.length, ...page(text, offset) };
 }
 function textPath(path) {
     const safe = safeRelativeArtifactPath(path);

package/dist/web/webServer.js

@@ -284,15 +284,16 @@ async function handleHttpRequest(request, response, store, dependencies, token,
             let value;
             if (method === "GET") {
                 const query = new URL(request.url, "http://localhost").searchParams;
-                if ([...query.keys()].some(key => !["op", "id", "runId"].includes(key)))
-                    throw new WebRequestRejected("Unknown Job query.");
-                value = dependencies.jobs.read(scope, family, Object.fromEntries(query), now());
+                if ([...query.keys()].some(key => !["op", "id", "runId", "reference", "offset"].includes(key)
+                    || query.getAll(key).length !== 1))
+                    throw new WebRequestRejected("Unknown or repeated Job query.");
+                value = await dependencies.jobs.read(scope, family, Object.fromEntries(query), now());
             }
             else if (method === "POST") {
                 if (headerValue(request, "origin") !== `http://${headerValue(request, "host")}`) {
                     throw new WebRequestRejected("Job changes require a same-origin request.");
                 }
-                value = dependencies.jobs.mutate(scope, family, await readMutationBody(request), now());
+                value = await dependencies.jobs.mutate(scope, family, await readMutationBody(request), now());
             }
             else
                 throw new WebRequestRejected("Method not allowed.");
@@ -631,7 +632,7 @@ async function handleHttpRequest(request, response, store, dependencies, token,
         try {
             const assetVersion = new URL(request.url, "http://localhost").searchParams.get("v");
             const asset = findWebAsset(pathname, assetVersion);
-            const managementPage = /^\/(?:models(?:\/(?:providers|catalog|quota))?|settings(?:\/(?:preferences|skills|server|connection))?)\/?$/.test(pathname);
+            const managementPage = /^\/(?:models(?:\/(?:providers|catalog|quota))?|settings(?:\/(?:preferences|skills|jobs|server|connection))?)\/?$/.test(pathname);
             if (pathname === "/" || pathname === "/index.html" || managementPage) {
                 sendText(response, 200, "text/html; charset=utf-8", prepareWebDocument(managementPage ? MODELS_HTML.replace("__YUI_WEB_TOKEN__", token) : dashboardHtml(token), managementPage ? "/assets/js/app/manage.js" : "/assets/app.js"), method === "HEAD");
             }

package/dist/web/webTaskSurface.js

@@ -53,6 +53,7 @@ export function createWebTaskSurface(store, options = {}, observations = [], hos
                 core: readTaskContext(tx, taskId, environment),
                 task: {
                     id: task.id, title: clip(task.title), status: task.status, updatedAt: task.updatedAt,
+                    source: task.source,
                     executionGate: task.executionGate, priority: task.priority, tags: task.tags?.slice(0, 16).map(value => clip(value)),
                     projectBindings: task.projectBindings.slice(0, 32),
                     description: clip(task.description), completionSummary: clip(task.completionSummary),