macp-sdk-typescript 0.14.0 → 0.14.1

package/CHANGELOG.md

@@ -4,6 +4,75 @@ All notable changes to `macp-sdk-typescript` are documented here. The format
 follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and the
 project uses [Semantic Versioning](https://semver.org/).
 
+## [0.14.1](https://github.com/multiagentcoordinationprotocol/macp-sdk-typescript/compare/v0.14.0...v0.14.1) (2026-10-03)
+
+
+### Bug Fixes
+
+* **parity:** re-vendor contract.json for contract_version 1.3.0 ([#156](https://github.com/multiagentcoordinationprotocol/macp-sdk-typescript/issues/156)) ([#157](https://github.com/multiagentcoordinationprotocol/macp-sdk-typescript/issues/157)) ([497949d](https://github.com/multiagentcoordinationprotocol/macp-sdk-typescript/commit/497949d2b29031d340f5d8cc2ef17ae34c946c42))
+
+## [Unreleased]
+
+### Added
+
+- **`TaskProjection.rejections: TaskRejectRecord[]`** (issue #151; a
+  cross-SDK parity audit against `macp-sdk-python`'s `TaskRejectRecord`,
+  `src/macp_sdk/task.py:53-58`). `TaskReject` now appends an unconditional
+  audit record — `taskId`, `assignee`, `reason?`, `sender` (from the
+  envelope, not the payload) — matching the convention already established
+  for `updates`/`completions`/`failures`. A `TaskReject` for an unknown
+  `taskId` still records a `rejections` entry (no crash, no silent drop) but
+  creates no `tasks` entry, unchanged from today. Deliberately does not fall
+  back `assignee` to the envelope sender the way Python's `p.assignee or
+  envelope.sender` does — this SDK's own sibling `TaskComplete`/`TaskFail`
+  handlers spread the payload's `assignee` as-is with no such fallback, and
+  intra-SDK consistency with that established pattern takes precedence here.
+
+### Fixed
+
+- **`BaseProjection` phase no longer regresses once `Committed`, and
+  `DecisionProjection` no longer lets a replayed `Proposal` rewind phase
+  from `Voting` back to `Evaluation` after voting has begun** (issue #150,
+  issue #153; found by a cross-SDK parity audit against `macp-sdk-python`'s
+  `_set_phase()`, `src/macp_sdk/base_projection.py:289-313`). All five
+  built-in mode projections now route every phase write through a new
+  shared, protected `setPhase()` choke point on `BaseProjection` that
+  no-ops once `phase === 'Committed'`, instead of assigning `this.phase`
+  directly at each of the (previously) 12 call sites across
+  `decision.ts`/`proposal.ts`/`task.ts`/`quorum.ts`/`handoff.ts` — only
+  `decision.ts`'s own Vote-branch guard protected this before. RFC-MACP-0007
+  §5 rule 6 separately requires a runtime to reject any
+  `Proposal`/`Evaluation`/`Objection` after the first accepted `Vote`;
+  `DecisionProjection`'s `Proposal` handler now guards on the pre-
+  `Evaluation` phase value (`if (this.phase === 'Proposal')
+  this.setPhase('Evaluation')`) so a replayed/retried `Proposal` (same
+  `proposalId`, a distinct `messageId` that still passes
+  `applyEnvelope`'s `message_id` dedup gate) can no longer rewind `phase`
+  back to `'Evaluation'` once voting has begun. `BaseProjection.
+  applyEnvelope`'s own direct `this.phase = 'Committed'` assignment for a
+  `Commitment` envelope is deliberately left untouched — exact parity with
+  Python's own `_set_phase()` docstring, which documents the same bypass.
+- **`buildDecisionPolicy` now rejects a `+Infinity` voting weight** (issue
+  #152; found by a cross-SDK parity audit against `macp-sdk-python`'s
+  `math.isfinite` guard, `src/macp_sdk/policy.py:186`). The per-weight
+  validation guard changed from `weight <= 0 || Number.isNaN(weight)` to
+  `weight <= 0 || !Number.isFinite(weight)` — `!Number.isFinite` is `true`
+  for `NaN`, `+Infinity`, and `-Infinity` alike, closing the `+Infinity` gap
+  the old `Number.isNaN`-only check missed (a `+Infinity` weight serializes
+  to JSON `null`, which is schema-invalid against
+  `decision-rules.schema.json`). `-Infinity`/`NaN` continue to throw,
+  unchanged.
+- **`watchers.ts`'s 5 "stream ended before receiving a ..." sites now throw
+  `MacpTransportError` instead of a bare `Error`** (issue #154; parity with
+  `macp-sdk-python` PR #138). `ModeRegistryWatcher.nextChange()`,
+  `RootsWatcher.nextChange()`, `SignalWatcher.nextSignal()`,
+  `PolicyWatcher.nextChange()`, and `SessionLifecycleWatcher.nextChange()`
+  each threw a bare `Error` when their stream ended before yielding a value;
+  a caller's single `catch (e) { if (e instanceof MacpSdkError) ... }` now
+  covers a cleanly-ended watch stream alongside every other SDK failure.
+  Message strings are unchanged byte-for-byte; `error.code` remains
+  `undefined` on all 5 (locally raised, no gRPC status to attach).
+
 ## [0.14.0](https://github.com/multiagentcoordinationprotocol/macp-sdk-typescript/compare/v0.13.0...v0.14.0) (2026-10-01)
 
 

package/dist/policy.js

@@ -105,9 +105,13 @@ function buildDecisionPolicy(policyId, description, rules, options) {
         }
         for (const [participant, weight] of Object.entries(weights)) {
             // weight <= 0 alone would let a NaN weight slip through (NaN <= 0 is
-            // false); the runtime guards this explicitly (registry.rs:596), mirrored
-            // here even though the Python reference does not check it separately.
-            if (weight <= 0 || Number.isNaN(weight)) {
+            // false); the runtime guards this explicitly (registry.rs:596).
+            // !Number.isFinite(weight) is true for NaN, +Infinity, and -Infinity
+            // alike -- the exact mirror of Python's own guard, policy.py:186:
+            // `if not math.isfinite(weight) or weight <= 0:` (issue #152; a
+            // +Infinity weight previously slipped past the old Number.isNaN-only
+            // check and serialized to JSON `null`, which is schema-invalid).
+            if (weight <= 0 || !Number.isFinite(weight)) {
                 throw new errors_1.MacpSessionError(`weights['${participant}'] must be > 0, got ${weight} -- a weight-0 observer is expressed by ` +
                     'omission from the map, not by an explicit 0');
             }

package/dist/projections/base.d.ts

@@ -226,4 +226,18 @@ export declare abstract class BaseProjection {
      * `MACP_LOG_LEVEL` environment variable.
      */
     protected recordAnomaly(anomaly: ProjectionAnomaly): void;
+    /**
+     * Assign `this.phase`, guarding against regression out of the terminal
+     * `'Committed'` state — parity with macp-sdk-python's `_set_phase`
+     * (`base_projection.py:289-313`). `applyEnvelope` sets `this.phase =
+     * 'Committed'` directly on a `Commitment` envelope and returns before
+     * `applyMode` is ever called (see `applyEnvelope` above), so this method is
+     * never asked to move *into* `'Committed'` — only ever *out of* it, which is
+     * exactly the case it exists to reject. Every subclass `applyMode`
+     * implementation must call this instead of assigning `this.phase` directly;
+     * the one exception is each subclass's own field initializer, which sets
+     * the starting phase before any message has been applied and can never
+     * observe `'Committed'`.
+     */
+    protected setPhase(phase: string): void;
 }

package/dist/projections/base.js

@@ -249,5 +249,23 @@ class BaseProjection {
         this.anomalies.push(anomaly);
         logging_1.logger.warn('projection anomaly', anomaly);
     }
+    /**
+     * Assign `this.phase`, guarding against regression out of the terminal
+     * `'Committed'` state — parity with macp-sdk-python's `_set_phase`
+     * (`base_projection.py:289-313`). `applyEnvelope` sets `this.phase =
+     * 'Committed'` directly on a `Commitment` envelope and returns before
+     * `applyMode` is ever called (see `applyEnvelope` above), so this method is
+     * never asked to move *into* `'Committed'` — only ever *out of* it, which is
+     * exactly the case it exists to reject. Every subclass `applyMode`
+     * implementation must call this instead of assigning `this.phase` directly;
+     * the one exception is each subclass's own field initializer, which sets
+     * the starting phase before any message has been applied and can never
+     * observe `'Committed'`.
+     */
+    setPhase(phase) {
+        if (this.phase === 'Committed')
+            return;
+        this.phase = phase;
+    }
 }
 exports.BaseProjection = BaseProjection;

package/dist/projections/decision.js

@@ -22,7 +22,15 @@ class DecisionProjection extends base_1.BaseProjection {
                     rationale: record.rationale,
                     sender: envelope.sender,
                 });
-                this.phase = 'Evaluation';
+                // RFC-MACP-0007 §5 rule 6: a runtime MUST reject any Proposal/
+                // Evaluation/Objection after the first accepted Vote. A replayed/
+                // retried Proposal (same proposalId, a distinct messageId that still
+                // passes applyEnvelope's message_id dedup gate) must therefore not
+                // rewind `phase` from 'Voting' back to 'Evaluation' (issue #153).
+                // Guarding on the initial phase value — mirrors macp-sdk-python's
+                // identical `if self.phase == "Proposal": self._set_phase(...)`.
+                if (this.phase === 'Proposal')
+                    this.setPhase('Evaluation');
                 break;
             }
             case 'Evaluation': {
@@ -80,20 +88,19 @@ class DecisionProjection extends base_1.BaseProjection {
                 // runtime rejects any session-scoped message once the session is
                 // non-OPEN, so a `Vote` cannot legally follow a `Commitment` in
                 // accepted history. If one reaches here anyway (the caller violated
-                // the accepted-only contract — see `applyEnvelope`'s docblock), do
-                // not regress `phase` out of `'Committed'`. Note "phase" itself is
-                // not a normative MACP term (it appears once, in passing, at
-                // RFC-MACP-0012 `:211`); this guard is justified by session
-                // terminality, not by a phase specification. An anomaly would be
-                // recorded here too, but unlike five of the six sites that were
-                // "frozen pending cross-SDK agreement" (issue #126/#128, now
-                // resolved for `duplicate_task_accept`/`settled_handoff` — see
-                // `base.ts`), this one is a session-terminality phase-regression
-                // guard, not a settlement discard, and remains genuinely undecided
-                // per #128's own explicit scoping. No behavior change here.
-                if (this.phase !== 'Committed') {
-                    this.phase = 'Voting';
-                }
+                // the accepted-only contract — see `applyEnvelope`'s docblock),
+                // `setPhase` (see `base.ts`) is what keeps `phase` from regressing
+                // out of `'Committed'`. Note "phase" itself is not a normative MACP
+                // term (it appears once, in passing, at RFC-MACP-0012 `:211`); this
+                // guard is justified by session terminality, not by a phase
+                // specification. An anomaly would be recorded here too, but unlike
+                // five of the six sites that were "frozen pending cross-SDK
+                // agreement" (issue #126/#128, now resolved for
+                // `duplicate_task_accept`/`settled_handoff` — see `base.ts`), this
+                // one is a session-terminality phase-regression guard, not a
+                // settlement discard, and remains genuinely undecided per #128's own
+                // explicit scoping. No behavior change here.
+                this.setPhase('Voting');
                 break;
             }
             default:

package/dist/projections/handoff.js

@@ -21,7 +21,7 @@ class HandoffProjection extends base_1.BaseProjection {
                     sender: envelope.sender,
                     status: 'offered',
                 });
-                this.phase = 'OfferPending';
+                this.setPhase('OfferPending');
                 break;
             }
             case 'HandoffContext': {
@@ -40,7 +40,7 @@ class HandoffProjection extends base_1.BaseProjection {
                     }
                     handoff.contextContentType = record.contentType;
                     if (this.phase === 'OfferPending')
-                        this.phase = 'ContextSharing';
+                        this.setPhase('ContextSharing');
                 }
                 break;
             }
@@ -72,7 +72,7 @@ class HandoffProjection extends base_1.BaseProjection {
                     // (proto-registry), so this is always a real boolean once proto 0.1.6
                     // is loaded — `true` marks a runtime synthetic implicit accept.
                     handoff.implicit = record.implicit ?? false;
-                    this.phase = 'Accepted';
+                    this.setPhase('Accepted');
                 }
                 else {
                     this.recordAnomaly({
@@ -107,7 +107,7 @@ class HandoffProjection extends base_1.BaseProjection {
                 if (handoff.status === 'offered' || handoff.status === 'context_sent') {
                     handoff.status = 'declined';
                     handoff.declinedBy = record.declinedBy;
-                    this.phase = 'Declined';
+                    this.setPhase('Declined');
                 }
                 else {
                     this.recordAnomaly({

package/dist/projections/proposal.d.ts

@@ -38,6 +38,19 @@ export interface ProposalRejectRecord {
     reason?: string;
     sender: string;
 }
+/**
+ * The three reachable `ProposalRecord.status` values, as a runtime array —
+ * cross-SDK contract pinned by the spec repo's `schemas/parity/contract.json`
+ * (`proposal_disposition.projection_status_values`, `contract_version`
+ * 1.3.0, issue #156). `satisfies readonly ProposalRecord['status'][]` links
+ * this array to the type above at compile time, and `_ProposalStatusIsFrozen`
+ * below closes the loop in the other direction — together they prove at
+ * `npm run check` time, not just in a docblock, that `status` can never hold
+ * an acceptance-shaped value like `'accepted'` (see `ProposalRecord.status`'s
+ * own docblock above for why acceptance is tracked separately). See
+ * `tests/parity/contract.test.ts`.
+ */
+export declare const PROPOSAL_STATUS_VALUES: readonly ["open", "rejected", "withdrawn"];
 export declare class ProposalProjection extends BaseProjection {
     protected readonly mode = "macp.mode.proposal.v1";
     readonly proposals: Map<string, ProposalRecord>;

package/dist/projections/proposal.js

@@ -1,8 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProposalProjection = void 0;
+exports.ProposalProjection = exports.PROPOSAL_STATUS_VALUES = void 0;
 const constants_1 = require("../constants");
 const base_1 = require("./base");
+/**
+ * The three reachable `ProposalRecord.status` values, as a runtime array —
+ * cross-SDK contract pinned by the spec repo's `schemas/parity/contract.json`
+ * (`proposal_disposition.projection_status_values`, `contract_version`
+ * 1.3.0, issue #156). `satisfies readonly ProposalRecord['status'][]` links
+ * this array to the type above at compile time, and `_ProposalStatusIsFrozen`
+ * below closes the loop in the other direction — together they prove at
+ * `npm run check` time, not just in a docblock, that `status` can never hold
+ * an acceptance-shaped value like `'accepted'` (see `ProposalRecord.status`'s
+ * own docblock above for why acceptance is tracked separately). See
+ * `tests/parity/contract.test.ts`.
+ */
+exports.PROPOSAL_STATUS_VALUES = [
+    'open',
+    'rejected',
+    'withdrawn',
+];
 class ProposalProjection extends base_1.BaseProjection {
     mode = constants_1.MODE_PROPOSAL;
     proposals = new Map();
@@ -86,7 +103,7 @@ class ProposalProjection extends base_1.BaseProjection {
                     const proposal = this.proposals.get(record.proposalId);
                     if (proposal) {
                         proposal.status = 'rejected';
-                        this.phase = 'TerminalRejected';
+                        this.setPhase('TerminalRejected');
                     }
                 }
                 break;

package/dist/projections/quorum.js

@@ -15,7 +15,7 @@ class QuorumProjection extends base_1.BaseProjection {
             case 'ApprovalRequest': {
                 const record = payload;
                 this.requests.set(record.requestId, { ...record, sender: envelope.sender });
-                this.phase = 'Voting';
+                this.setPhase('Voting');
                 break;
             }
             case 'Approve': {

package/dist/projections/task.d.ts

@@ -33,12 +33,19 @@ export interface TaskFailRecord {
     retryable: boolean;
     sender: string;
 }
+export interface TaskRejectRecord {
+    taskId: string;
+    assignee: string;
+    reason?: string;
+    sender: string;
+}
 export declare class TaskProjection extends BaseProjection {
     protected readonly mode = "macp.mode.task.v1";
     readonly tasks: Map<string, TaskRecord>;
     readonly updates: TaskUpdateRecord[];
     readonly completions: TaskCompleteRecord[];
     readonly failures: TaskFailRecord[];
+    readonly rejections: TaskRejectRecord[];
     phase: 'Pending' | 'Requested' | 'InProgress' | 'Completed' | 'Failed' | 'Committed';
     /**
      * The **session-level** active assignment: who currently holds the session's

package/dist/projections/task.js

@@ -9,6 +9,7 @@ class TaskProjection extends base_1.BaseProjection {
     updates = [];
     completions = [];
     failures = [];
+    rejections = [];
     phase = 'Pending';
     /**
      * The **session-level** active assignment: who currently holds the session's
@@ -46,7 +47,7 @@ class TaskProjection extends base_1.BaseProjection {
                     progress: 0,
                     sender: envelope.sender,
                 });
-                this.phase = 'Requested';
+                this.setPhase('Requested');
                 break;
             }
             case 'TaskAccept': {
@@ -90,7 +91,7 @@ class TaskProjection extends base_1.BaseProjection {
                         task.assignee = record.assignee;
                         task.status = 'accepted';
                         this.activeAssignment = { sender: envelope.sender, taskId: record.taskId };
-                        this.phase = 'InProgress';
+                        this.setPhase('InProgress');
                     }
                     else {
                         this.recordAnomaly({
@@ -109,6 +110,16 @@ class TaskProjection extends base_1.BaseProjection {
             }
             case 'TaskReject': {
                 const record = payload;
+                // Issue #151: unconditional audit record, matching this file's own
+                // TaskUpdate/TaskComplete/TaskFail convention (and Python's
+                // identical unconditional `self.rejections.append(...)`,
+                // task.py:186-196) — `sender` comes from the envelope, never the
+                // payload, matching the three sibling records. Deliberately does
+                // NOT fall back `assignee` to `envelope.sender` the way Python's
+                // `p.assignee or envelope.sender` does: TaskComplete/TaskFail below
+                // spread the payload's `assignee` as-is with no such fallback, and
+                // intra-SDK consistency wins over replicating Python's nuance here.
+                this.rejections.push({ ...record, sender: envelope.sender });
                 const task = this.tasks.get(record.taskId);
                 if (task)
                     task.status = 'rejected';
@@ -158,7 +169,7 @@ class TaskProjection extends base_1.BaseProjection {
                 if (task) {
                     task.status = 'completed';
                     task.progress = 1;
-                    this.phase = 'Completed';
+                    this.setPhase('Completed');
                 }
                 break;
             }
@@ -168,7 +179,7 @@ class TaskProjection extends base_1.BaseProjection {
                 const task = this.tasks.get(record.taskId);
                 if (task) {
                     task.status = 'failed';
-                    this.phase = 'Failed';
+                    this.setPhase('Failed');
                 }
                 break;
             }

package/dist/version.d.ts

@@ -4,4 +4,4 @@
  * Kept in sync with package.json by release-please (see the
  * `x-release-please-version` annotation).
  */
-export declare const VERSION = "0.14.0";
+export declare const VERSION = "0.14.1";

package/dist/version.js

@@ -7,4 +7,4 @@ exports.VERSION = void 0;
  * Kept in sync with package.json by release-please (see the
  * `x-release-please-version` annotation).
  */
-exports.VERSION = '0.14.0'; // x-release-please-version
+exports.VERSION = '0.14.1'; // x-release-please-version

package/dist/watchers.js

@@ -130,7 +130,7 @@ class ModeRegistryWatcher {
         const result = await gen.next();
         await gen.return(undefined);
         if (result.done)
-            throw new Error('stream ended before receiving a change');
+            throw new errors_1.MacpTransportError('stream ended before receiving a change');
         return result.value;
     }
 }
@@ -159,7 +159,7 @@ class RootsWatcher {
         const result = await gen.next();
         await gen.return(undefined);
         if (result.done)
-            throw new Error('stream ended before receiving a change');
+            throw new errors_1.MacpTransportError('stream ended before receiving a change');
         return result.value;
     }
 }
@@ -202,7 +202,7 @@ class SignalWatcher {
         const result = await gen.next();
         await gen.return(undefined);
         if (result.done)
-            throw new Error('stream ended before receiving a signal');
+            throw new errors_1.MacpTransportError('stream ended before receiving a signal');
         return result.value;
     }
 }
@@ -231,7 +231,7 @@ class PolicyWatcher {
         const result = await gen.next();
         await gen.return(undefined);
         if (result.done)
-            throw new Error('stream ended before receiving a policy change');
+            throw new errors_1.MacpTransportError('stream ended before receiving a policy change');
         return result.value;
     }
 }
@@ -270,7 +270,7 @@ class SessionLifecycleWatcher {
         const result = await gen.next();
         await gen.return(undefined);
         if (result.done)
-            throw new Error('stream ended before receiving a session lifecycle event');
+            throw new errors_1.MacpTransportError('stream ended before receiving a session lifecycle event');
         return result.value;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "macp-sdk-typescript",
-  "version": "0.14.0",
+  "version": "0.14.1",
   "description": "TypeScript SDK for the MACP Rust runtime",
   "license": "Apache-2.0",
   "type": "commonjs",