macp-sdk-typescript 0.13.0 → 0.14.1

package/CHANGELOG.md

@@ -4,6 +4,88 @@ 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)
+
+
+### ⚠ BREAKING CHANGES
+
+* **agent:** encodeExtensions() (src/agent/runner.ts) no longer JSON-stringifies a session_start.extensions value. A string value is now base64-decoded (falling back to raw UTF-8 if it isn't valid base64); a number, boolean, plain object, array, or null value now throws instead of being silently JSON-encoded, as does a present-but-non-object extensions map itself. Buffer/Uint8Array values are unaffected. This reverses the UTF-8-JSON-encoding behavior documented in the 0.2.3 (SDK-TS-1) CHANGELOG entry, which silently put wire bytes on the connection that a conforming peer cannot decode.
+* **projections:** ProposalRecord.status's type no longer accepts 'accepted'. A TypeScript consumer comparing status === 'accepted' or switching on it now gets a compile-time TS2367/TS2678/TS2322 instead of silently-dead code; a plain-JS (or `as any`-cast) caller sees no behavior change, since the comparison always evaluated false.
+
+### Bug Fixes
+
+* **agent:** encodeExtensions() base64-decodes extensions values ([#149](https://github.com/multiagentcoordinationprotocol/macp-sdk-typescript/issues/149)) ([72c6ea4](https://github.com/multiagentcoordinationprotocol/macp-sdk-typescript/commit/72c6ea484e1dd5e75dbfc0bd12cbed787eeeacbd))
+* **projections:** ProposalRecord.status no longer accepts 'accepted' ([#147](https://github.com/multiagentcoordinationprotocol/macp-sdk-typescript/issues/147)) ([c5142d7](https://github.com/multiagentcoordinationprotocol/macp-sdk-typescript/commit/c5142d7c1ccd37b128549e512e9d5c6436899e30))
+
 ## [0.13.0](https://github.com/multiagentcoordinationprotocol/macp-sdk-typescript/compare/v0.12.0...v0.13.0) (2026-09-30)
 
 
@@ -131,6 +213,30 @@ project uses [Semantic Versioning](https://semver.org/).
   still only fails server-side). A caller that genuinely needs one
   credential reused across multiple senders should use
   `Auth.bearer(token, senderHint)` (the legacy two-arg form) instead.
+* **projections:** `ProposalRecord.status`'s type no longer accepts
+  `'accepted'` (issue #146). No code path has ever assigned it — acceptance
+  is tracked separately via `accepts`/`isAccepted()`, since it's a
+  per-sender, supersedable relation (RFC-MACP-0008 §5 rule 5), not a
+  per-proposal fact a scalar field could hold. A TypeScript consumer
+  comparing `status === 'accepted'` or switching on it now gets a
+  compile-time `TS2367`/`TS2678`/`TS2322` instead of silently-dead code; a
+  plain-JS (or `as any`-cast) caller sees no behavior change, since the
+  comparison always evaluated `false`.
+* **agent:** `fromBootstrap()`'s `encodeExtensions()` now base64-decodes a
+  `session_start.extensions` string value (falling back to raw UTF-8 for a
+  non-base64 string), instead of `JSON.stringify`-ing it, per RFC-MACP-0001
+  §10.3 (a protobuf `bytes` field's canonical JSON representation is
+  base64) — the wire-level `extensions` map is `map<string, bytes>` (issue
+  #139). This reverses the UTF-8-JSON-encoding behavior documented at the
+  `0.2.3` entry above (SDK-TS-1): that release's choice silently put wire
+  bytes on the connection that a conforming peer (including this SDK's own
+  `macp-sdk-python` counterpart) cannot decode, even for the canonical
+  example value. A number, boolean, plain object, array, or `null`
+  extension value — previously silently JSON-encoded — now throws at
+  bootstrap construction instead, naming the offending key; so does a
+  present-but-non-object `extensions` map itself. `Buffer`/`Uint8Array`
+  values are unaffected (same passthrough as before, for TS-only
+  in-process callers — never reachable via a JSON bootstrap file).
 
 ### Features
 
@@ -191,6 +297,12 @@ project uses [Semantic Versioning](https://semver.org/).
   sites. `DecisionProjection`'s late-`Vote`-after-`Commitment` site remains
   the one still-open, undecided case (per #128's own explicit scoping) —
   unaffected by this change.
+- **`encodeExtensions()` is now exported from `macp-sdk-typescript/agent`**
+  (issue #139), so a caller constructing a bootstrap `extensions` map
+  programmatically can validate/encode a value the same way
+  `fromBootstrap()` does, and so it's directly unit-testable (a
+  `Buffer`/`Uint8Array` value can't round-trip through a JSON bootstrap
+  file otherwise).
 
 ### Changed
 
@@ -466,6 +578,11 @@ project uses [Semantic Versioning](https://semver.org/).
   site — `taskId`, `title`, `requestId`, `proposalId`, `option`, `handoffId`,
   `targetParticipant`, `modeVersion`, `configurationVersion` — is unaffected
   and still rejects an empty value.
+- **`ProposalRecord.status`'s declared type no longer lies about
+  `'accepted'`** (issue #146). The union included `'accepted'` since this
+  type was first written, but nothing has ever assigned it — see the
+  `### ⚠ BREAKING CHANGES` entry above for why, and why that correction is a
+  breaking (not purely additive) change.
 
 ### Documentation
 

package/dist/agent/runner.d.ts

@@ -24,7 +24,7 @@ export interface BootstrapPayload {
             policy_version?: string;
             context?: Record<string, unknown>;
             context_id?: string;
-            extensions?: Record<string, unknown>;
+            extensions?: Record<string, string | Buffer | Uint8Array>;
             roots?: Array<{
                 uri: string;
                 name?: string;
@@ -50,3 +50,25 @@ export interface BootstrapPayload {
     };
 }
 export declare function fromBootstrap(bootstrapPath?: string): Participant;
+/**
+ * Coerce a bootstrap `session_start.extensions` map into the
+ * `Record<string, Buffer>` form the SessionStart envelope expects
+ * (`map<string, bytes>` on the wire).
+ *
+ * Per RFC-MACP-0001 §10.3, a protobuf `bytes` field's canonical JSON
+ * representation is a base64 string, so a `string` value is base64-decoded
+ * first (strict shape check via `BASE64_PATTERN`, not Node's lenient
+ * decoder); a string that isn't valid base64 falls back to raw UTF-8 bytes.
+ * This base64-first heuristic — and the resulting ambiguity for a plain
+ * string that happens to also be valid base64 — mirrors
+ * `macp-sdk-python`'s `_decode_extensions` on purpose, to stay
+ * byte-for-byte interoperable; it is a known, tracked wart, not fixed here.
+ * `Buffer`/`Uint8Array` values pass through unchanged, for TS-only
+ * in-process callers that already hold raw bytes (never reachable via a
+ * JSON bootstrap file). Anything else — including the `extensions`
+ * container itself being a non-object (string/number/boolean/array) —
+ * throws, naming the offending key and/or type, so a malformed bootstrap
+ * fails loudly at construction instead of silently corrupting wire bytes a
+ * peer can't decode (issue #139).
+ */
+export declare function encodeExtensions(extensions: Record<string, string | Buffer | Uint8Array> | undefined): Record<string, Buffer> | undefined;

package/dist/agent/runner.js

@@ -34,11 +34,13 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fromBootstrap = fromBootstrap;
+exports.encodeExtensions = encodeExtensions;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const auth_1 = require("../auth");
 const client_1 = require("../client");
 const constants_1 = require("../constants");
+const logging_1 = require("../logging");
 const participant_1 = require("./participant");
 function fromBootstrap(bootstrapPath) {
     const resolvedPath = bootstrapPath ?? process.env.MACP_BOOTSTRAP_FILE;
@@ -111,17 +113,53 @@ function fromBootstrap(bootstrapPath) {
     };
     return new participant_1.Participant(config);
 }
+// Matches a syntactically valid base64 string (correct alphabet, correct
+// padding) — a cheap stand-in for Python's `base64.b64decode(value,
+// validate=True)` so a plainly non-base64 string (e.g. "pack:example-001")
+// is rejected up front rather than silently mis-decoded by Node's lenient
+// `Buffer.from(str, 'base64')`, which ignores invalid characters instead of
+// raising. Matches the empty string too (decodes to an empty buffer either
+// way, so which branch handles it is immaterial).
+const BASE64_PATTERN = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
+function tryDecodeBase64(value) {
+    if (!BASE64_PATTERN.test(value))
+        return undefined;
+    return Buffer.from(value, 'base64');
+}
+function describeExtensionsValueType(value) {
+    if (value === null)
+        return 'null';
+    if (Array.isArray(value))
+        return 'array';
+    return typeof value;
+}
 /**
- * Serialise a JSON-native extensions map (as delivered in the bootstrap
- * payload) into the `Record<string, Buffer>` form the SessionStart envelope
- * expects. Each value is encoded as UTF-8 JSON so arbitrary structures
- * round-trip through the protobuf `bytes` field. `Buffer` / `Uint8Array`
- * values are passed through untouched so callers that already hold raw bytes
- * don't pay a double-encode.
+ * Coerce a bootstrap `session_start.extensions` map into the
+ * `Record<string, Buffer>` form the SessionStart envelope expects
+ * (`map<string, bytes>` on the wire).
+ *
+ * Per RFC-MACP-0001 §10.3, a protobuf `bytes` field's canonical JSON
+ * representation is a base64 string, so a `string` value is base64-decoded
+ * first (strict shape check via `BASE64_PATTERN`, not Node's lenient
+ * decoder); a string that isn't valid base64 falls back to raw UTF-8 bytes.
+ * This base64-first heuristic — and the resulting ambiguity for a plain
+ * string that happens to also be valid base64 — mirrors
+ * `macp-sdk-python`'s `_decode_extensions` on purpose, to stay
+ * byte-for-byte interoperable; it is a known, tracked wart, not fixed here.
+ * `Buffer`/`Uint8Array` values pass through unchanged, for TS-only
+ * in-process callers that already hold raw bytes (never reachable via a
+ * JSON bootstrap file). Anything else — including the `extensions`
+ * container itself being a non-object (string/number/boolean/array) —
+ * throws, naming the offending key and/or type, so a malformed bootstrap
+ * fails loudly at construction instead of silently corrupting wire bytes a
+ * peer can't decode (issue #139).
  */
 function encodeExtensions(extensions) {
-    if (!extensions)
+    if (extensions === undefined || extensions === null)
         return undefined;
+    if (typeof extensions !== 'object' || Array.isArray(extensions)) {
+        throw new Error(`bootstrap session_start.extensions must be an object, got ${describeExtensionsValueType(extensions)}`);
+    }
     const out = {};
     for (const [key, value] of Object.entries(extensions)) {
         if (Buffer.isBuffer(value)) {
@@ -130,8 +168,19 @@ function encodeExtensions(extensions) {
         else if (value instanceof Uint8Array) {
             out[key] = Buffer.from(value);
         }
+        else if (typeof value === 'string') {
+            const decoded = tryDecodeBase64(value);
+            if (decoded !== undefined) {
+                logging_1.logger.debug(`[fromBootstrap] extensions["${key}"] decoded as base64`);
+                out[key] = decoded;
+            }
+            else {
+                logging_1.logger.debug(`[fromBootstrap] extensions["${key}"] is not valid base64; falling back to raw UTF-8`);
+                out[key] = Buffer.from(value, 'utf8');
+            }
+        }
         else {
-            out[key] = Buffer.from(JSON.stringify(value), 'utf8');
+            throw new Error(`bootstrap extensions["${key}"] must be a base64-encoded string (or Buffer/Uint8Array), got ${describeExtensionsValueType(value)}`);
         }
     }
     return out;

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

@@ -14,9 +14,12 @@ export type ProjectionAnomalyKind = 'duplicate_vote' | 'duplicate_ballot' | 'dup
  * this proposal (RFC-MACP-0007 §5.3), or a second distinct ballot across
  * `Approve`/`Reject`/`Abstain` from this sender for this request
  * (RFC-MACP-0011 §5 rule 3), was observed and discarded — the first stands.
- * (RFC-MACP-0011 §5 rule 3 caps *how many* ballots and is silent on *which of
- * two* stands; first-ballot-wins here is parity with RFC-MACP-0007 §5.3 plus
- * runtime-enforced behaviour.)
+ * (RFC-MACP-0011 §5 rule 3 states "the first accepted ballot stands"
+ * directly, since the rule-3 hardening in spec PR
+ * multiagentcoordinationprotocol#85 — before that, this SDK's
+ * first-ballot-wins behaviour was an inference from parity with
+ * RFC-MACP-0007 §5.3 plus runtime-enforced behaviour, not a direct
+ * RFC-0011 citation.)
  *
  * **Deliberately narrow claim — do not overclaim "this transcript violates
  * the spec".** A projection cannot tell a genuinely non-conforming source
@@ -223,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

@@ -8,7 +8,24 @@ export interface ProposalRecord {
     tags?: string[];
     sender: string;
     supersedes?: string;
-    status: 'open' | 'accepted' | 'rejected' | 'withdrawn';
+    /**
+     * Reachable values only (issue #146). An `Accept` is recorded on the
+     * projection's `accepts` list (and surfaced via `acceptedProposal()` /
+     * `isAccepted()`), never on this field — no code path assigns `'accepted'`
+     * here. A non-terminal `Reject` likewise leaves this `'open'`; only a
+     * terminal `Reject` sets `'rejected'`.
+     *
+     * That is by design, not an omission: acceptance is a per-sender,
+     * supersedable relation (RFC-MACP-0008 §5 rule 5), not a per-proposal
+     * fact, so a scalar field here cannot hold it — "alice accepts p2 while
+     * bob still accepts p1" is a legal state. This mirrors the runtime, whose
+     * `ProposalDisposition` is `{Live, Withdrawn}` with acceptance in a
+     * separate `accepts` map, and `macp-sdk-python`'s own `status: str`
+     * (documented the same way after its issue #112). `task.ts`/`handoff.ts`
+     * do set `'accepted'`-equivalent statuses because their acceptance is one
+     * actor claiming one slot — this mode's isn't. See `docs/modes/proposal.md`.
+     */
+    status: 'open' | 'rejected' | 'withdrawn';
 }
 export interface ProposalAcceptRecord {
     proposalId: string;
@@ -21,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': {
@@ -54,21 +54,24 @@ class QuorumProjection extends base_1.BaseProjection {
         const senderMap = this.ballots.get(requestId) ?? new Map();
         const kept = senderMap.get(envelope.sender);
         if (kept !== undefined) {
-            // RFC-MACP-0011 §5 rule 3 (`:67`): participation is MAY (a participant need
-            // not cast a ballot), but the cap of one ballot per participant ACROSS
-            // Approve, Reject, and Abstain is enforced under §5's opening sentence,
-            // "Implementations MUST enforce the following:" (`:63`). Do NOT phrase this
-            // as "a participant MUST cast at most one ballot" — RFC-0011 puts the MUST
-            // on the implementation, not the participant (contrast RFC-MACP-0007 §5.3,
-            // which puts it directly on the participant; same obligation, different
-            // addressee). A later ballot of a *different* type is still a duplicate,
-            // not a change of vote, so this guard is keyed on the sender ALONE within
-            // the request — never on sender + vote. macp-runtime enforces this
-            // identically in all three arms (quorum.rs:164/184/204).
-            // Keeping the sender's FIRST ballot (rather than the last) is not stated
-            // by RFC-0011 either; it is parity with RFC-MACP-0007 §5 item 3's
-            // explicit first-stands rule for `Vote`, plus macp-runtime's enforced
-            // first-wins behaviour.
+            // RFC-MACP-0011 §5 rule 3 (`:69`, hardened by spec PR
+            // multiagentcoordinationprotocol#85): "Each eligible participant MUST
+            // cast at most one ballot per request_id... A runtime MUST reject a
+            // second ballot from the same sender for the same request_id,
+            // regardless of the type of either ballot; the first accepted ballot
+            // stands." Participation itself is still MAY (a participant need not
+            // ballot at all) — only the one-per-participant cap and first-wins
+            // outcome are MUST. A later ballot of a *different* type is still a
+            // duplicate, not a change of vote, so this guard is keyed on the
+            // sender ALONE within the request — never on sender + vote.
+            // macp-runtime enforces this identically in all three arms
+            // (quorum.rs:164/184/204).
+            //
+            // Keeping the sender's FIRST ballot is now a direct rule-3 citation
+            // (above), not an inference — before PR #85 hardened the rule, this
+            // comment relied on parity with RFC-MACP-0007 §5 item 3's first-stands
+            // rule for `Vote` plus macp-runtime's observed behavior, since RFC-0011
+            // capped *how many* ballots without yet stating *which* stands.
             this.recordAnomaly({
                 kind: 'duplicate_ballot',
                 mode: envelope.mode,

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.13.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.13.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.13.0",
+  "version": "0.14.1",
   "description": "TypeScript SDK for the MACP Rust runtime",
   "license": "Apache-2.0",
   "type": "commonjs",