@fro.bot/systematic 3.4.0 → 3.4.1

package/README.md

@@ -3,7 +3,7 @@
 <picture>
   <source media="(prefers-color-scheme: dark)" srcset="./assets/banner.svg">
   <source media="(prefers-color-scheme: light)" srcset="./assets/banner.svg">
-  <img alt="Systematic — Compound-Engineering Workflows for OpenCode, Pi, and Claude Code" src="./assets/banner.svg" width="100%">
+  <img alt="Systematic — Compound-Engineering Loops for OpenCode, Pi, and Claude Code" src="./assets/banner.svg" width="100%">
 </picture>
 
 <br><br>
@@ -29,7 +29,7 @@ You want AI that follows your process, not just your prompts. You want repeatabl
 
 ## What You Get
 
-Systematic is a compound-engineering workflow: brainstorm, plan, work, review — each phase a structured skill that guides the AI through requirements exploration, implementation planning, execution, and code review, capturing what was learned along the way. It ships 31 bundled skills and 37 specialized agents for architecture, security, performance, design, and code review.
+Systematic is a compound-engineering loop: brainstorm, plan, work, review — each phase a structured skill that guides the AI through requirements exploration, implementation planning, execution, and code review, capturing what was learned along the way. It ships 31 bundled skills and 37 specialized agents for architecture, security, performance, design, and code review.
 
 The workflow runs on three harnesses from one source: [OpenCode](https://opencode.ai/), [Pi](https://github.com/earendil-works/pi-coding-agent), and Claude Code. Each gets a native install path; skill and agent content is identical across all three.
 

package/dist/index.js

@@ -2890,6 +2890,19 @@ function seedFromMarker(marker) {
     capabilityFlags: marker.capabilityFlags
   };
 }
+function registrationDigestFromMarker(marker) {
+  if (marker.kind === "mint")
+    return marker.envelope.registrationDigest;
+  return marker.registrationDigest;
+}
+function filterMarkersByRegistration(markers, ownRegistrationDigest) {
+  return markers.filter((input) => {
+    const validation = validateReceiptMarker(input);
+    if (validation.status !== "valid")
+      return true;
+    return registrationDigestFromMarker(validation.marker) === ownRegistrationDigest;
+  });
+}
 function extractReceiptReadbackSeed(inputs) {
   if (inputs.length === 0)
     return { status: "empty" };
@@ -10400,6 +10413,11 @@ var statusToolSchema = exports_external.object(statusToolShape).strict();
 function isRecord7(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function decodeSessionSaltBytes(hex) {
+  if (typeof hex !== "string" || hex.length !== 64 || !/^[0-9a-f]+$/.test(hex))
+    return;
+  return Uint8Array.from(Buffer.from(hex, "hex"));
+}
 function boundedString(value, maxLength) {
   return typeof value === "string" && value.length > 0 && value.length <= maxLength;
 }
@@ -10979,6 +10997,46 @@ function createSessionRuntime(options) {
   function seedAgrees(nextLedger, seed) {
     return nextLedger.metadata.registrationDigest === seed.registrationDigest && JSON.stringify(nextLedger.metadata.capabilityFlags) === JSON.stringify(["workflow-guard"]);
   }
+  function candidateSeedFromMarker(input) {
+    const validation = validateReceiptMarker(input);
+    if (validation.status !== "valid")
+      return;
+    const marker = validation.marker;
+    if (marker.kind === "mint") {
+      const salt = decodeSessionSaltBytes(marker.sessionSalt);
+      return salt ? { salt, digest: marker.envelope.registrationDigest } : undefined;
+    }
+    if (marker.kind === "control" && marker.control === "progression") {
+      const salt = decodeSessionSaltBytes(marker.sessionSalt);
+      return salt ? { salt, digest: marker.registrationDigest } : undefined;
+    }
+    return;
+  }
+  function candidateAgreesWithOwnIdentity(salt, digest2) {
+    try {
+      const probe = createReceiptLedger({
+        capabilityFlags: ["workflow-guard"],
+        registrationIdentity: options.registrationIdentity,
+        sessionSalt: salt
+      });
+      return probe.metadata.registrationDigest === digest2;
+    } catch {
+      return false;
+    }
+  }
+  function resolveOwnRegistrationDigest(markers) {
+    const seenDigests = new Set;
+    for (const input of markers) {
+      const candidate = candidateSeedFromMarker(input);
+      if (!candidate || seenDigests.has(candidate.digest))
+        continue;
+      seenDigests.add(candidate.digest);
+      if (candidateAgreesWithOwnIdentity(candidate.salt, candidate.digest)) {
+        return candidate.digest;
+      }
+    }
+    return;
+  }
   function recoverPersistedMarkers(markers) {
     const seed = extractReceiptReadbackSeed(markers);
     if (seed.status !== "ready")
@@ -11017,6 +11075,39 @@ function createSessionRuntime(options) {
     initialized = true;
     return true;
   }
+  function classifyMarkersFromParts(parts2) {
+    const allMarkers = [];
+    for (const part of parts2)
+      collectReceiptMarkers(part, allMarkers);
+    if (allMarkers.length === 0)
+      return { kind: "foreign-empty" };
+    const ownDigest = resolveOwnRegistrationDigest(allMarkers);
+    if (ownDigest !== undefined) {
+      return {
+        kind: "own",
+        markers: filterMarkersByRegistration(allMarkers, ownDigest)
+      };
+    }
+    for (const input of allMarkers) {
+      const validation = validateReceiptMarker(input);
+      if (validation.status !== "valid") {
+        return { kind: "ambiguous" };
+      }
+      const candidate = candidateSeedFromMarker(input);
+      if (candidate === undefined) {
+        return { kind: "ambiguous" };
+      }
+    }
+    return { kind: "foreign-empty" };
+  }
+  function publishEmptyMarkers(parts2, allowFresh) {
+    if (allowFresh && !parts2.some((part) => containsGuardHistory(part))) {
+      publishFresh();
+    } else {
+      retryableEmptyHistory = true;
+      publishUnavailable();
+    }
+  }
   async function initializeSession(sessionID, allowFresh) {
     const reader = options.hostReadback?.readSessionParts;
     if (!reader) {
@@ -11030,19 +11121,16 @@ function createSessionRuntime(options) {
       publishUnavailable();
       return;
     }
-    const markers = [];
-    for (const part of parts2)
-      collectReceiptMarkers(part, markers);
-    if (markers.length === 0) {
-      if (allowFresh && !parts2.some((part) => containsGuardHistory(part))) {
-        publishFresh();
-      } else {
-        retryableEmptyHistory = true;
-        publishUnavailable();
-      }
+    const classification = classifyMarkersFromParts(parts2);
+    if (classification.kind === "ambiguous") {
+      publishUnavailable();
       return;
     }
-    if (!recoverPersistedMarkers(markers))
+    if (classification.kind === "foreign-empty") {
+      publishEmptyMarkers(parts2, allowFresh);
+      return;
+    }
+    if (!recoverPersistedMarkers(classification.markers))
       publishUnavailable();
   }
   async function recoverFromHost(sessionID, allowFresh = true) {
@@ -11080,12 +11168,15 @@ function createSessionRuntime(options) {
       markUnavailable();
       return;
     }
-    const markers = [];
-    for (const part of parts2)
-      collectReceiptMarkers(part, markers);
-    if (markers.length === 0)
+    const classification = classifyMarkersFromParts(parts2);
+    if (classification.kind === "foreign-empty")
       return;
-    const seed = extractReceiptReadbackSeed(markers);
+    if (classification.kind === "ambiguous") {
+      markUnavailable();
+      return;
+    }
+    const ownMarkers = classification.markers;
+    const seed = extractReceiptReadbackSeed(ownMarkers);
     if (seed.status !== "ready") {
       markUnavailable();
       return;
@@ -11099,7 +11190,7 @@ function createSessionRuntime(options) {
       markUnavailable();
       return;
     }
-    const recovered = childLedger.recoverReadback(markers);
+    const recovered = childLedger.recoverReadback(ownMarkers);
     if (recovered.status === "rejected") {
       markUnavailable();
       return;

package/dist/lib/receipt-readback.d.ts

@@ -156,6 +156,16 @@ export type ReceiptReadbackSeedResult = {
 };
 export declare function digestReceiptIdentity(domain: ReceiptDigestDomain, identity: string, sessionSalt: Uint8Array): string;
 export declare function validateReceiptMarker(input: unknown): ReceiptMarkerValidation;
+/**
+ * Filters a raw marker array, retaining only markers that belong to the given
+ * registrationDigest. Markers that cannot be parsed (malformed, unknown schema,
+ * etc.) are retained as-is so that downstream callers can fail-closed on them.
+ *
+ * Use this before extractReceiptReadbackSeed / foldReceiptReadback when the
+ * shared metadata array may contain markers from multiple concurrent
+ * registrations (e.g. dual-registration in a single OpenCode session).
+ */
+export declare function filterMarkersByRegistration(markers: readonly unknown[], ownRegistrationDigest: string): unknown[];
 export declare function extractReceiptReadbackSeed(inputs: readonly unknown[]): ReceiptReadbackSeedResult;
 export declare function projectReceiptMintMarker(receipt: unknown, sessionSalt: Uint8Array): ReceiptMintMarker | undefined;
 export declare function projectReceiptConsumptionMarker(receipt: unknown, transitionDigest: string, timestamp?: number): ReceiptConsumeMarker | undefined;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@fro.bot/systematic",
-  "version": "3.4.0",
-  "description": "Structured engineering workflows for OpenCode",
+  "version": "3.4.1",
+  "description": "Compound-engineering loops for OpenCode, Pi, and Claude Code",
   "type": "module",
   "homepage": "https://fro.bot/systematic",
   "main": "./dist/index.js",