@zq-silk/yui 1.1.2 → 2.1.0

package/dist/task/leaderArchive.js

@@ -0,0 +1,111 @@
+import { createHash } from "node:crypto";
+import { createTaskEvent } from "../event/taskEvent.js";
+import { runTaskCommand } from "../commands/taskCommands.js";
+import { archiveExecutionChecks, archiveSettlementChecks } from "./archivePreflight.js";
+import { admitLeaderArchive, assertLeaderArchiveAdmission } from "./leaderArchiveAuthority.js";
+import { assertTaskRemoteDeliveryIntegrated, createTaskRemoteDeliveryProof } from "./remoteDeliveryService.js";
+import { selectNewTaskRoleSession } from "../executor/agentExecutor.js";
+/** A single foreground Controller operation survives stopping its requesting
+ * Session. It has no retry worker: uncertain receipts are inspected, not
+ * replayed. All existing settlement, delivery and cleanup checks remain. */
+export async function archiveLeaderTask(store, coordinator, taskId, environment, request) {
+    const inputDigest = createHash("sha256").update(JSON.stringify(request)).digest("hex");
+    const previous = store.listEvents(taskId).find(event => event.type === "task.leader-archive-started" && event.payload.requestId === request.requestId);
+    if (previous) {
+        if (previous.payload.inputDigest !== inputDigest)
+            throw new Error("Archive request id names different input.");
+        const result = store.listEvents(taskId).find(event => event.type === "task.leader-archive-result" && event.payload.requestId === request.requestId);
+        return { taskId, requestId: request.requestId, status: result?.payload.status ?? "unknown",
+            detail: result?.payload.detail, replayed: true };
+    }
+    const admission = admitLeaderArchive(store, taskId, environment, request.sourceMessage, request.purpose);
+    const task = store.getTask(taskId);
+    const settlement = archiveSettlementChecks(store, task);
+    if (settlement.length)
+        throw new Error(`Archive is unsettled: ${JSON.stringify(settlement)}`);
+    const session = store.getTaskRoleSessionSet(taskId, "leader");
+    const ownInput = session?.providerBinding?.run;
+    // Only the requesting no-Run Leader may be stopped as part of this action.
+    // Another Run, Job, unknown input, or then handoff is not archive authority.
+    const ownResources = `role:${taskId}/leader`;
+    const execution = archiveExecutionChecks(store, taskId).filter(check => !(check.resource === ownResources
+        && ownInput?.runId === undefined && ownInput?.status === "accepted"
+        && ["unresolved-provider-input", "unresolved-mailbox"].includes(check.reason)));
+    if (execution.length)
+        throw new Error(`Archive execution is unresolved: ${JSON.stringify(execution)}`);
+    if (store.listMessages(taskId).some(message => message.interruptThen?.targetNativeSessionId === admission.source.nativeSessionId
+        && message.continuation === undefined && message.interruptThen.notDeliveredReason === undefined)) {
+        throw new Error("Settle the original input handoff before archive.");
+    }
+    let candidate = null;
+    const workspace = store.getTaskWorkspace(taskId);
+    if (task.projectBindings.length && workspace) {
+        const snapshot = await coordinator.preparer.snapshotDirectTaskMain(workspace, task.projectBindings.map(binding => binding.projectId));
+        candidate = { schemaVersion: 1, projects: snapshot.projects.map(project => ({
+                projectId: project.projectId, commit: project.headCommit
+            })) };
+    }
+    const proof = createTaskRemoteDeliveryProof(store, task, candidate);
+    assertTaskRemoteDeliveryIntegrated(proof.delivery);
+    for (const owned of store.listManagedWorkspaces(taskId)) {
+        const disposition = owned.owner.type === "work-item"
+            && store.getWorkItem(taskId, owned.owner.workItemId)?.status === "retired" ? "abandoned" : "integrated";
+        const checks = await coordinator.preparer.inspectWorkspaceCleanup(owned, disposition);
+        if (checks.some(check => !(owned.owner.type === "task" && check.reason === "git-worktree-registrations"))) {
+            throw new Error(`Archive workspace is not clean/removable: ${JSON.stringify(checks)}`);
+        }
+    }
+    // Reauthenticate after asynchronous inspection, before the first effect.
+    admitLeaderArchive(store, taskId, environment, request.sourceMessage, request.purpose);
+    assertLeaderArchiveAdmission(store, taskId, admission);
+    const record = (type, payload) => store.transaction(tx => tx.saveEvent(taskId, createTaskEvent(tx.nextEventId(taskId), taskId, type, { requestId: request.requestId, ...payload }, new Date())));
+    const started = store.transaction(tx => {
+        assertLeaderArchiveAdmission(tx, taskId, admission);
+        const events = tx.listEvents(taskId);
+        const prior = events.find(event => event.type === "task.leader-archive-started"
+            && event.payload.requestId === request.requestId);
+        if (prior) {
+            if (prior.payload.inputDigest !== inputDigest)
+                throw new Error("Archive request id names different input.");
+            return false;
+        }
+        const unsettled = events.find(event => event.type === "task.leader-archive-started"
+            && !events.some(result => result.type === "task.leader-archive-result"
+                && result.payload.requestId === event.payload.requestId));
+        if (unsettled)
+            throw new Error(`Inspect unresolved archive ${unsettled.payload.requestId} before another operation.`);
+        tx.saveEvent(taskId, createTaskEvent(tx.nextEventId(taskId), taskId, "task.leader-archive-started", { requestId: request.requestId, inputDigest, authorizationSource: JSON.stringify(admission.source) }, new Date()));
+        return true;
+    });
+    if (!started)
+        return { taskId, requestId: request.requestId, status: "unknown", replayed: true };
+    try {
+        await coordinator.runtime.stopTaskRoleSessions(taskId, ["leader"]);
+        store.transaction(tx => {
+            assertLeaderArchiveAdmission(tx, taskId, admission);
+            const stopped = tx.getTaskRoleSessionSet(taskId, "leader");
+            const current = stopped?.sessions[stopped.activeAgentId];
+            if (!stopped || current?.nativeSessionId !== admission.source.nativeSessionId
+                || current.status !== "ended" || current.endReason !== "stopped") {
+                throw new Error("Leader Session changed before archive runtime retirement.");
+            }
+            // Retain the exact stopped caller in history and clear its resumable
+            // binding. Generic workspace cleanup must not stop that caller again:
+            // the first verified stop already released its physical owner records.
+            tx.saveTaskRoleSessionSet(selectNewTaskRoleSession(stopped, stopped.activeAgentId, new Date()));
+        });
+        const cleanup = await coordinator.cleanupTaskForArchive(taskId, "integrated");
+        if (cleanup.status !== "removed")
+            throw new Error(cleanup.error ?? `Archive cleanup ${cleanup.status}.`);
+        runTaskCommand(["archive", taskId, "--integrated"], store, {
+            environment, archiveLeaderAdmission: admission, archiveRemoteDeliveryProof: proof
+        });
+        record("task.leader-archive-result", { status: "archived" });
+        return { taskId, requestId: request.requestId, status: "archived" };
+    }
+    catch (error) {
+        record("task.leader-archive-result", { status: store.getTask(taskId)?.status === "archived" ? "archived" : "failed",
+            detail: error instanceof Error ? error.message : String(error) });
+        throw error;
+    }
+}

package/dist/task/leaderArchiveAuthority.js

@@ -0,0 +1,24 @@
+import { taskAuthorizationSource } from "../grant/taskAuthorization.js";
+const admissions = new WeakSet();
+const terminalIdentity = (store, taskId) => {
+    const task = store.getTask(taskId);
+    if (!task || !["completed", "cancelled"].includes(task.status))
+        throw new Error("Ordinary Leader archive requires a terminal Task.");
+    return JSON.stringify({
+        status: task.status, completedAt: task.completedAt, completionSummary: task.completionSummary,
+        retiredAt: task.retiredAt, retirementSummary: task.retirementSummary,
+        projectBindings: task.projectBindings
+    });
+};
+export function admitLeaderArchive(store, taskId, environment, messageId, purpose) {
+    const source = taskAuthorizationSource(store, taskId, environment, messageId, purpose);
+    const admission = Object.freeze({ taskId, source, terminalIdentity: terminalIdentity(store, taskId) });
+    admissions.add(admission);
+    return admission;
+}
+export function assertLeaderArchiveAdmission(store, taskId, admission) {
+    if (!admissions.has(admission) || admission.taskId !== taskId
+        || terminalIdentity(store, taskId) !== admission.terminalIdentity) {
+        throw new Error("Archive admission is untrusted or its terminal Task changed.");
+    }
+}

package/dist/task/taskAuthority.js

@@ -1,5 +1,6 @@
+import { hasManagedIdentity } from "../runtime/managedIdentity.js";
 import { usageError } from "../errors/cliError.js";
-import { MANAGED_NATIVE_SESSION_ENV, currentManagedRuntime } from "../runtime/managedCaller.js";
+import { currentManagedRuntime } from "../runtime/managedCaller.js";
 const LEADER_ROLE = "leader";
 export function taskActor(environment, taskId) {
     const env = environment ?? {};
@@ -16,9 +17,7 @@ export function taskActor(environment, taskId) {
             return "operator";
         throw usageError("A managed global Session may perform this action only as Operator.");
     }
-    if (env.YUI_ROLE !== undefined
-        || env.YUI_AGENT_ID !== undefined
-        || env[MANAGED_NATIVE_SESSION_ENV] !== undefined) {
+    if (hasManagedIdentity(env)) {
         throw usageError("Managed Agent identity is incomplete; refusing to infer user authority.");
     }
     return "user";
@@ -86,9 +85,7 @@ export function projectActor(environment) {
             return "operator";
         throw usageError("A managed global Session may manage Project Knowledge only as Operator.");
     }
-    if (env.YUI_ROLE !== undefined
-        || env.YUI_AGENT_ID !== undefined
-        || env[MANAGED_NATIVE_SESSION_ENV] !== undefined) {
+    if (hasManagedIdentity(env)) {
         throw usageError("Managed Agent identity is incomplete; refusing to infer user authority.");
     }
     return "user";
@@ -124,9 +121,7 @@ export function resolveJobCaller(environment, taskId) {
             nativeSessionId: env.CODEX_THREAD_ID ?? env.YUI_NATIVE_SESSION_ID
         };
     }
-    if (env.YUI_ROLE !== undefined
-        || env.YUI_AGENT_ID !== undefined
-        || env[MANAGED_NATIVE_SESSION_ENV] !== undefined) {
+    if (hasManagedIdentity(env)) {
         throw usageError("Managed Agent identity is incomplete; refusing to infer user authority.");
     }
     return { scope: "user" };

package/dist/tmux/commandExecutor.js

@@ -4,8 +4,8 @@ export class CommandExecutionError extends Error {
     code;
     exitStatus;
     stderr;
-    constructor(code, exitStatus, stderr = "") {
-        super(commandExecutionMessage(code));
+    constructor(code, exitStatus, stderr = "", options) {
+        super(commandExecutionMessage(code), options);
         this.code = code;
         this.exitStatus = exitStatus;
         this.stderr = stderr;
@@ -102,15 +102,17 @@ export class NodeCommandExecutor {
 }
 function stableCommandExecutionError(error) {
     const details = errorDetails(error);
+    const cause = typeof error === "object" && error !== null && "error" in error
+        && error.error instanceof Error ? { cause: error.error } : undefined;
     if (details.code === "ENOENT") {
-        return new CommandExecutionError("COMMAND_NOT_FOUND", details.exitStatus, details.stderr);
+        return new CommandExecutionError("COMMAND_NOT_FOUND", details.exitStatus, details.stderr, cause);
     }
     if (details.code === "ETIMEDOUT"
         || details.signal === "SIGTERM"
         || details.signal === "SIGKILL") {
-        return new CommandExecutionError("COMMAND_TIMED_OUT", details.exitStatus, details.stderr);
+        return new CommandExecutionError("COMMAND_TIMED_OUT", details.exitStatus, details.stderr, cause);
     }
-    return new CommandExecutionError("COMMAND_FAILED", details.exitStatus, details.stderr);
+    return new CommandExecutionError("COMMAND_FAILED", details.exitStatus, details.stderr, cause);
 }
 function errorDetails(error) {
     if (typeof error !== "object" || error === null)

package/dist/web/assets/assetManifest.js

@@ -1,43 +1,59 @@
 import { readFileSync } from "node:fs";
 import { createRequire } from "node:module";
+import { API_SCRIPT } from "./client/api.js";
 import { APP_SCRIPT } from "./client/app.js";
 import { COMPONENTS_SCRIPT } from "./client/components.js";
+import { DETAIL_SCRIPT } from "./client/detail.js";
+import { DOCK_SCRIPT } from "./client/dock.js";
 import { DOM_SCRIPT } from "./client/dom.js";
+import { EVIDENCE_SCRIPT } from "./client/evidence.js";
 import { FORMAT_SCRIPT } from "./client/format.js";
+import { FORMS_SCRIPT } from "./client/forms.js";
 import { I18N_SCRIPT } from "./client/i18n.js";
 import { MARKDOWN_SCRIPT } from "./client/markdown.js";
+import { OVERVIEW_SCRIPT } from "./client/overview.js";
+import { RECORDS_SCRIPT } from "./client/records.js";
+import { SECTIONS_SCRIPT } from "./client/sections.js";
+import { SIDEBAR_SCRIPT } from "./client/sidebar.js";
 import { THEME_SCRIPT } from "./client/theme.js";
-import { VIEW_SCRIPT } from "./client/view.js";
-import { TASK_SURFACE_SCRIPT } from "./client/taskSurface.js";
-import { TASK_SUMMARY_SCRIPT } from "./client/taskSummary.js";
 import { DASHBOARD_HTML } from "./shell.js";
 import { FONT_FACE_STYLES } from "./fonts.js";
 import { FONT_WOFF2_BASE64 } from "./fontData.js";
-import { CARD_STYLES } from "./styles/cards.js";
+import { BASE_STYLES } from "./styles/base.js";
+import { COMPONENT_STYLES } from "./styles/components.js";
 import { LAYOUT_STYLES } from "./styles/layout.js";
 import { MARKDOWN_STYLES } from "./styles/markdown.js";
 import { RESPONSIVE_STYLES } from "./styles/responsive.js";
 import { TOKEN_STYLES } from "./styles/tokens.js";
-import { WIDGET_STYLES } from "./styles/widgets.js";
+import { VIEW_STYLES } from "./styles/views.js";
 const require = createRequire(import.meta.url);
+const CSS = "text/css; charset=utf-8";
+const JS = "text/javascript; charset=utf-8";
 export const WEB_ASSETS = Object.freeze({
-    "/assets/css/tokens.css": { contentType: "text/css; charset=utf-8", body: TOKEN_STYLES },
-    "/assets/css/fonts.css": { contentType: "text/css; charset=utf-8", body: FONT_FACE_STYLES },
-    "/assets/css/layout.css": { contentType: "text/css; charset=utf-8", body: LAYOUT_STYLES },
-    "/assets/css/widgets.css": { contentType: "text/css; charset=utf-8", body: WIDGET_STYLES },
-    "/assets/css/cards.css": { contentType: "text/css; charset=utf-8", body: CARD_STYLES },
-    "/assets/css/markdown.css": { contentType: "text/css; charset=utf-8", body: MARKDOWN_STYLES },
-    "/assets/css/responsive.css": { contentType: "text/css; charset=utf-8", body: RESPONSIVE_STYLES },
-    "/assets/js/dom.js": { contentType: "text/javascript; charset=utf-8", body: DOM_SCRIPT },
-    "/assets/js/format.js": { contentType: "text/javascript; charset=utf-8", body: FORMAT_SCRIPT },
-    "/assets/js/i18n.js": { contentType: "text/javascript; charset=utf-8", body: I18N_SCRIPT },
-    "/assets/js/markdown.js": { contentType: "text/javascript; charset=utf-8", body: MARKDOWN_SCRIPT },
-    "/assets/js/theme.js": { contentType: "text/javascript; charset=utf-8", body: THEME_SCRIPT },
-    "/assets/js/components.js": { contentType: "text/javascript; charset=utf-8", body: COMPONENTS_SCRIPT },
-    "/assets/js/view.js": { contentType: "text/javascript; charset=utf-8", body: VIEW_SCRIPT },
-    "/assets/js/task-surface.js": { contentType: "text/javascript; charset=utf-8", body: TASK_SURFACE_SCRIPT },
-    "/assets/js/task-summary.js": { contentType: "text/javascript; charset=utf-8", body: TASK_SUMMARY_SCRIPT },
-    "/assets/app.js": { contentType: "text/javascript; charset=utf-8", body: APP_SCRIPT },
+    "/assets/css/fonts.css": { contentType: CSS, body: FONT_FACE_STYLES },
+    "/assets/css/tokens.css": { contentType: CSS, body: TOKEN_STYLES },
+    "/assets/css/base.css": { contentType: CSS, body: BASE_STYLES },
+    "/assets/css/layout.css": { contentType: CSS, body: LAYOUT_STYLES },
+    "/assets/css/components.css": { contentType: CSS, body: COMPONENT_STYLES },
+    "/assets/css/views.css": { contentType: CSS, body: VIEW_STYLES },
+    "/assets/css/markdown.css": { contentType: CSS, body: MARKDOWN_STYLES },
+    "/assets/css/responsive.css": { contentType: CSS, body: RESPONSIVE_STYLES },
+    "/assets/js/dom.js": { contentType: JS, body: DOM_SCRIPT },
+    "/assets/js/format.js": { contentType: JS, body: FORMAT_SCRIPT },
+    "/assets/js/i18n.js": { contentType: JS, body: I18N_SCRIPT },
+    "/assets/js/markdown.js": { contentType: JS, body: MARKDOWN_SCRIPT },
+    "/assets/js/theme.js": { contentType: JS, body: THEME_SCRIPT },
+    "/assets/js/api.js": { contentType: JS, body: API_SCRIPT },
+    "/assets/js/components.js": { contentType: JS, body: COMPONENTS_SCRIPT },
+    "/assets/js/records.js": { contentType: JS, body: RECORDS_SCRIPT },
+    "/assets/js/forms.js": { contentType: JS, body: FORMS_SCRIPT },
+    "/assets/js/evidence.js": { contentType: JS, body: EVIDENCE_SCRIPT },
+    "/assets/js/sidebar.js": { contentType: JS, body: SIDEBAR_SCRIPT },
+    "/assets/js/overview.js": { contentType: JS, body: OVERVIEW_SCRIPT },
+    "/assets/js/sections.js": { contentType: JS, body: SECTIONS_SCRIPT },
+    "/assets/js/detail.js": { contentType: JS, body: DETAIL_SCRIPT },
+    "/assets/js/dock.js": { contentType: JS, body: DOCK_SCRIPT },
+    "/assets/app.js": { contentType: JS, body: APP_SCRIPT },
     ...fontAssets(),
     "/assets/vendor/xterm.mjs": vendorAsset("@xterm/xterm/lib/xterm.mjs", "text/javascript; charset=utf-8"),
     "/assets/vendor/addon-fit.mjs": vendorAsset("@xterm/addon-fit/lib/addon-fit.mjs", "text/javascript; charset=utf-8"),

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

@@ -0,0 +1,115 @@
+export const API_SCRIPT = String.raw `
+// Loopback API client. Every request carries the page token; a write is keyed
+// so an unresolved submission can never be silently replayed from this page.
+const token = document.querySelector('meta[name="yui-web-token"]').content;
+const unresolved = new Set();
+
+export function pageToken() { return token; }
+
+export async function requestJson(path, options) {
+  const response = await fetch(path, {
+    ...options,
+    headers: {
+      accept: "application/json",
+      "x-yui-web-token": token,
+      ...(options && options.headers ? options.headers : {})
+    }
+  });
+  if (!response.ok) {
+    let message = "HTTP " + response.status;
+    let disposition = "unknown";
+    try {
+      const body = await response.json();
+      if (body && body.error) message = body.error;
+      if (body && body.disposition === "not-submitted") disposition = "not-submitted";
+    } catch {}
+    throw Object.assign(new Error(message), { disposition, status: response.status });
+  }
+  return response.json();
+}
+
+function postJson(path, body, signal) {
+  return requestJson(path, {
+    method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(body),
+    ...(signal ? { signal } : {})
+  });
+}
+
+// A key stays blocked until the server either answers or proves the request
+// was not submitted; an unknown outcome must be inspected, not resent.
+export async function submitMutation(key, path, body) {
+  if (unresolved.has(key)) {
+    throw Object.assign(new Error("An earlier submission is unresolved; read current facts first."), { disposition: "blocked" });
+  }
+  unresolved.add(key);
+  try {
+    const receipt = await postJson(path, body);
+    unresolved.delete(key);
+    return receipt;
+  } catch (error) {
+    if (error.disposition === "not-submitted") unresolved.delete(key);
+    throw error;
+  }
+}
+
+export function releaseMutation(key) { unresolved.delete(key); }
+
+const task = function (taskId) { return "/api/tasks/" + encodeURIComponent(taskId); };
+
+export const api = {
+  dashboard: function (query) { return requestJson("/api/dashboard?" + query); },
+  pageSessions: function (query) {
+    return requestJson("/api/dashboard/sessions?" + query, { signal: AbortSignal.timeout(5000) });
+  },
+  context: function (taskId) { return requestJson(task(taskId) + "/context"); },
+  observation: function (taskId) { return requestJson(task(taskId), { signal: AbortSignal.timeout(1500) }); },
+  inspect: async function (taskId, ref) {
+    const query = new URLSearchParams({ store: ref.store, ref: ref.refId });
+    if (ref.digest) query.set("digest", ref.digest);
+    let result = await requestJson(task(taskId) + "/inspect?" + query);
+    if (!result.contentPage) return result;
+    const source = result.contentPage.source;
+    const digest = result.contentPage.digest;
+    let text = "";
+    while (true) {
+      const page = result.contentPage;
+      if (!page || page.source !== source || page.digest !== digest || page.encoding !== "json"
+        || page.offset !== text.length || typeof page.text !== "string" || !page.text.length) {
+        throw new Error("Original read changed or returned an invalid page; refresh its Context reference.");
+      }
+      text += page.text;
+      if (page.complete) return JSON.parse(text);
+      if (!page.nextCursor) throw new Error("Original read is incomplete; refresh its Context reference.");
+      query.set("cursor", page.nextCursor);
+      result = await requestJson(task(taskId) + "/inspect?" + query);
+    }
+  },
+  artifacts: function (taskId) { return requestJson(task(taskId) + "/artifacts"); },
+  artifact: function (taskId, path, commit) {
+    return requestJson(task(taskId) + "/artifacts?" + new URLSearchParams({ path, commit }));
+  },
+  evidence: function (taskId) { return requestJson(task(taskId) + "/evidence"); },
+  panels: function (taskId) { return requestJson(task(taskId) + "/panels", { signal: AbortSignal.timeout(3000) }); },
+  readPanel: function (taskId, ref, input) {
+    return postJson(task(taskId) + "/panels", { ref, input }, AbortSignal.timeout(3000));
+  },
+  sendMessage: function (taskId, body, requestId, intent) {
+    return submitMutation(taskId + "/messages", task(taskId) + "/messages",
+      { body, requestId, ...(intent === undefined ? {} : { intent }) });
+  },
+  control: function (taskId, payload) {
+    return submitMutation(taskId + "/control/" + payload.requestId, task(taskId) + "/control", payload);
+  },
+  updateTask: function (taskId, patch, requestId) {
+    return submitMutation(taskId + "/metadata", task(taskId) + "/metadata", { patch, requestId });
+  },
+  answerInput: function (taskId, inputId, answer) {
+    return submitMutation(taskId + "/input/" + inputId,
+      task(taskId) + "/inputs/" + encodeURIComponent(inputId) + "/answer", answer);
+  },
+  globalState: function (role) { return requestJson("/api/roles/" + encodeURIComponent(role) + "/control"); },
+  globalControl: function (role, input) {
+    return submitMutation("global/" + role, "/api/roles/" + encodeURIComponent(role) + "/control", input);
+  }
+};
+`;