@capxul/mcp 4.2.0-rc.12 → 4.2.0-rc.14

package/dist/capxul-source.json

@@ -1,11 +1,11 @@
 {
   "source": {
-    "commit": "fd5b4d0f124c75f609e469b8673c61f84253c0dc",
-    "tree": "d61f0f6b0c83dfc2d405ffc6b55eecf2e9d80f2d",
+    "commit": "ad9386dd8d539fea17964d05292fc0ca16495d2f",
+    "tree": "87b1723ed13d7be72487cbcbbfded24b0ac850e5",
     "branch": "codex/programme-rc",
     "repository": "https://github.com/Xelmar-tech/infrastructure",
     "lockfileSha256": "5870f53b72706d103220c1bcf733cb4fb71196aea32a9cfbdc277d73cc959264"
   },
   "name": "@capxul/mcp",
-  "version": "4.2.0-rc.12"
+  "version": "4.2.0-rc.14"
 }

package/dist/main.mjs

@@ -6947,6 +6947,8 @@ const CAPXUL_OPERATIONS = {
 		cancelRequest: "financialOps.cancelRequest",
 		createPayee: "financialOps.createPayee",
 		declineRequest: "financialOps.declineRequest",
+		emitInvoiceIssued: "financialOps.emitInvoiceIssued",
+		emitInvoiceRequestTransitioned: "financialOps.emitInvoiceRequestTransitioned",
 		emitPaymentWriterTelemetry: "financialOps.emitPaymentWriterTelemetry",
 		issueRequest: "financialOps.issueRequest",
 		recoverSettlementVerification: "financialOps.recoverSettlementVerification",
@@ -6957,6 +6959,7 @@ const CAPXUL_OPERATIONS = {
 		current: "holdings.current",
 		primary: "holdings.primary"
 	},
+	indexer: { reconcile: "indexer.reconcile" },
 	identity: {
 		accountAt: "identity.AccountAt",
 		accountClaimed: "identity.AccountClaimed",
@@ -7046,6 +7049,7 @@ const CAPXUL_OPERATIONS = {
 		createOrg: "org.createOrg",
 		create: "org.create",
 		detectAndAcceptPendingInvitations: "org.detectAndAcceptPendingInvitations",
+		emitInviteProgressed: "org.emitInviteProgressed",
 		expireInvitations: "org.expireInvitations",
 		getLifecycle: "org.getLifecycle",
 		getProofReceipt: "org.getProofReceipt",
@@ -7850,6 +7854,26 @@ const MovementScanIncidentProps = Schema.Struct({
 	incident_kind: Schema.String,
 	anchor_block_number: Schema.Number
 });
+/**
+* One durable row the reconciliation job corrected against Ponder (SPEC D9).
+*
+* Both block fields are optional and for the same reason: a correction INTO
+* drift (a Payment settled in Convex whose Ponder fact a reorg removed) has no
+* current block, and a correction that confirms a later fact has one.
+*
+* `projection_kind` is closed. A later ticket that reconciles a deploy, a
+* bootstrap or a grant outcome adds its kind here in the same change; an
+* unknown kind must not decode.
+*/
+const IndexerDriftCorrectedProps = Schema.Struct({
+	...TelemetryEnvelopeProps,
+	projection_kind: Schema.Literals(["member_authority", "payment_settlement"]),
+	previous_state: Schema.String,
+	current_state: Schema.String,
+	previous_block: Schema.optional(Schema.Number),
+	current_block: Schema.optional(Schema.Number),
+	logical_event_id: Schema.optional(Schema.String)
+});
 Schema.Struct({
 	name: Schema.Literal("auth_otp_requested"),
 	props: AuthOtpRequestedProps
@@ -8054,6 +8078,10 @@ Schema.Struct({
 	name: Schema.Literal("movement_scan_incident"),
 	props: MovementScanIncidentProps
 });
+Schema.Struct({
+	name: Schema.Literal("indexer_drift_corrected"),
+	props: IndexerDriftCorrectedProps
+});
 /** The one spelling of "whose scope did this happen in" across every surface. */
 const ScopeKindSchema = Schema.Literals(["account", "organization"]);
 const AccountKindSchema = Schema.Literals(["personalSafe", "orgTreasury"]);
@@ -9644,6 +9672,13 @@ Schema.Struct({
 	transfers: Schema.Array(TransferEvidenceSchema),
 	requestCount: nonNegativeInteger("requestCount")
 });
+/**
+* `chainId:txHash:transactionLogOrdinal` — the indexer's own row id. The
+* ordinal is the position in the transaction's receipt logs, never the
+* block-global index that `eventLogIndex` carries.
+*/
+const LOGICAL_EVENT_ID_RE = /^[1-9][0-9]{0,9}:0x[0-9a-f]{64}:(0|[1-9][0-9]{0,5})$/u;
+const LogicalEventIdSchema = Schema.String.pipe(Schema.refine((value) => LOGICAL_EVENT_ID_RE.test(value), { message: "must be chainId:txHash:transactionLogOrdinal" }));
 const VerifiedMoneyEvidenceCommonSchema = Schema.Struct({
 	chainId: BaseSepoliaChainIdSchema,
 	contractAddress: AddressSchema,
@@ -9652,7 +9687,17 @@ const VerifiedMoneyEvidenceCommonSchema = Schema.Struct({
 	blockNumber: BlockNumberSchema,
 	blockHash: Bytes32Schema,
 	blockTimestamp: Uint48Schema,
-	eventLogIndex: LogIndexSchema
+	/**
+	* The block-global log index of the settled event, as
+	* `eth_getTransactionReceipt` reports it. Both readers key on this value, and
+	* the ledger de-duplicates a settlement on `(txHash, eventLogIndex)`.
+	*/
+	eventLogIndex: LogIndexSchema,
+	/**
+	* The indexer row the fact was read from. Present only when the indexer
+	* answered; the receipt-backed reader reads no row and sets nothing.
+	*/
+	logicalEventId: Schema.optional(LogicalEventIdSchema)
 });
 const VerifiedPaymentEvidenceSchema = Schema.Struct({
 	...VerifiedMoneyEvidenceCommonSchema.fields,
@@ -11884,31 +11929,31 @@ function makeActorRelationshipMethods(deps) {
 					reference: input.reference,
 					...input.memo === void 0 ? {} : { memo: input.memo },
 					...input.expiresAt === void 0 ? {} : { expiresAt: input.expiresAt }
-				}))), (request) => mapActorRequest(request, input.payer)), controls, CAPXUL_OPERATIONS.requests.issue, deps.runPromise);
+				}))), (request) => mapActorRequest(request, input.payer)).pipe(Effect.tap(() => observeContactScope)), controls, CAPXUL_OPERATIONS.requests.issue, deps.runPromise);
 			},
 			list: (options) => {
 				const controls = deps.invocationControls?.(options) ?? options;
-				return runPortEffect(mapReply(CAPXUL_OPERATIONS.requests.list, Effect.suspend(() => convexCall.query(fns.requestsList, copyInvocationObservation(controls, { actor }))), (requests) => requests.map((request) => mapActorRequest(request))), controls, CAPXUL_OPERATIONS.requests.list, deps.runPromise);
+				return runPortEffect(mapReply(CAPXUL_OPERATIONS.requests.list, Effect.suspend(() => convexCall.query(fns.requestsList, copyInvocationObservation(controls, { actor }))), (requests) => requests.map((request) => mapActorRequest(request))).pipe(Effect.tap(() => observeContactScope)), controls, CAPXUL_OPERATIONS.requests.list, deps.runPromise);
 			},
 			get: (requestId, options) => {
 				const controls = deps.invocationControls?.(options) ?? options;
 				return runPortEffect(mapReply(CAPXUL_OPERATIONS.requests.get, Effect.suspend(() => convexCall.query(fns.requestsGet, copyInvocationObservation(controls, {
 					actor,
 					paymentRequestId: requestId
-				}))), (request) => request === null ? null : mapActorRequest(request)), controls, CAPXUL_OPERATIONS.requests.get, deps.runPromise);
+				}))), (request) => request === null ? null : mapActorRequest(request)).pipe(Effect.tap(() => observeContactScope)), controls, CAPXUL_OPERATIONS.requests.get, deps.runPromise);
 			},
 			cancel: (requestId, options) => {
 				const controls = deps.invocationControls?.(options) ?? options;
 				return runPortEffect(mapReply(CAPXUL_OPERATIONS.requests.cancel, Effect.suspend(() => convexCall.mutation(fns.requestsCancel, copyInvocationObservation(controls, {
 					actor,
 					paymentRequestId: requestId
-				}))), (request) => mapActorRequest(request)), controls, CAPXUL_OPERATIONS.requests.cancel, deps.runPromise);
+				}))), (request) => mapActorRequest(request)).pipe(Effect.tap(() => observeContactScope)), controls, CAPXUL_OPERATIONS.requests.cancel, deps.runPromise);
 			}
 		},
 		inbox: {
 			list: (options) => {
 				const controls = deps.invocationControls?.(options) ?? options;
-				return runPortEffect(mapReply(CAPXUL_OPERATIONS.inbox.list, Effect.suspend(() => convexCall.query(fns.inboxList, copyInvocationObservation(controls, { actor }))), (items) => items.map(mapInboxItem)), controls, CAPXUL_OPERATIONS.inbox.list, deps.runPromise);
+				return runPortEffect(mapReply(CAPXUL_OPERATIONS.inbox.list, Effect.suspend(() => convexCall.query(fns.inboxList, copyInvocationObservation(controls, { actor }))), (items) => items.map(mapInboxItem)).pipe(Effect.tap(() => observeContactScope)), controls, CAPXUL_OPERATIONS.inbox.list, deps.runPromise);
 			},
 			approve: (input, options) => {
 				const controls = deps.invocationControls?.(options) ?? options;
@@ -11920,14 +11965,14 @@ function makeActorRelationshipMethods(deps) {
 				}))).pipe(Effect.flatMap((prepared) => {
 					const result = mapApprovedInboxPayment(prepared, input);
 					return result.ok ? Effect.succeed(result.value) : Effect.fail({ publicError: result.error });
-				})), controls, CAPXUL_OPERATIONS.inbox.approve, deps.runPromise);
+				}), Effect.tap(() => observeContactScope)), controls, CAPXUL_OPERATIONS.inbox.approve, deps.runPromise);
 			},
 			decline: (requestId, options) => {
 				const controls = deps.invocationControls?.(options) ?? options;
 				return runPortEffect(mapReply(CAPXUL_OPERATIONS.inbox.decline, Effect.suspend(() => convexCall.mutation(fns.inboxDecline, copyInvocationObservation(controls, {
 					actor,
 					paymentRequestId: requestId
-				}))), mapInboxItem), controls, CAPXUL_OPERATIONS.inbox.decline, deps.runPromise);
+				}))), mapInboxItem).pipe(Effect.tap(() => observeContactScope)), controls, CAPXUL_OPERATIONS.inbox.decline, deps.runPromise);
 			}
 		},
 		profile: {
@@ -12783,7 +12828,7 @@ function subscribeActivity(deps, actor, controls, onChange) {
 }
 //#endregion
 //#region ../../packages/sdk/package.json
-var version$1 = "4.2.0-rc.12";
+var version$1 = "4.2.0-rc.14";
 //#endregion
 //#region ../../packages/sdk/src/telemetry/exception-projection.ts
 /** Fixed fallback for failures that have no safe message. */
@@ -14036,10 +14081,12 @@ function makeFinancialOpsMethods(deps) {
 				return runPortEffect(Effect.suspend(() => deps.convexCall.query(fns.depositInstructions, copyInvocationObservation(controls, {}))).pipe(Effect.tap((instructions) => emitDepositInitiated(deps.telemetry, instructions, controls))), controls, CAPXUL_OPERATIONS.me.depositInstructions, deps.runPromise);
 			}
 		},
-		targets: { resolve: async (reference, options) => {
-			const recipient = normalizeTargetForBackend(reference, "reference");
-			if (!recipient.ok) return recipient;
-			return mapOk(await runIfActive(options?.signal, CAPXUL_OPERATIONS.recipient.resolve, () => deps.convexCall.query(fns.resolveRecipient, { recipient: recipient.value })), resolvedTargetFromResolution);
+		targets: { resolve: (reference, options) => {
+			const controls = deps.invocationControls?.(options) ?? options;
+			return runPortEffect(projectReply(Effect.suspend(() => {
+				const recipient = normalizeTargetForBackend(reference, "reference");
+				return recipient.ok ? deps.convexCall.query(fns.resolveRecipient, copyInvocationObservation(controls, { recipient: recipient.value })) : Effect.fail({ publicError: recipient.error });
+			}), resolvedTargetFromResolution), controls, CAPXUL_OPERATIONS.recipient.resolve, deps.runPromise);
 		} },
 		destinations: {
 			add: (input, options) => {
@@ -14102,8 +14149,14 @@ function makeFinancialOpsMethods(deps) {
 				kind: "claim",
 				paymentId
 			}, deps.invocationControls?.(options) ?? options, CAPXUL_OPERATIONS.payments.claim),
-			list: async (options) => mapOk(await runIfActive(options?.signal, CAPXUL_OPERATIONS.payments.list, () => deps.convexCall.query(fns.listPayments, {})), (payments) => payments.map(normalizePaymentTiming)),
-			get: async (paymentId, options) => mapOk(await runIfActive(options?.signal, CAPXUL_OPERATIONS.payments.get, () => deps.convexCall.query(fns.getPayment, { paymentId })), (payment) => payment === null ? null : normalizePaymentTiming(payment)),
+			list: (options) => {
+				const controls = deps.invocationControls?.(options) ?? options;
+				return runPortEffect(projectReply(Effect.suspend(() => deps.convexCall.query(fns.listPayments, copyInvocationObservation(controls, {}))), (payments) => payments.map(normalizePaymentTiming)), controls, CAPXUL_OPERATIONS.payments.list, deps.runPromise);
+			},
+			get: (paymentId, options) => {
+				const controls = deps.invocationControls?.(options) ?? options;
+				return runPortEffect(projectReply(Effect.suspend(() => deps.convexCall.query(fns.getPayment, copyInvocationObservation(controls, { paymentId }))), (payment) => payment === null ? null : normalizePaymentTiming(payment)), controls, CAPXUL_OPERATIONS.payments.get, deps.runPromise);
+			},
 			cancel: (paymentId, options) => runLifecycle({
 				kind: "cancel",
 				paymentId
@@ -14471,6 +14524,22 @@ function normalizePaymentTiming(payment) {
 		timing: payment.timing ?? payment.release ?? { kind: "instant" }
 	};
 }
+/**
+* `mapOk`, moved inside the observed Effect (R09 #1967).
+*
+* The projection can refuse — `toAddress` and `toPartyId` throw on a malformed
+* reply — and every verb on this surface returns a `CapxulResult`, so that
+* throw stays a value here (ADR-0023). The error identity is `mapOk`'s: a
+* `CapxulError` passes through, anything else becomes `Errors.unknown(cause)`.
+* Running it inside the runner is what puts the decode failure on the same
+* operation record as the read that produced the reply.
+*/
+function projectReply(program, project) {
+	return program.pipe(Effect.flatMap((value) => Effect.try({
+		try: () => project(value),
+		catch: (cause) => ({ publicError: cause instanceof CapxulError ? cause : Errors.unknown(cause) })
+	})));
+}
 function mapOk(result, f) {
 	if (!result.ok) return result;
 	try {
@@ -19121,6 +19190,8 @@ const OBSERVED_CONVEX_QUERIES = /* @__PURE__ */ new Set([
 	"movement/activity:summary",
 	"movement/activity:get",
 	"financialOps/queries:depositInstructions",
+	"financialOps/queries:listPayments",
+	"financialOps/queries:getPayment",
 	"financialOps/destinations:list",
 	"financialOps/queries:verifyPaymentDocument",
 	"financialOps/queries:renderStoredDocument",
@@ -19845,11 +19916,11 @@ var ConvexOrganizationAdapter = class {
 		return this.listMembers(input).pipe(Effect.map((members) => members.filter((member) => member.status === "pending" || member.status === "pending_safe" || member.status === "pending_grant")));
 	}
 	inviteMember(input) {
-		return this.#convex.action(this.#fns.inviteMember, {
+		return this.#convex.action(this.#fns.inviteMember, copyInvocationObservation(input, {
 			orgId: input.orgId,
 			email: input.input.email,
 			role: input.input.role
-		}).pipe(Effect.mapError((error) => orgErrorFromCapxul("inviteMember", error.publicError, error)), Effect.map(brandOrgMember), Effect.catchDefect((cause) => Effect.fail(toOrgError("inviteMember", cause))));
+		})).pipe(Effect.mapError((error) => orgErrorFromCapxul("inviteMember", error.publicError, error)), Effect.map(brandOrgMember), Effect.catchDefect((cause) => Effect.fail(toOrgError("inviteMember", cause))));
 	}
 	resendInviteToken(input) {
 		return this.#convex.mutation(this.#fns.resendInvite, {
@@ -45808,18 +45879,6 @@ function emitOrgCreateFailed(telemetry, error) {
 		}
 	});
 }
-function emitOrgInviteSent(telemetry, input) {
-	const domain = emailDomain$1(input.email);
-	return emitOrgTelemetry(telemetry, {
-		name: "org_invite_sent",
-		props: {
-			org_id: input.orgId,
-			...domain === void 0 ? {} : { email_domain: domain },
-			role: input.role,
-			status: input.status
-		}
-	});
-}
 function reportOrgTelemetryFailure(kind, name, cause) {
 	if (!isOrgTelemetryDebugEnabled()) return;
 	globalThis.console?.warn?.("[capxul] org telemetry dropped", {
@@ -45995,25 +46054,26 @@ function listMembersProgram(orgId) {
 		return [];
 	});
 }
+/**
+* R06 (#1964): the SDK no longer emits `org_invite_sent`. The backend action
+* that writes the invitation is its ONE producer, so a hermetic call — which
+* writes nothing — can no longer report an invitation that never happened, and
+* a live call is counted once instead of twice. The captured attempt rides the
+* port input, so the durable event carries the correlation this call ran under.
+*/
 function inviteMemberProgram(orgId, input) {
 	return Effect.gen(function* () {
 		const deps = yield* OrgDepsTag;
-		const member = deps.orgPort !== void 0 ? yield* deps.orgPort.inviteMember({
-			orgId,
-			input
-		}).pipe(Effect.mapError((error) => error.publicError)) : hermeticMember({
+		if (deps.orgPort === void 0) return hermeticMember({
 			orgId,
 			email: input.email,
 			role: input.role,
 			status: "pending"
 		});
-		yield* Effect.promise(() => emitOrgInviteSent(deps.telemetry, {
+		return yield* deps.orgPort.inviteMember(copyInvocationObservation(deps.invocationSource, {
 			orgId,
-			email: input.email,
-			role: member.role,
-			status: member.status
-		}));
-		return member;
+			input
+		})).pipe(Effect.mapError((error) => error.publicError));
 	});
 }
 function detectAndAcceptPendingInvitationsProgram() {
@@ -46280,11 +46340,15 @@ function makeOrgMethods(deps) {
 					return toCapxulResult(listRolesProgram(orgId), layer);
 				},
 				invite(_input, _options) {
-					if (_options?.signal?.aborted) return Promise.resolve({
+					const controls = deps.invocationControls?.(_options) ?? _options;
+					if (controls?.signal?.aborted) return Promise.resolve({
 						ok: false,
 						error: Errors.cancelled({ operation: CAPXUL_OPERATIONS.org.invite })
 					});
-					return toCapxulResult(inviteMemberProgram(orgId, _input), layer);
+					return runCapxulEffect(inviteMemberProgram(orgId, _input).pipe(Effect.provide(orgDepsLayer({
+						...orgDeps,
+						...controls === void 0 ? {} : { invocationSource: controls }
+					}))), controls, CAPXUL_OPERATIONS.org.invite, deps.runPromise);
 				},
 				auditLog(_options) {
 					if (_options?.signal?.aborted) return Promise.resolve({
@@ -47221,6 +47285,7 @@ function identity(row) {
 		chainId: toChainId(integer(row, "chain_id")),
 		txHash: toTxHash(hex(row, "tx_hash")),
 		transactionLogOrdinal: integer(row, "transaction_log_ordinal"),
+		logIndex: integer(row, "log_index"),
 		blockNumber: big(row, "block_number"),
 		blockHash: hex(row, "block_hash"),
 		timestamp: big(row, "timestamp")
@@ -47303,8 +47368,8 @@ function decodeStatus(body) {
 * that allowlist changes, this file changes with it or every read fails 403.
 */
 const HEADS = {
-	transfer: "select \"id\", \"chain_id\", \"tx_hash\", \"transaction_log_ordinal\", \"block_number\", \"block_hash\", \"timestamp\", \"asset_id\", \"token\", \"from\", \"to\", \"amount\" from \"transfer\" where (\"transfer\".\"from\" = $1 or \"transfer\".\"to\" = $2) order by \"transfer\".\"block_number\" desc, \"transfer\".\"id\" desc",
-	payment: "select \"id\", \"chain_id\", \"tx_hash\", \"transaction_log_ordinal\", \"block_number\", \"block_hash\", \"timestamp\", \"contract\", \"settlement_id\", \"sender\", \"recipient\", \"asset_id\", \"token\", \"amount\", \"kind\", \"document_hash\" from \"payment\" where (\"payment\".\"sender\" = $1 or \"payment\".\"recipient\" = $2) order by \"payment\".\"block_number\" desc, \"payment\".\"id\" desc",
+	transfer: "select \"id\", \"chain_id\", \"tx_hash\", \"transaction_log_ordinal\", \"log_index\", \"block_number\", \"block_hash\", \"timestamp\", \"asset_id\", \"token\", \"from\", \"to\", \"amount\" from \"transfer\" where (\"transfer\".\"from\" = $1 or \"transfer\".\"to\" = $2) order by \"transfer\".\"block_number\" desc, \"transfer\".\"id\" desc",
+	payment: "select \"id\", \"chain_id\", \"tx_hash\", \"transaction_log_ordinal\", \"log_index\", \"block_number\", \"block_hash\", \"timestamp\", \"contract\", \"settlement_id\", \"sender\", \"recipient\", \"asset_id\", \"token\", \"amount\", \"kind\", \"document_hash\" from \"payment\" where (\"payment\".\"sender\" = $1 or \"payment\".\"recipient\" = $2) order by \"payment\".\"block_number\" desc, \"payment\".\"id\" desc",
 	balance: "select \"chain_id\", \"asset_id\", \"to\", \"amount\" from \"balance\" where \"balance\".\"to\" = $1"
 };
 /** How many times the statement binds the Safe address. */
@@ -48949,7 +49014,7 @@ function stdioIdentity(env = process.env, options = {}) {
 }
 //#endregion
 //#region package.json
-var version = "4.2.0-rc.12";
+var version = "4.2.0-rc.14";
 //#endregion
 //#region src/deps.ts
 const NO_IDENTITY = async () => void 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capxul/mcp",
-  "version": "4.2.0-rc.12",
+  "version": "4.2.0-rc.14",
   "private": false,
   "description": "Capxul MCP server for auth, Account readiness, identity, Organizations, relationships, requests, destinations, and testnet funding over Streamable HTTP.",
   "keywords": [
@@ -50,9 +50,9 @@
     "typescript": "npm:@typescript/typescript6@6.0.2",
     "vite": "npm:@voidzero-dev/vite-plus-core@0.3.0",
     "vite-plus": "0.3.0",
-    "@capxul/sdk": "4.2.0-rc.12",
+    "@capxul/config": "0.3.0",
     "@capxul/typescript-config": "0.0.0",
-    "@capxul/config": "0.3.0"
+    "@capxul/sdk": "4.2.0-rc.14"
   },
   "scripts": {
     "dev": "vp exec tsx src/main.ts serve",