dsh-wsr-execution 0.0.1 → 0.1.0

package/package.json

@@ -1,24 +1,77 @@
 {
   "name": "dsh-wsr-execution",
-  "version": "0.0.1",
-  "description": "Reserved package name for the WSR Execution integration for DeepSeek Harness.",
+  "version": "0.1.0",
+  "description": "DeepSeek Harness adapter bundle for WSR Intake, Delivery resources, Session state, Actions, and final results.",
+  "type": "module",
+  "main": "./src/index.js",
+  "exports": {
+    ".": "./src/index.js",
+    "./client": "./lib/client.js",
+    "./cordis.patch.yml": "./cordis.patch.yml",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "src",
+    "lib/client.js",
+    "skills",
+    "cordis.patch.yml",
+    "NOTICE.md",
+    "README.md"
+  ],
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "inject": [
+        "@deepseek-ai/dsh-client-connection",
+        "@deepseek-ai/dsh-client-runtime",
+        "@deepseek-ai/dsh-client-ui-conversation",
+        "@deepseek-ai/dsh-client-ui-primitives"
+      ],
+      "platform": "web"
+    },
+    "compatibility": {
+      "dsh": "0.1.1-rc.2"
+    }
+  },
+  "wsr": {
+    "displayName": "WSR",
+    "role": "execution-adapter",
+    "foundationOnly": false,
+    "ownerRevision": "0feb3333afd88e00444f80a7a0d135d2f93582db",
+    "ownerAsset": {
+      "url": "https://github.com/firestige/wsr-execution/releases/download/0.1.4-rc.1/wsr-execution-0.1.4.tgz",
+      "sha256": "4407239534795f528b3ca597583a682636dd539516f567434a128d5437345e4d"
+    }
+  },
+  "dependencies": {
+    "@deepseek-ai/dsh-client-connection": "0.1.1-rc.2",
+    "@deepseek-ai/dsh-client-runtime": "0.1.1-rc.2",
+    "@deepseek-ai/dsh-client-ui-conversation": "0.1.1-rc.2",
+    "@deepseek-ai/dsh-client-ui-primitives": "0.1.1-rc.2",
+    "@deepseek-ai/dsh-client-ui-workspace": "0.1.1-rc.2",
+    "@deepseek-ai/dsh-tools": "0.1.1-rc.2"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/dsh": "0.1.1-rc.2",
+    "wsr-execution": "0.1.4"
+  },
+  "peerDependenciesMeta": {
+    "@deepseek-ai/dsh": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": "24.12.0"
+  },
   "license": "Apache-2.0",
-  "author": {
-    "name": "firestige"
+  "publishConfig": {
+    "access": "public"
   },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/firestige/wsr-dsh.git",
     "directory": "packages/execution"
-  },
-  "homepage": "https://github.com/firestige/wsr-dsh#readme",
-  "bugs": {
-    "url": "https://github.com/firestige/wsr-dsh/issues"
-  },
-  "keywords": [
-    "deepseek-harness",
-    "dsh",
-    "workflow",
-    "wsr"
-  ]
+  }
 }

package/skills/workflow-execution/SKILL.md

@@ -0,0 +1,17 @@
+---
+name: workflow-execution
+description: Explicitly create, inspect, recover, finish an interaction, or abandon a Workflow Delivery.
+disable-model-invocation: true
+user-invocable: true
+---
+
+Use the operation that matches the user's explicit request:
+
+- `list` discovers privacy-safe Delivery and worktree state.
+- `create` starts a new Delivery from the current turn text and attachments.
+- `recover` binds this conversation to an exact detached Delivery, or to this worktree's Delivery when no ID was supplied.
+- `status` inspects the current binding or one exact Delivery ID.
+- `action-finish` corresponds to `/wsr action finish`; it requests closure of the current Action interaction without claiming that the Action completed.
+- `abandon` performs exact authorized abandonment.
+
+Call `workflow_execution_intake` exactly once with that closed operation and the current host-neutral turn values. Do not call executable plugin code, Core, M01, Runner, an execution session, or a Provider service directly.

package/src/action-presentation/model.js

@@ -0,0 +1,236 @@
+export const DSH_ACTION_PRESENTATION_COMPATIBILITY = Object.freeze({
+  dsh: "0.1.1-rc.2",
+  uiPrimitives: "@deepseek-ai/dsh-client-ui-primitives@0.1.1-rc.2",
+  presentation: "wsr.presentation@1.0.0",
+});
+
+const ROOT_KEYS = "correlation,data,kind,schemaVersion";
+const KINDS = new Set([
+  "command-accepted",
+  "delivery-running",
+  "delivery-list",
+  "delivery-status",
+  "action-output",
+  "action-input-request",
+  "terminal-result",
+  "error",
+]);
+const ACTION_STATES = new Set(["running", "completed", "failed", "cancelled", "waiting", "recovering"]);
+const TERMINAL_OUTCOMES = new Set(["SUCCEEDED", "FAILED", "CANCELLED"]);
+const DELIVERY_STATES = new Set([
+  "BOUND", "START_UNCERTAIN", "RUNNING_CORRELATED", "START_FAILED", "RESULT_UNRESOLVED", "TERMINAL_HANDLING",
+  "RUNNING", "RECOVERING", "WAITING", "AWAITING_INPUT", "COMPLETED", "SUCCEEDED", "FAILED", "CANCELLED",
+]);
+const MAX_PRESENTATION_BYTES = 4096;
+
+function deepFreeze(value, seen = new Set()) {
+  if (value === null || typeof value !== "object" || seen.has(value)) return value;
+  seen.add(value);
+  for (const child of Object.values(value)) deepFreeze(child, seen);
+  return Object.freeze(value);
+}
+
+function invalidPresentation() {
+  return deepFreeze({
+    schemaVersion: DSH_ACTION_PRESENTATION_COMPATIBILITY.presentation,
+    correlation: "presentation-invalid",
+    kind: "error",
+    data: { code: "WSR_PRESENTATION_INVALID", message: "WSR presentation unavailable" },
+  });
+}
+
+function plainJson(value, seen = new Set()) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return true;
+  if (typeof value === "number") return Number.isFinite(value);
+  if (typeof value !== "object" || seen.has(value)) return false;
+  seen.add(value);
+  if (Array.isArray(value)) return value.every((item) => plainJson(item, seen));
+  if (Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) return false;
+  const descriptors = Object.getOwnPropertyDescriptors(value);
+  return Reflect.ownKeys(value).every((key) => typeof key === "string"
+    && descriptors[key] !== undefined
+    && "value" in descriptors[key]
+    && plainJson(descriptors[key].value, seen));
+}
+
+function hasValidTypedData(value) {
+  if (value.kind === "action-output") {
+    const state = value.data.state === undefined ? "completed" : value.data.state;
+    const channel = value.data.channel === undefined ? "action" : value.data.channel;
+    return typeof state === "string" && ACTION_STATES.has(state)
+      && (channel === "action" || channel === "tool");
+  }
+  if (value.kind === "terminal-result") {
+    const outputValid = Object.hasOwn(value.data, "finalOutput")
+      ? typeof value.data.finalOutput === "string" && value.data.finalOutput.length > 0
+      : typeof value.data.summary === "string" && value.data.summary.length > 0;
+    return typeof value.data.outcome === "string" && TERMINAL_OUTCOMES.has(value.data.outcome) && outputValid;
+  }
+  if (value.kind === "delivery-running" || value.kind === "delivery-status") {
+    return value.data.state === undefined
+      || (typeof value.data.state === "string" && DELIVERY_STATES.has(value.data.state));
+  }
+  return true;
+}
+
+/**
+ * Admit one durable Execution presentation fact. Unsupported revisions and
+ * shapes become a bounded generic error; rejected bytes are never echoed.
+ */
+export function parseExecutionPresentation(input) {
+  let value = input;
+  if (typeof input === "string") {
+    if (input.length === 0 || new TextEncoder().encode(input).byteLength > MAX_PRESENTATION_BYTES) return invalidPresentation();
+    try { value = JSON.parse(input); } catch { return invalidPresentation(); }
+  }
+  if (value === null || typeof value !== "object" || Array.isArray(value)
+    || Object.keys(value).sort().join(",") !== ROOT_KEYS
+    || value.schemaVersion !== DSH_ACTION_PRESENTATION_COMPATIBILITY.presentation
+    || typeof value.correlation !== "string" || value.correlation.length === 0
+    || !KINDS.has(value.kind)
+    || value.data === null || typeof value.data !== "object" || Array.isArray(value.data)
+    || !plainJson(value.data)
+    || !hasValidTypedData(value)) return invalidPresentation();
+  return deepFreeze(structuredClone(value));
+}
+
+function text(value, keys = ["text", "message", "question", "summary", "result"]) {
+  if (typeof value === "string") return value;
+  if (Array.isArray(value)) {
+    const lines = value.map((item) => text(item, keys)).filter((item) => typeof item === "string" && item.length > 0);
+    return lines.length === 0 ? undefined : lines.join("\n\n");
+  }
+  if (value === null || typeof value !== "object") return undefined;
+  for (const key of keys) {
+    if (!Object.hasOwn(value, key)) continue;
+    const nested = text(value[key], keys);
+    if (nested !== undefined) return nested;
+  }
+  return undefined;
+}
+
+function normalizedLifecycle(value, fallback) {
+  if (typeof value !== "string") return fallback;
+  const normalized = value.toLowerCase().replaceAll("_", "-");
+  if (["succeeded", "success", "done", "terminal"].includes(normalized)) return "completed";
+  if (["failed", "error"].includes(normalized)) return "failed";
+  if (["cancelled", "canceled"].includes(normalized)) return "cancelled";
+  if (["waiting", "awaiting-input"].includes(normalized)) return "waiting";
+  if (["start-failed"].includes(normalized)) return "failed";
+  if (["recovering", "recovery", "running-correlated", "result-unresolved", "terminal-handling"].includes(normalized)) return "recovering";
+  if (["running", "accepted", "start-uncertain", "bound"].includes(normalized)) return "running";
+  return fallback;
+}
+
+const STATE_LABELS = Object.freeze({
+  running: "Running",
+  completed: "Completed",
+  failed: "Failed",
+  cancelled: "Cancelled",
+  waiting: "Waiting for input",
+  recovering: "Recovering",
+});
+
+function model(input) {
+  return deepFreeze(input);
+}
+
+/** Convert a typed owner fact into the browser-only WSR presentation model. */
+export function projectExecutionPresentation(event) {
+  const { correlation, data } = event;
+  if (event.kind === "delivery-list") throw new TypeError("WSR_PRESENTATION_OUT_OF_SCOPE");
+  if (event.kind === "terminal-result") {
+    const state = normalizedLifecycle(data.outcome, "failed");
+    const body = typeof data.finalOutput === "string" ? data.finalOutput : data.summary;
+    return model({
+      correlation, layer: "final", state, title: "Final result",
+      summary: data.outcome[0] + data.outcome.slice(1).toLowerCase(), body,
+      defaultOpen: true, focusPolicy: "none", role: "article",
+      compatibility: typeof data.finalOutput === "string" ? "current" : "legacy-summary",
+    });
+  }
+  if (event.kind === "action-input-request") {
+    return model({
+      correlation, layer: "action", state: "waiting",
+      title: typeof data.label === "string" ? data.label : "Workflow Action",
+      summary: STATE_LABELS.waiting, body: text(data.prompt) ?? "Input required",
+      defaultOpen: true, focusPolicy: "preserve", role: "status", compatibility: "current",
+    });
+  }
+  if (event.kind === "action-output") {
+    const state = data.state ?? "completed";
+    return model({
+      correlation, layer: data.channel === "tool" ? "tool" : "action", state,
+      title: typeof data.label === "string" ? data.label : "Workflow Action",
+      summary: STATE_LABELS[state], body: text(data.content) ?? "WSR content unavailable",
+      defaultOpen: state !== "completed", focusPolicy: "none", role: "status", compatibility: "current",
+    });
+  }
+  if (event.kind === "error") {
+    return model({
+      correlation, layer: "progress", state: "failed", title: "Workflow presentation",
+      summary: typeof data.code === "string" ? data.code : "WSR_ERROR",
+      body: typeof data.message === "string" ? data.message : "WSR presentation unavailable",
+      defaultOpen: true, focusPolicy: "none", role: "alert", compatibility: "current",
+    });
+  }
+
+  const state = event.kind === "delivery-running"
+    ? normalizedLifecycle(data.state, "running")
+    : normalizedLifecycle(data.state, event.kind === "command-accepted" ? "running" : "running");
+  const deliveryId = typeof data.deliveryId === "string" ? data.deliveryId : undefined;
+  return model({
+    correlation, layer: "progress", state, title: "Workflow delivery",
+    summary: `${STATE_LABELS[state]}${deliveryId === undefined ? "" : ` · ${deliveryId}`}`,
+    body: undefined, defaultOpen: state !== "completed", focusPolicy: "none", role: "status", compatibility: "current",
+  });
+}
+
+/** Lifecycle-driven disclosure policy that never destroys the active focus target. */
+export function resolveDisclosureOpen({ current, previousState, nextState, containsFocus }) {
+  if (nextState === "waiting") return true;
+  if (nextState === "completed" && previousState !== "completed") return containsFocus ? true : false;
+  if (["running", "recovering", "failed", "cancelled"].includes(nextState) && nextState !== previousState) return true;
+  return current;
+}
+
+/** Durable Harness conversation-event adapter. It creates only WSR nodes. */
+export function createExecutionPresentationDefinition() {
+  return Object.freeze({
+    kind: "wsr-execution-presentation",
+    target: "chat",
+    match(event) {
+      if (event?.type === "command/run" && event.data?.name === "wsr"
+        && event.data?.source?.kind === "plugin" && event.data?.source?.plugin === "workflow-execution"
+        && typeof event.data?.commandId === "string") {
+        return { id: event.data.commandId, role: "start" };
+      }
+      return event?.type === "command/done" && typeof event.data?.commandId === "string"
+        ? { id: event.data.commandId, role: "update" }
+        : null;
+    },
+    start(_context, match) {
+      return Object.freeze({ seq: match.event.seq, presentation: undefined });
+    },
+    update(context, match) {
+      const event = parseExecutionPresentation(match.event?.data?.text);
+      if (event.kind === "delivery-list") {
+        return Object.freeze({ ...context.state, presentation: undefined });
+      }
+      return Object.freeze({ ...context.state, presentation: projectExecutionPresentation(event) });
+    },
+    buildViewNode(context) {
+      if (context.state?.presentation === undefined) return null;
+      return Object.freeze({
+        key: context.key,
+        kind: "wsr-execution-presentation",
+        id: context.id,
+        target: "chat",
+        anchorSeq: context.state.seq,
+        location: context.start?.location ?? { kind: "unresolved" },
+        visibility: "visible",
+        data: context.state.presentation,
+      });
+    },
+  });
+}

package/src/action-presentation/view.js

@@ -0,0 +1,98 @@
+import {
+  createExecutionPresentationDefinition,
+  resolveDisclosureOpen,
+} from "./model.js";
+
+const DOT_STATE = Object.freeze({
+  running: "ongoing",
+  recovering: "ongoing",
+  completed: "done",
+  waiting: "warning",
+  failed: "error",
+  cancelled: "error",
+});
+
+/**
+ * Build the WSR renderer from Harness-owned, public UI primitives. Dependency
+ * injection keeps the projection testable without copying any DSH component.
+ */
+export function createActionPresentationView({ React, DisclosureRow, MessageText, StateDot, observe = () => undefined }) {
+  if (typeof DisclosureRow !== "function") throw new TypeError("DSH_DISCLOSURE_ROW_REQUIRED");
+
+  return function WsrExecutionPresentationView({ node }) {
+    const presentation = node.data;
+    const [open, setOpen] = React.useState(presentation.defaultOpen);
+    const bodyRef = React.useRef(null);
+    const previousState = React.useRef(presentation.state);
+
+    React.useEffect(() => {
+      setOpen((current) => resolveDisclosureOpen({
+        current,
+        previousState: previousState.current,
+        nextState: presentation.state,
+        containsFocus: typeof document !== "undefined"
+          && bodyRef.current !== null
+          && bodyRef.current.contains(document.activeElement),
+      }));
+      previousState.current = presentation.state;
+    }, [presentation.state]);
+
+    observe(presentation);
+
+    if (presentation.layer === "final") {
+      return React.createElement("article", {
+        "data-wsr-presentation": "true",
+        "data-wsr-layer": "final",
+        "data-wsr-state": presentation.state,
+        "data-wsr-correlation": presentation.correlation,
+        "data-wsr-chat-role": "assistant",
+        "data-wsr-compatibility": presentation.compatibility,
+        "aria-label": presentation.title,
+      }, React.createElement(MessageText, { text: presentation.body }));
+    }
+
+    const waiting = presentation.state === "waiting";
+    const expandable = presentation.body !== undefined && !waiting;
+    const body = presentation.body === undefined ? undefined : React.createElement("div", {
+      ref: bodyRef,
+      "data-wsr-presentation": "true",
+      "data-wsr-layer": presentation.layer,
+      "data-wsr-state": presentation.state,
+      "data-wsr-correlation": presentation.correlation,
+      "data-wsr-action-input": waiting ? "true" : undefined,
+      role: waiting ? "group" : undefined,
+      tabIndex: waiting ? 0 : undefined,
+      "aria-label": waiting ? presentation.summary : undefined,
+      "aria-live": waiting ? "polite" : undefined,
+    }, React.createElement("pre", {
+      style: { margin: 0, maxHeight: "20rem", overflow: "auto", whiteSpace: "pre-wrap", wordBreak: "break-word" },
+    }, presentation.body));
+
+    return React.createElement(DisclosureRow, {
+      icon: React.createElement(StateDot, { state: DOT_STATE[presentation.state], size: 10 }),
+      title: presentation.title,
+      open: waiting ? true : open,
+      expandable,
+      onToggle: waiting ? () => undefined : () => setOpen((current) => !current),
+      expandOnRowClick: expandable,
+      // The locked primitive animates its hover-preview icon without a
+      // reduced-motion branch. Keeping that optional preview off preserves the
+      // same keyboard disclosure while making WSR rows motion-free.
+      previewChevron: false,
+      keepContentWhenOpen: true,
+      collapsedContent: React.createElement("span", {
+        role: presentation.role,
+        "aria-live": ["running", "recovering", "waiting"].includes(presentation.state) ? "polite" : undefined,
+      }, presentation.summary),
+    }, body);
+  };
+}
+
+/** Register the feature-owned event projection and its one keyed chat node. */
+export function registerActionPresentation(ctx, View) {
+  ctx.conversationEvents.register(createExecutionPresentationDefinition());
+  ctx.slots.inject("conversation.chat.node", () => ctx.slots.register({
+    name: "conversation.chat.node",
+    key: "wsr-execution-presentation",
+  }, View));
+}

package/src/client/browser-entry.js

@@ -0,0 +1,32 @@
+import React from "react";
+import { DisclosureRow, MessageText, StateDot } from "@deepseek-ai/dsh-client-ui-primitives";
+import * as workspaceUi from "@deepseek-ai/dsh-client-ui-workspace";
+
+import { createActionPresentationView, registerActionPresentation } from "../action-presentation/view.js";
+import { createDeliveryControlPlaneClient } from "./delivery/control-plane-port.js";
+import { registerSessionDeliveryView } from "./delivery/session-delivery-view.js";
+import { applyDeliverySidebar } from "./delivery-inventory/sidebar.js";
+
+export const name = "wsr-execution-client";
+export const inject = Object.freeze([
+  "connection", "conversationEvents", "sessions", "slots", "workspaces", "locale",
+]);
+
+export function apply(ctx) {
+  const controlPlane = createDeliveryControlPlaneClient(ctx.connection.rpc);
+  const refresh = () => { void controlPlane.refresh(); };
+  refresh();
+  const timer = setInterval(refresh, 2_000);
+  ctx.effect(() => () => clearInterval(timer), "wsr-execution: control-plane refresh");
+
+  applyDeliverySidebar(ctx, { React, workspaceUi, inventory: controlPlane.inventory });
+  registerSessionDeliveryView(ctx, {
+    React,
+    bindProjection(sessionId) {
+      const source = controlPlane.bindSession(String(sessionId));
+      void source.refresh();
+      return source;
+    },
+  });
+  registerActionPresentation(ctx, createActionPresentationView({ React, DisclosureRow, MessageText, StateDot }));
+}

package/src/client/delivery/control-plane-port.js

@@ -0,0 +1,64 @@
+const CHANNEL = "/wsr-execution";
+
+function createStore(initial) {
+  let snapshot = initial;
+  const listeners = new Set();
+  return Object.freeze({
+    getSnapshot: () => snapshot,
+    subscribe(listener) { listeners.add(listener); return () => listeners.delete(listener); },
+    publish(value) { snapshot = Object.freeze(value); for (const listener of [...listeners]) listener(); },
+  });
+}
+
+function message(error) {
+  return typeof error?.message === "string" && error.message.length > 0
+    ? error.message
+    : "Delivery control plane unavailable";
+}
+
+/** Browser-side React stores backed only by the loopback Host read gateway. */
+export function createDeliveryControlPlaneClient(rpc) {
+  if (typeof rpc?.call !== "function") throw new TypeError("DSH_CONNECTION_RPC_REQUIRED");
+  const inventory = createStore(Object.freeze({ kind: "loading" }));
+  const sessions = new Map();
+  const read = async (endpoint, payload) => {
+    const result = await rpc.call(CHANNEL, endpoint, payload);
+    if (result?.ok !== true) throw new Error(message(result?.error));
+    return result.value;
+  };
+  const client = {
+    inventory,
+    async refresh() {
+      try {
+        const value = await read("inventory/read", {});
+        inventory.publish({ kind: "ready", snapshot: value });
+        for (const source of sessions.values()) void source.refresh();
+      } catch (error) {
+        const previous = inventory.getSnapshot();
+        inventory.publish({
+          kind: previous.kind === "ready" ? "reconnecting" : "error",
+          message: message(error),
+          ...(previous.kind === "ready" ? { snapshot: previous.snapshot } : {}),
+        });
+      }
+    },
+    bindSession(sessionCorrelation) {
+      if (typeof sessionCorrelation !== "string" || sessionCorrelation.length === 0 || sessionCorrelation.length > 512) {
+        throw new TypeError("SESSION_CORRELATION_INVALID");
+      }
+      if (sessions.has(sessionCorrelation)) return sessions.get(sessionCorrelation);
+      const store = createStore(Object.freeze({ kind: "loading" }));
+      const source = Object.freeze({
+        getSnapshot: store.getSnapshot,
+        subscribe: store.subscribe,
+        async refresh() {
+          try { store.publish({ kind: "ready", view: await read("session/read", { sessionCorrelation }) }); }
+          catch (error) { store.publish({ kind: "error", code: "DELIVERY_PROJECTION_UNAVAILABLE", message: message(error) }); }
+        },
+      });
+      sessions.set(sessionCorrelation, source);
+      return source;
+    },
+  };
+  return Object.freeze(client);
+}

package/src/client/delivery/session-delivery-view.js

@@ -0,0 +1,126 @@
+export const DELIVERY_VIEW_ID = "delivery";
+export const DELIVERY_VIEW_ORDER = 20;
+
+const SHA256 = /^sha256:[0-9a-f]{64}$/u;
+const LIFECYCLES = new Set([
+  "BOUND", "START_UNCERTAIN", "RUNNING_CORRELATED", "START_FAILED",
+  "RESULT_UNRESOLVED", "TERMINAL_HANDLING", "TERMINAL",
+]);
+
+function nonEmpty(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function validDelivery(delivery, sessionCorrelation) {
+  return delivery !== null && typeof delivery === "object" && !Array.isArray(delivery)
+    && nonEmpty(delivery.deliveryId) && SHA256.test(delivery.deliveryBindingIdentity)
+    && nonEmpty(delivery.task?.identity)
+    && nonEmpty(delivery.workflow?.identity)
+    && nonEmpty(delivery.workflow?.packageName)
+    && nonEmpty(delivery.workflow?.exactPackageVersion)
+    && SHA256.test(delivery.workflow?.packageDigest)
+    && nonEmpty(delivery.workflow?.snapshotIdentity)
+    && SHA256.test(delivery.workflow?.snapshotDigest)
+    && LIFECYCLES.has(delivery.lifecycle)
+    && delivery.navigation?.sessionCorrelation === sessionCorrelation
+    && delivery.detached === false
+    && typeof delivery.recoverable === "boolean"
+    && Number.isSafeInteger(delivery.timing?.startedAt)
+    && Number.isSafeInteger(delivery.timing?.updatedAt)
+    && Number.isSafeInteger(delivery.timing?.elapsedMs)
+    && delivery.timing.elapsedMs >= 0;
+}
+
+function duration(value) {
+  const seconds = Math.floor(value / 1000);
+  if (seconds < 60) return `${seconds}.${String(value % 1000).padStart(3, "0")}s`;
+  return `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
+}
+
+function safeSnapshot(source) {
+  try { return source.getSnapshot(); }
+  catch { return { kind: "error", code: "DELIVERY_PROJECTION_UNAVAILABLE", message: "Execution projection unavailable" }; }
+}
+
+function safeSubscribe(source, notify) {
+  try { const dispose = source.subscribe(notify); return typeof dispose === "function" ? dispose : () => undefined; }
+  catch { return () => undefined; }
+}
+
+function pair(React, label, value) {
+  return [
+    React.createElement("dt", { key: `${label}-label` }, label),
+    React.createElement("dd", { key: `${label}-value` }, value),
+  ];
+}
+
+function statePanel(React, role, code, message) {
+  return React.createElement("section", {
+    "aria-labelledby": "wsr-delivery-view-title", "aria-live": role === "alert" ? "assertive" : "polite",
+    "data-wsr-delivery-view": "true", role,
+  }, React.createElement("h2", { id: "wsr-delivery-view-title" }, "Delivery"),
+  React.createElement("p", null, message), code === undefined ? null : React.createElement("code", null, code));
+}
+
+/** Render the exact owner `SessionDeliveryView` without a shadow projection. */
+export function createSessionDeliveryView(React) {
+  if (typeof React?.createElement !== "function" || typeof React?.useSyncExternalStore !== "function") {
+    throw new TypeError("DELIVERY_VIEW_REACT_INVALID");
+  }
+  return function SessionDeliveryView({ sessionId, source }) {
+    const state = React.useSyncExternalStore(
+      (notify) => safeSubscribe(source, notify),
+      () => safeSnapshot(source),
+      () => safeSnapshot(source),
+    );
+    if (state.kind === "loading") return statePanel(React, "status", undefined, "Loading Delivery…");
+    if (state.kind === "error") return statePanel(React, "alert", state.code ?? "DELIVERY_PROJECTION_UNAVAILABLE", state.message ?? "Execution projection unavailable");
+    const view = state.view;
+    if (state.kind !== "ready" || view?.sessionCorrelation !== sessionId) {
+      return statePanel(React, "alert", "DELIVERY_PROJECTION_CORRUPT", "Delivery projection invalid");
+    }
+    if (view.kind === "UNBOUND") return statePanel(React, "status", undefined, "No Delivery bound to this Session");
+    if (view.kind !== "BOUND" || !validDelivery(view.delivery, sessionId)) {
+      return statePanel(React, "alert", "DELIVERY_PROJECTION_CORRUPT", "Delivery projection invalid");
+    }
+    const delivery = view.delivery;
+    const failed = delivery.terminal?.outcome === "FAILED" || delivery.error !== null;
+    const identityRows = [
+      ...pair(React, "Delivery", delivery.deliveryId),
+      ...pair(React, "Task", delivery.task.displayName ?? delivery.task.identity),
+      ...pair(React, "Workflow", delivery.workflow.identity),
+      ...pair(React, "Package", `${delivery.workflow.packageName}@${delivery.workflow.exactPackageVersion}`),
+      ...pair(React, "Package digest", delivery.workflow.packageDigest),
+      ...pair(React, "Snapshot", delivery.workflow.snapshotIdentity),
+      ...pair(React, "Snapshot digest", delivery.workflow.snapshotDigest),
+      ...pair(React, "Binding", delivery.deliveryBindingIdentity),
+    ];
+    const lifecycleRows = [
+      ...pair(React, "Lifecycle", delivery.lifecycle),
+      ...pair(React, "Recoverable", delivery.recoverable ? "yes" : "no"),
+      ...(delivery.current === null ? [] : pair(React, delivery.current.kind === "ACTION" ? "Current Action" : "Current Intervention", delivery.current.identity)),
+      ...pair(React, "Started", new Date(delivery.timing.startedAt).toISOString()),
+      ...pair(React, "Elapsed", duration(delivery.timing.elapsedMs)),
+      ...(delivery.terminal === null ? [] : [
+        ...pair(React, "Ended", new Date(delivery.terminal.finishedAt).toISOString()),
+        ...pair(React, "Outcome", delivery.terminal.outcome),
+      ]),
+      ...(delivery.error === null ? [] : pair(React, "Error", delivery.error.code)),
+    ];
+    return React.createElement("section", {
+      "aria-labelledby": "wsr-delivery-view-title", "aria-live": failed ? "assertive" : "polite",
+      "data-wsr-delivery-id": delivery.deliveryId, "data-wsr-delivery-view": "true", role: failed ? "alert" : "region",
+    }, React.createElement("h2", { id: "wsr-delivery-view-title" }, "Delivery"),
+    React.createElement("dl", { "aria-label": "Delivery identity" }, identityRows),
+    React.createElement("dl", { "aria-label": "Delivery lifecycle" }, lifecycleRows));
+  };
+}
+
+export function registerSessionDeliveryView(ctx, options) {
+  if (typeof ctx?.slots?.inject !== "function" || typeof ctx?.slots?.register !== "function"
+    || typeof options?.bindProjection !== "function") throw new TypeError("DELIVERY_VIEW_REGISTRATION_INVALID");
+  const View = createSessionDeliveryView(options.React);
+  ctx.slots.inject("conversation.view", () => ctx.slots.register({
+    name: "conversation.view", id: DELIVERY_VIEW_ID, order: DELIVERY_VIEW_ORDER, label: "Delivery",
+    inject: (sessionId) => ({ source: options.bindProjection(sessionId) }),
+  }, View));
+}