dsh-wsr-execution 0.2.0 → 0.2.2

package/src/client/delivery-inventory/model.js

@@ -5,11 +5,21 @@ const LIFECYCLES = new Set([
 ]);
 const WORKSPACE_KEY = "wsr.sidebar.workspace.expanded.v1";
 const DELIVERY_KEY = "wsr.sidebar.delivery.expanded.v1";
+const ERROR_CODES = new Set([
+  "DELIVERY_PROJECTION_CORRUPT",
+  "DELIVERY_PROJECTION_STALE_BINDING",
+  "DELIVERY_PROJECTION_RECOVERY_MISMATCH",
+  "DELIVERY_PROJECTION_UNAVAILABLE",
+]);
 
 function errorView(label = "Delivery inventory unavailable") {
   return Object.freeze({ kind: "error", role: "alert", label, rows: Object.freeze([]) });
 }
 
+function diagnostic(state, label) {
+  return typeof state?.code === "string" && ERROR_CODES.has(state.code) ? `${state.code}: ${label}` : label;
+}
+
 function validString(value) {
   return typeof value === "string" && value.length > 0 && value.length <= 512;
 }
@@ -49,7 +59,10 @@ function rowsFrom(deliveries, selectedSessionId) {
 /** Project only the formal Execution DeliveryControlPlaneSnapshot. */
 export function projectDeliveryInventory(state, { selectedSessionId } = {}) {
   if (state?.kind === "loading") return Object.freeze({ kind: "loading", role: "status", label: "Loading Deliveries", rows: Object.freeze([]) });
-  if (state?.kind === "error") return errorView(validString(state.message) ? state.message : undefined);
+  if (state?.kind === "error") {
+    const label = validString(state.message) ? state.message : "Delivery inventory unavailable";
+    return errorView(diagnostic(state, label));
+  }
   if (!new Set(["ready", "reconnecting"]).has(state?.kind)) return errorView();
   const snapshot = state.snapshot;
   if (snapshot === null || typeof snapshot !== "object" || Array.isArray(snapshot)
@@ -57,7 +70,9 @@ export function projectDeliveryInventory(state, { selectedSessionId } = {}) {
     || !Number.isSafeInteger(snapshot.generation) || snapshot.generation < 1) return errorView();
   const rows = rowsFrom(snapshot.deliveries, selectedSessionId);
   if (rows === undefined) return errorView();
-  if (state.kind === "reconnecting") return Object.freeze({ kind: "reconnecting", role: "status", label: "Reconnecting to Delivery inventory", rows });
+  if (state.kind === "reconnecting") return Object.freeze({
+    kind: "reconnecting", role: "status", label: diagnostic(state, "Reconnecting to Delivery inventory"), rows,
+  });
   if (rows.length === 0) return Object.freeze({ kind: "empty", role: "status", label: "No Deliveries", rows });
   return Object.freeze({ kind: "ready", role: "list", label: "Deliveries", rows });
 }
@@ -113,4 +128,3 @@ export function createMemoryCollapseStore(storage = {}) {
     setDeliveryExpanded(value) { update("deliveryExpanded", DELIVERY_KEY, value); },
   });
 }
-

package/src/host/delivery-control-plane.js

@@ -55,7 +55,10 @@ export async function createDeliveryControlPlaneGateway(readModel) {
         if (payload === null || typeof payload !== "object" || Array.isArray(payload) || Object.keys(payload).length !== 0) {
           throw new TypeError("CONTROL_PLANE_RPC_INVALID");
         }
-        if (failure !== undefined) return failure;
+        if (failure !== undefined) {
+          try { current = await readModel.snapshot(); failure = undefined; }
+          catch (error) { failure = errorResult(error); return failure; }
+        }
         if (current === undefined) {
           try { current = await readModel.snapshot(); }
           catch (error) { return errorResult(error); }
@@ -80,33 +83,57 @@ export async function createDeliveryControlPlaneGateway(readModel) {
 /** Map the owner correlation coordinate to the DSH Session id at the Host edge. */
 export function createDshSessionControlPlaneReadModel(readModel, bindings) {
   assertReadModel(readModel);
-  if (typeof bindings?.list !== "function" || typeof bindings?.bySession !== "function") {
+  if (typeof bindings?.listProjection !== "function" || typeof bindings?.bySession !== "function") {
     throw new TypeError("DSH_SESSION_BINDINGS_REQUIRED");
   }
+  const stale = () => Object.assign(new Error("DELIVERY_PROJECTION_STALE_BINDING"), { code: "DELIVERY_PROJECTION_STALE_BINDING" });
+  const exact = (delivery, binding) => delivery.deliveryId === binding.deliveryId
+    && delivery.deliveryBindingIdentity === binding.deliveryBindingIdentity
+    && delivery.worktree === binding.worktree
+    && delivery.navigation?.sessionCorrelation === binding.correlation;
   const mapSnapshot = async (snapshot) => {
-    const rows = await bindings.list();
-    const sessions = new Map(rows.map((binding) => [binding.correlation, binding.sessionKey]));
+    const rows = await bindings.listProjection();
+    const sessions = new Map(rows.map((binding) => [binding.correlation, binding]));
+    if (sessions.size !== rows.length) throw stale();
     return Object.freeze({
       ...snapshot,
       deliveries: Object.freeze(snapshot.deliveries.map((delivery) => {
         if (delivery.navigation === null) return delivery;
-        const sessionCorrelation = sessions.get(delivery.navigation.sessionCorrelation);
-        if (sessionCorrelation === undefined) throw Object.assign(new Error("DELIVERY_PROJECTION_STALE_BINDING"), { code: "DELIVERY_PROJECTION_STALE_BINDING" });
-        return Object.freeze({ ...delivery, navigation: Object.freeze({ sessionCorrelation }) });
+        const binding = sessions.get(delivery.navigation.sessionCorrelation);
+        if (binding === undefined || !exact(delivery, binding)) throw stale();
+        return Object.freeze({ ...delivery, navigation: Object.freeze({ sessionCorrelation: binding.sessionKey }) });
       })),
     });
   };
   return Object.freeze({
     async snapshot() { return mapSnapshot(await readModel.snapshot()); },
     async session(sessionCorrelation) {
-      const binding = await bindings.bySession(sessionCorrelation);
-      if (binding === undefined) return Object.freeze({ kind: "UNBOUND", sessionCorrelation });
-      const view = await readModel.session(binding.correlation);
-      if (view.kind === "UNBOUND") return Object.freeze({ kind: "UNBOUND", sessionCorrelation });
+      const [active, associations, snapshot] = await Promise.all([
+        bindings.bySession(sessionCorrelation), bindings.listProjection(), readModel.snapshot(),
+      ]);
+      const scoped = associations.filter((binding) => binding.sessionKey === sessionCorrelation);
+      if (scoped.length === 0) return Object.freeze({ kind: "UNBOUND", sessionCorrelation });
+      const matched = scoped.map((binding) => {
+        const candidates = snapshot.deliveries.filter((delivery) => exact(delivery, binding));
+        if (candidates.length !== 1) throw stale();
+        return Object.freeze({ binding, delivery: candidates[0] });
+      });
+      let selected;
+      if (active !== undefined) {
+        selected = matched.find(({ binding }) => binding.state === "BOUND" && binding.deliveryId === active.deliveryId);
+        if (selected === undefined) throw stale();
+      } else {
+        const historical = matched.filter(({ binding, delivery }) => binding.state === "HISTORICAL"
+          && delivery.lifecycle === "TERMINAL" && delivery.recoverable === false);
+        if (historical.length !== matched.length) throw stale();
+        historical.sort((left, right) => right.delivery.timing.updatedAt - left.delivery.timing.updatedAt
+          || right.delivery.deliveryId.localeCompare(left.delivery.deliveryId));
+        selected = historical[0];
+      }
       return Object.freeze({
         kind: "BOUND",
         sessionCorrelation,
-        delivery: Object.freeze({ ...view.delivery, navigation: Object.freeze({ sessionCorrelation }) }),
+        delivery: Object.freeze({ ...selected.delivery, navigation: Object.freeze({ sessionCorrelation }) }),
       });
     },
     async subscribe(listener, onError) {

package/src/intake/binding-repository.js

@@ -10,7 +10,7 @@ export class IntakeBindingError extends Error {
   }
 }
 
-function exact(value) {
+function exactActive(value) {
   if (value === null || typeof value !== "object" || Array.isArray(value)
     || Object.keys(value).sort().join(",") !== "correlation,deliveryBindingIdentity,deliveryId,sessionKey,state,worktree"
     || typeof value.sessionKey !== "string" || value.sessionKey.length === 0
@@ -31,21 +31,28 @@ function exact(value) {
   });
 }
 
-function legacy(value) {
+function exactHistorical(value) {
   if (value === null || typeof value !== "object" || Array.isArray(value)
-    || Object.keys(value).sort().join(",") !== "correlation,deliveryId,sessionKey,state,worktree"
+    || Object.keys(value).sort().join(",") !== "correlation,deliveryBindingIdentity,deliveryId,sessionKey,worktree"
     || typeof value.sessionKey !== "string" || value.sessionKey.length === 0
     || typeof value.correlation !== "string" || value.correlation.length === 0
     || typeof value.deliveryId !== "string" || value.deliveryId.length === 0
+    || typeof value.deliveryBindingIdentity !== "string" || !/^sha256:[0-9a-f]{64}$/u.test(value.deliveryBindingIdentity)
     || typeof value.worktree !== "string" || !isAbsolute(value.worktree)
-    || !["BOUND", "DETACHED"].includes(value.state)) {
+  ) {
     throw new IntakeBindingError("INTAKE_BINDING_INVARIANT_VIOLATION");
   }
-  return Object.freeze({ ...value, worktree: resolve(value.worktree) });
+  return Object.freeze({
+    sessionKey: value.sessionKey,
+    correlation: value.correlation,
+    deliveryId: value.deliveryId,
+    deliveryBindingIdentity: value.deliveryBindingIdentity,
+    worktree: resolve(value.worktree),
+  });
 }
 
-function validate(bindings) {
-  const accepted = bindings.map(exact);
+function validateActive(bindings) {
+  const accepted = bindings.map(exactActive);
   if (new Set(accepted.map((entry) => entry.sessionKey)).size !== accepted.length
     || new Set(accepted.map((entry) => entry.correlation)).size !== accepted.length
     || new Set(accepted.map((entry) => entry.deliveryId)).size !== accepted.length
@@ -56,8 +63,28 @@ function validate(bindings) {
   return accepted;
 }
 
+function validateHistorical(associations) {
+  const accepted = associations.map(exactHistorical);
+  if (new Set(accepted.map((entry) => entry.correlation)).size !== accepted.length
+    || new Set(accepted.map((entry) => entry.deliveryId)).size !== accepted.length
+    || new Set(accepted.map((entry) => entry.deliveryBindingIdentity)).size !== accepted.length) {
+    throw new IntakeBindingError("INTAKE_BINDING_INVARIANT_VIOLATION");
+  }
+  return accepted;
+}
+
+function validateTogether(active, historical) {
+  const all = [...active, ...historical];
+  if (new Set(all.map((entry) => entry.correlation)).size !== all.length
+    || new Set(all.map((entry) => entry.deliveryId)).size !== all.length
+    || new Set(all.map((entry) => entry.deliveryBindingIdentity)).size !== all.length) {
+    throw new IntakeBindingError("INTAKE_BINDING_INVARIANT_VIOLATION");
+  }
+}
+
 export class IntakeSessionBindingRepository {
-  #bindings = [];
+  #active = [];
+  #historical = [];
   #started = false;
   constructor(file) {
     if (typeof file !== "string" || !isAbsolute(file)) throw new IntakeBindingError("INTAKE_BINDING_INVARIANT_VIOLATION");
@@ -69,91 +96,137 @@ export class IntakeSessionBindingRepository {
     try {
       const document = JSON.parse(await readFile(this.file, "utf8"));
       if (document === null || typeof document !== "object" || Array.isArray(document)
-        || Object.keys(document).sort().join(",") !== "bindings,schemaVersion" || !Array.isArray(document.bindings)
-        || !["execution.intake-bindings@1.0.0", "execution.intake-bindings@2.0.0"].includes(document.schemaVersion)) {
+        || Object.keys(document).sort().join(",") !== "activeBindings,historicalAssociations,schemaVersion"
+        || document.schemaVersion !== "execution.intake-bindings@3.0.0"
+        || !Array.isArray(document.activeBindings) || !Array.isArray(document.historicalAssociations)) {
         throw new IntakeBindingError("INTAKE_BINDING_INVARIANT_VIOLATION");
       }
-      if (document.schemaVersion === "execution.intake-bindings@2.0.0") {
-        this.#bindings = validate(document.bindings);
-      } else {
-        if (!Array.isArray(inventory)) throw new IntakeBindingError("INTAKE_BINDING_INVARIANT_VIOLATION");
-        this.#bindings = validate(document.bindings.map((candidate) => {
-          const entry = legacy(candidate);
-          const matches = inventory.filter((item) => item !== null && typeof item === "object"
-            && item.deliveryId === entry.deliveryId && typeof item.worktree === "string" && isAbsolute(item.worktree)
-            && resolve(item.worktree) === entry.worktree
-            && typeof item.deliveryBindingIdentity === "string" && /^sha256:[0-9a-f]{64}$/u.test(item.deliveryBindingIdentity));
-          if (matches.length !== 1) throw new IntakeBindingError("INTAKE_BINDING_INVARIANT_VIOLATION");
-          return { ...entry, deliveryBindingIdentity: matches[0].deliveryBindingIdentity };
-        }));
-        await this.#persist();
-      }
+      this.#active = validateActive(document.activeBindings);
+      this.#historical = validateHistorical(document.historicalAssociations);
+      validateTogether(this.#active, this.#historical);
     } catch (cause) {
       if (cause?.code !== "ENOENT") {
         if (cause instanceof IntakeBindingError) throw cause;
         throw new IntakeBindingError("INTAKE_BINDING_INVARIANT_VIOLATION");
       }
-      this.#bindings = [];
+      this.#active = [];
+      this.#historical = [];
     }
     this.#started = true;
   }
 
   async claim(input) {
     this.#ready();
-    const candidate = exact({ ...input, state: "BOUND" });
-    const session = this.#bindings.find((entry) => entry.sessionKey === candidate.sessionKey);
+    const candidate = exactActive({ ...input, state: "BOUND" });
+    const session = this.#active.find((entry) => entry.sessionKey === candidate.sessionKey);
     if (session !== undefined) {
       if (session.deliveryId === candidate.deliveryId && session.correlation === candidate.correlation
         && session.worktree === candidate.worktree && session.deliveryBindingIdentity === candidate.deliveryBindingIdentity) return session;
       if (session.state === "DETACHED" && session.deliveryId === candidate.deliveryId
         && session.worktree === candidate.worktree && session.deliveryBindingIdentity === candidate.deliveryBindingIdentity) {
-        this.#bindings.splice(this.#bindings.indexOf(session), 1, candidate);
+        this.#active.splice(this.#active.indexOf(session), 1, candidate);
         await this.#persist();
         return candidate;
       }
       throw new IntakeBindingError("SESSION_INTAKE_BOUND");
     }
-    const delivery = this.#bindings.find((entry) => entry.deliveryId === candidate.deliveryId);
+    if (this.#historical.some((entry) => entry.deliveryId === candidate.deliveryId
+      || entry.correlation === candidate.correlation || entry.deliveryBindingIdentity === candidate.deliveryBindingIdentity)) {
+      throw new IntakeBindingError("INTAKE_BINDING_INVARIANT_VIOLATION");
+    }
+    const delivery = this.#active.find((entry) => entry.deliveryId === candidate.deliveryId);
     if (delivery?.state === "BOUND") throw new IntakeBindingError("DELIVERY_INTAKE_BOUND");
     if (delivery?.state === "DETACHED") {
       if (delivery.worktree !== candidate.worktree || delivery.deliveryBindingIdentity !== candidate.deliveryBindingIdentity) {
         throw new IntakeBindingError("INTAKE_BINDING_INVARIANT_VIOLATION");
       }
-      this.#bindings.splice(this.#bindings.indexOf(delivery), 1, candidate);
+      this.#active.splice(this.#active.indexOf(delivery), 1, candidate);
     }
-    else this.#bindings.push(candidate);
+    else this.#active.push(candidate);
+    validateTogether(this.#active, this.#historical);
     await this.#persist();
     return candidate;
   }
 
   async bySession(sessionKey) {
     this.#ready();
-    return this.#bindings.find((entry) => entry.sessionKey === sessionKey);
+    return this.#active.find((entry) => entry.sessionKey === sessionKey);
   }
 
   async byDelivery(deliveryId) {
     this.#ready();
-    return this.#bindings.find((entry) => entry.deliveryId === deliveryId);
+    return this.#active.find((entry) => entry.deliveryId === deliveryId);
   }
 
   async list() {
     this.#ready();
-    return Object.freeze([...this.#bindings]);
+    return Object.freeze([...this.#active]);
+  }
+
+  async listProjection() {
+    this.#ready();
+    return Object.freeze([
+      ...this.#active.filter((entry) => entry.state === "BOUND"),
+      ...this.#historical.map((entry) => Object.freeze({ ...entry, state: "HISTORICAL" })),
+    ]);
+  }
+
+  async archiveTerminal(sessionKey, delivery) {
+    this.#ready();
+    if (typeof sessionKey !== "string" || sessionKey.length === 0
+      || delivery === null || typeof delivery !== "object" || Array.isArray(delivery)
+      || delivery.lifecycle !== "TERMINAL" || delivery.recoverable !== false || delivery.current !== null
+      || typeof delivery.navigation?.sessionCorrelation !== "string"
+      || !Number.isSafeInteger(delivery.timing?.updatedAt)
+      || delivery.terminal === null || typeof delivery.terminal !== "object"
+      || !["SUCCEEDED", "FAILED", "CANCELLED"].includes(delivery.terminal.outcome)
+      || delivery.terminal.finishedAt !== delivery.timing.updatedAt) {
+      throw new IntakeBindingError("INTAKE_BINDING_INVARIANT_VIOLATION");
+    }
+    const candidate = exactHistorical({
+      sessionKey,
+      correlation: delivery.navigation.sessionCorrelation,
+      deliveryId: delivery.deliveryId,
+      deliveryBindingIdentity: delivery.deliveryBindingIdentity,
+      worktree: delivery.worktree,
+    });
+    const sameCoordinate = (entry) => entry.deliveryId === candidate.deliveryId
+      || entry.correlation === candidate.correlation || entry.deliveryBindingIdentity === candidate.deliveryBindingIdentity;
+    const historical = this.#historical.find(sameCoordinate);
+    if (historical !== undefined) {
+      if (historical.sessionKey === candidate.sessionKey && historical.deliveryId === candidate.deliveryId
+        && historical.correlation === candidate.correlation && historical.worktree === candidate.worktree
+        && historical.deliveryBindingIdentity === candidate.deliveryBindingIdentity) return historical;
+      throw new IntakeBindingError("INTAKE_BINDING_INVARIANT_VIOLATION");
+    }
+    const active = this.#active.find(sameCoordinate);
+    if (active !== undefined) {
+      if (active.sessionKey !== candidate.sessionKey || active.deliveryId !== candidate.deliveryId
+        || active.correlation !== candidate.correlation || active.worktree !== candidate.worktree
+        || active.deliveryBindingIdentity !== candidate.deliveryBindingIdentity) {
+        throw new IntakeBindingError("INTAKE_BINDING_INVARIANT_VIOLATION");
+      }
+      this.#active.splice(this.#active.indexOf(active), 1);
+    }
+    this.#historical.push(candidate);
+    validateTogether(this.#active, this.#historical);
+    await this.#persist();
+    return candidate;
   }
 
   async markDetached(deliveryId) {
     this.#ready();
-    const index = this.#bindings.findIndex((entry) => entry.deliveryId === deliveryId);
-    if (index === -1 || this.#bindings[index].state === "DETACHED") return;
-    this.#bindings.splice(index, 1, Object.freeze({ ...this.#bindings[index], state: "DETACHED" }));
+    const index = this.#active.findIndex((entry) => entry.deliveryId === deliveryId);
+    if (index === -1 || this.#active[index].state === "DETACHED") return;
+    this.#active.splice(index, 1, Object.freeze({ ...this.#active[index], state: "DETACHED" }));
     await this.#persist();
   }
 
   async detach(deliveryId) {
     this.#ready();
-    const index = this.#bindings.findIndex((entry) => entry.deliveryId === deliveryId);
+    const index = this.#active.findIndex((entry) => entry.deliveryId === deliveryId);
     if (index === -1) return;
-    this.#bindings.splice(index, 1);
+    this.#active.splice(index, 1);
     await this.#persist();
   }
 
@@ -164,7 +237,11 @@ export class IntakeSessionBindingRepository {
   async #persist() {
     await mkdir(dirname(this.file), { recursive: true, mode: 0o700 });
     const temporary = `${this.file}.${randomUUID()}.tmp`;
-    const document = { schemaVersion: "execution.intake-bindings@2.0.0", bindings: this.#bindings };
+    const document = {
+      schemaVersion: "execution.intake-bindings@3.0.0",
+      activeBindings: this.#active,
+      historicalAssociations: this.#historical,
+    };
     await writeFile(temporary, `${JSON.stringify(document)}\n`, { flag: "wx", mode: 0o600 });
     await rename(temporary, this.file);
   }

package/src/intake/command.js

@@ -42,3 +42,13 @@ export function parseWsrCommand(value) {
   }
   return invalid();
 }
+
+export function promptDiagnostic(operation, attachments = []) {
+  if (operation?.operation !== "create") return undefined;
+  const hasPrompt = typeof operation.remainder === "string" && operation.remainder.trim().length > 0;
+  if (hasPrompt || (Array.isArray(attachments) && attachments.length > 0)) return undefined;
+  return Object.freeze({
+    code: "TASK_PROMPT_REQUIRED",
+    message: "Add a Task instruction after the Workflow selector or attach a file.",
+  });
+}