@brightbeamai/chap-coordinator 0.2.9 → 0.2.10

package/README.md

@@ -216,7 +216,12 @@ task's `assignee`.
 
 Audit entries are hash-linked when the profile is active.
 `audit.verify_chain` replays the chain locally and confirms
-`prev_hash` continuity.
+`prev_hash` continuity. The verdict names the range it covered:
+`status` is `verified` with `ok: true` only when every entry was
+checked, and `not_evaluated` with `ok: false` when part of the log
+lies outside the chain, which happens when the profile is added to a
+workspace that already has entries. A broken chain is an error. Read
+`status`, or read `ok` and fail closed.
 
 `audit.submit_to_scitt` builds a SCITT-shaped signed statement for
 each audit entry in the requested range and passes it to a

package/dist/{api-DE78DA0o.d.cts → api-CcT_8H5j.d.cts}

@@ -175,6 +175,19 @@ declare class Coordinator {
     private opTaskComplete;
     private opAuditRead;
     private opReviewRequest;
+    /**
+     * Verify an optional `approved_artefact_digest` against the artefact under
+     * review (review/1.0 S3.2).
+     *
+     * The digest sits in params, so it is inside whatever the envelope signature
+     * covers: the decision then attests the content the reviewer saw rather than
+     * a task reference, and a relying party can check it without trusting the
+     * Coordinator that produced it. Absent, behaviour is exactly as before.
+     *
+     * On mismatch nothing is recorded and no state changes, so a client that
+     * computes the wrong digest refuses only its own decision.
+     */
+    private checkArtefactDigest;
     private opDecide;
     private opDecideOverride;
     private opAbstainDeclare;

package/dist/{api-CPEk0V6i.d.ts → api-Cvkhcalw.d.ts}

@@ -175,6 +175,19 @@ declare class Coordinator {
     private opTaskComplete;
     private opAuditRead;
     private opReviewRequest;
+    /**
+     * Verify an optional `approved_artefact_digest` against the artefact under
+     * review (review/1.0 S3.2).
+     *
+     * The digest sits in params, so it is inside whatever the envelope signature
+     * covers: the decision then attests the content the reviewer saw rather than
+     * a task reference, and a relying party can check it without trusting the
+     * Coordinator that produced it. Absent, behaviour is exactly as before.
+     *
+     * On mismatch nothing is recorded and no state changes, so a client that
+     * computes the wrong digest refuses only its own decision.
+     */
+    private checkArtefactDigest;
     private opDecide;
     private opDecideOverride;
     private opAbstainDeclare;

package/dist/api.d.cts

@@ -1,4 +1,4 @@
 import './methods.cjs';
-export { b as CoordinatorApi, c as CoordinatorError, g as call, m as makeApi } from './api-DE78DA0o.cjs';
+export { b as CoordinatorApi, c as CoordinatorError, g as call, m as makeApi } from './api-CcT_8H5j.cjs';
 import './types.cjs';
 import './storage/store.cjs';

package/dist/api.d.ts

@@ -1,4 +1,4 @@
 import './methods.js';
-export { b as CoordinatorApi, c as CoordinatorError, g as call, m as makeApi } from './api-CPEk0V6i.js';
+export { b as CoordinatorApi, c as CoordinatorError, g as call, m as makeApi } from './api-Cvkhcalw.js';
 import './types.js';
 import './storage/store.js';

package/dist/index.cjs

@@ -259,6 +259,7 @@ var E = {
   NOT_AUTHORISED: -32011,
   PATCH_FAILED: -32012,
   REVIEW_LAPSED: -32013,
+  REVIEW_ALREADY_OPEN: -32014,
   // whisper/1.0 profile (profiles/whisper.md S6)
   WHISPER_ALREADY_ANSWERED: -32020,
   WHISPER_LAPSED: -32021,
@@ -285,6 +286,7 @@ var E = {
   SIG_KEY_NOT_FOUND: -32071,
   SIG_KEY_REVOKED: -32072,
   SIG_ROTATION_KEY_MISMATCH: -32073,
+  SIG_ARTEFACT_DIGEST_MISMATCH: -32074,
   // audit-scitt/1.0 profile (profiles/audit-scitt.md S8)
   SCITT_UNREACHABLE: -32080,
   SCITT_STATEMENT_REJECTED: -32081,
@@ -752,6 +754,12 @@ function registerAuditScitt(coord) {
     if (!(ws.chain_enabled || coord.options.enableChain)) {
       return { error: rpcError(E.PARAMS, "Chain not enabled for this workspace") };
     }
+    if (p.from_seq !== void 0 || p.to_seq !== void 0) {
+      return { error: rpcError(
+        E.PARAMS,
+        "Range verification is not implemented; omit from_seq and to_seq to verify the whole log."
+      ) };
+    }
     let start = ws.audit.findIndex((e) => e.prev_hash != null);
     if (start < 0) start = ws.audit.length;
     const errors = [];
@@ -763,16 +771,35 @@ function registerAuditScitt(coord) {
       }
       prev = sha256Hex(Buffer.concat([canonicalize(e.envelope), Buffer.from(expectedPrev, "utf-8")]));
     }
-    const storedHead = ws.chain_head ?? ZERO_HASH;
+    const storedHead = ws.chain_head === void 0 || ws.chain_head === null ? ZERO_HASH : ws.chain_head;
     if (prev !== storedHead) {
       errors.push("chain_head mismatch: replay does not match stored head");
     }
     if (errors.length) {
       return { error: rpcError(E.PARAMS, errors.join("; ")) };
     }
+    const entriesTotal = ws.audit.length;
+    const entriesChecked = entriesTotal - start;
+    const entriesUnchecked = start;
+    if (entriesUnchecked > 0) {
+      return { result: {
+        status: "not_evaluated",
+        ok: false,
+        reason: "unchained_prefix",
+        entries_total: entriesTotal,
+        entries_checked: entriesChecked,
+        entries_unchecked: entriesUnchecked,
+        checked_from_seq: entriesChecked > 0 ? ws.audit[start].seq : null,
+        chain_head: storedHead
+      } };
+    }
     return { result: {
+      status: "verified",
       ok: true,
-      entries_checked: ws.audit.length - start,
+      entries_total: entriesTotal,
+      entries_checked: entriesChecked,
+      entries_unchecked: 0,
+      checked_from_seq: entriesChecked > 0 ? ws.audit[start].seq : null,
       chain_head: storedHead
     } };
   });
@@ -2463,12 +2490,38 @@ var Coordinator = class {
     const reviewers = Array.isArray(to) ? to : typeof to === "string" ? [to] : [];
     if (!reviewers.length) return { error: rpcError(E.PARAMS, "review.request needs 'to'") };
     const now = this.now();
+    const rule = p.rule || "any_one_approves";
+    if (task.state === "review_requested" && task.review) {
+      if (contentHash(task.pending_artefact) !== contentHash(p.artefact)) {
+        return { error: rpcError(
+          E.REVIEW_ALREADY_OPEN,
+          "A review is already open on this task with different content. Decide, abstain, escalate or cancel it before requesting review of a new artefact."
+        ) };
+      }
+      if (rule !== task.review.rule) {
+        return { error: rpcError(
+          E.REVIEW_ALREADY_OPEN,
+          `Cannot change the decision rule of an open review (currently ${task.review.rule})`
+        ) };
+      }
+      for (const r of reviewers) {
+        if (!task.review.requested_to.includes(r)) task.review.requested_to.push(r);
+      }
+      if (p.deadline !== void 0) task.review.deadline = p.deadline;
+      task.updated_at = now;
+      return { result: {
+        state: "review_requested",
+        review_id: task.id,
+        amended: true,
+        requested_to: [...task.review.requested_to]
+      } };
+    }
     task.state = "review_requested";
     task.updated_at = now;
     task.review = {
       requested_at: now,
       requested_to: reviewers,
-      rule: p.rule || "any_one_approves",
+      rule,
       deadline: p.deadline,
       decisions: []
     };
@@ -2476,6 +2529,37 @@ var Coordinator = class {
     task.pending_artefact = p.artefact;
     return { result: { state: "review_requested", review_id: task.id } };
   }
+  /**
+   * Verify an optional `approved_artefact_digest` against the artefact under
+   * review (review/1.0 S3.2).
+   *
+   * The digest sits in params, so it is inside whatever the envelope signature
+   * covers: the decision then attests the content the reviewer saw rather than
+   * a task reference, and a relying party can check it without trusting the
+   * Coordinator that produced it. Absent, behaviour is exactly as before.
+   *
+   * On mismatch nothing is recorded and no state changes, so a client that
+   * computes the wrong digest refuses only its own decision.
+   */
+  checkArtefactDigest(p, task) {
+    const declared = p.approved_artefact_digest;
+    if (declared === void 0 || declared === null) return null;
+    if (typeof declared !== "string") {
+      return { error: rpcError(E.PARAMS, "approved_artefact_digest must be a string") };
+    }
+    if (task.pending_artefact === void 0) {
+      return { error: rpcError(E.PARAMS, "No artefact under review to bind a digest to") };
+    }
+    const actual = contentHash(task.pending_artefact);
+    if (declared !== actual) {
+      return { error: rpcError(
+        E.SIG_ARTEFACT_DIGEST_MISMATCH,
+        "approved_artefact_digest does not match the artefact under review",
+        { declared, actual }
+      ) };
+    }
+    return null;
+  }
   opDecide(p, kind) {
     const miss = missing(p, ["workspace", "from", "task_id"]);
     if (miss) return { error: rpcError(E.PARAMS, `Missing field: ${miss}`) };
@@ -2492,6 +2576,8 @@ var Coordinator = class {
     }
     const notReviewer = this.requireReviewer(task, p.from);
     if (notReviewer) return notReviewer;
+    const digestError = this.checkArtefactDigest(p, task);
+    if (digestError) return digestError;
     const now = this.now();
     task.review.decisions.push({
       reviewer: p.from,
@@ -2526,6 +2612,8 @@ var Coordinator = class {
     }
     const notReviewer = this.requireReviewer(task, p.from);
     if (notReviewer) return notReviewer;
+    const digestError = this.checkArtefactDigest(p, task);
+    if (digestError) return digestError;
     const base = task.pending_artefact;
     if (base === void 0) return { error: rpcError(E.PARAMS, "No base artefact for override") };
     let applied;