@capxul/mcp 4.20.0-beta.10 → 4.20.0-beta.11

package/dist/main.mjs

@@ -825,6 +825,38 @@ function validateHandle(raw) {
 	return handle;
 }
 //#endregion
+//#region ../../packages/types/src/organization-setup.ts
+/** Backend-owned Organization setup states shared by wire and telemetry. */
+const ORGANIZATION_SETUP_STATUSES = [
+	"awaitingAuthorization",
+	"processing",
+	"needsAttention",
+	"ready",
+	"rechecking",
+	"failed"
+];
+/** Closed reasons for a stored Organization setup issue. */
+const ORGANIZATION_SETUP_REASONS = [
+	"submission_unknown",
+	"receipt_unresolved",
+	"provider_unavailable",
+	"receipt_reverted",
+	"deterministic_address_mismatch",
+	"receipt_mismatch",
+	"block_identity_changed",
+	"authority_event_mismatch",
+	"allowance_timestamp_mismatch",
+	"receipt_identity_unavailable",
+	"receipt_identity_mismatch",
+	"contract_code_unavailable",
+	"contract_state_mismatch",
+	"permission_projection_mismatch",
+	"bootstrap_reorg",
+	"dependent_authority_unresolved",
+	"historical_evidence_missing",
+	"worker_failed"
+];
+//#endregion
 //#region ../../packages/types/src/index.ts
 const ASSET_ID_RE = /^eip155:([1-9][0-9]*)\/erc20:(0x[0-9a-f]{40})$/;
 const EVM_ADDRESS_RE$1 = /^0x[0-9a-f]{40}$/i;
@@ -3227,9 +3259,6 @@ function normalizeBindingEmail(email) {
 	return normalizeSafeSaltEmail(email);
 }
 //#endregion
-//#region ../../packages/config/src/role-dsl.ts
-const ADMIN_ROLE_LABEL = "Admin";
-//#endregion
 //#region ../../packages/config/src/capxul-payments-v2.ts
 /** The exact compiled CapxulPaymentsV2 ABI. */
 const CAPXUL_PAYMENTS_V2_ABI = [
@@ -4066,8 +4095,7 @@ const RESTORING = { phase: "restoring" };
 const label = (state) => {
 	if (state.phase !== "authenticated") return state.phase;
 	if (state.account.at !== "claimed") return `authenticated:${state.account.at}`;
-	const org = state.account.org;
-	return org === null ? "authenticated:claimed" : `authenticated:claimed:${org.at}`;
+	return state.account.org === null ? "authenticated:claimed" : "authenticated:claimed:organization";
 };
 const EVENT_TAGS = [
 	"RequestOtp",
@@ -4085,8 +4113,8 @@ const EVENT_TAGS = [
 	"RetryAccount",
 	"CreateOrganization",
 	"AttachOrganization",
-	"RetryOrganization",
-	"LeaveOrganization"
+	"LeaveOrganization",
+	"ObserveOrganization"
 ];
 const PRIVATE_EVENT_TAGS = [
 	"OtpSent",
@@ -4102,9 +4130,8 @@ const PRIVATE_EVENT_TAGS = [
 	"AccountClaiming",
 	"AccountClaimed",
 	"AccountFailed",
-	"OrgAt",
-	"OrgReady",
-	"OrgFailed"
+	"OrgSelected",
+	"OrgSelectionFailed"
 ];
 const IDENTITY_EVENT_TAGS = [...EVENT_TAGS, ...PRIVATE_EVENT_TAGS];
 /** Valid in every `authenticated:*` position — the pre-S1 auth machine's row. */
@@ -4154,18 +4181,11 @@ const TRANSITION_TABLE = {
 		"CreateOrganization",
 		"AttachOrganization"
 	],
-	"authenticated:claimed:creating": [...SESSION_EVENTS],
-	"authenticated:claimed:loading": [...SESSION_EVENTS],
-	"authenticated:claimed:settingUp": [...SESSION_EVENTS],
-	"authenticated:claimed:ready": [
+	"authenticated:claimed:organization": [
 		...SESSION_EVENTS,
 		"AttachOrganization",
-		"LeaveOrganization"
-	],
-	"authenticated:claimed:failed": [
-		...SESSION_EVENTS,
-		"RetryOrganization",
-		"LeaveOrganization"
+		"LeaveOrganization",
+		"ObserveOrganization"
 	]
 };
 const DEFAULT_CONFIG = {
@@ -4245,36 +4265,24 @@ const privateTransition = (state, event) => {
 			failure: event.failure,
 			retryable: isRetryable(event.failure)
 		}) } : WRONG;
-		case "OrgAt": {
+		case "OrgSelected": {
 			const held = claimedOrg(state);
-			if (held === null || held.claimed.org === null) return WRONG;
-			const org = held.claimed.org;
-			return org.at === "creating" || org.at === "loading" || org.at === "settingUp" ? { next: withOrg(held.state, held.claimed, {
-				at: "settingUp",
-				orgId: event.orgId,
-				step: event.step
-			}) } : WRONG;
-		}
-		case "OrgReady": {
-			const held = claimedOrg(state);
-			if (held === null || held.claimed.org === null) return WRONG;
-			const org = held.claimed.org;
-			return org.at === "creating" || org.at === "settingUp" || org.at === "loading" ? { next: withOrg(held.state, held.claimed, {
-				at: "ready",
-				orgId: event.orgId
-			}) } : WRONG;
+			if (held === null || held.claimed.org === null || held.claimed.org.orgId !== null) return WRONG;
+			return { next: withOrg(held.state, held.claimed, {
+				orgId: event.setup.orgId,
+				setup: event.setup,
+				observation: "connected"
+			}) };
 		}
-		case "OrgFailed": {
+		case "OrgSelectionFailed": {
 			const held = claimedOrg(state);
-			if (held === null || held.claimed.org === null) return WRONG;
-			const org = held.claimed.org;
-			return org.at === "creating" || org.at === "loading" || org.at === "settingUp" ? { next: withOrg(held.state, held.claimed, {
-				at: "failed",
-				orgId: event.orgId,
-				step: event.step,
-				failure: event.failure,
-				retryable: event.retryable ?? isRetryable(event.failure)
-			}) } : WRONG;
+			if (held === null || held.claimed.org === null || held.claimed.org.orgId !== null) return WRONG;
+			return { next: withOrg(held.state, held.claimed, {
+				orgId: null,
+				setup: null,
+				observation: "error",
+				failure: event.failure
+			}) };
 		}
 	}
 };
@@ -4343,35 +4351,43 @@ const transition = (state, event, config = DEFAULT_CONFIG) => {
 		case "CreateOrganization": {
 			const held = claimedOrg(state);
 			if (held === null || held.claimed.org !== null) return WRONG;
-			const draft = {
-				name: event.draft.name,
-				handle: event.draft.handle,
-				country: event.draft.country
-			};
 			return { next: withOrg(held.state, held.claimed, {
-				at: "creating",
-				draft
+				orgId: null,
+				setup: null,
+				observation: "loading"
 			}) };
 		}
 		case "AttachOrganization": {
 			const held = claimedOrg(state);
 			if (held === null) return WRONG;
-			if (held.claimed.org?.at === "ready" && held.claimed.org.orgId === event.orgId) return { next: state };
-			if (held.claimed.org !== null && held.claimed.org.at !== "ready") return WRONG;
+			if (held.claimed.org?.orgId === event.orgId) return { next: state };
 			return { next: withOrg(held.state, held.claimed, {
-				at: "loading",
-				orgId: event.orgId
+				orgId: event.orgId,
+				setup: null,
+				observation: "loading"
 			}) };
 		}
-		case "RetryOrganization": {
+		case "ObserveOrganization": {
 			const held = claimedOrg(state);
-			if (held === null || held.claimed.org === null) return WRONG;
-			const org = held.claimed.org;
-			if (org.at !== "failed" || !org.retryable || org.orgId === null) return WRONG;
+			if (held === null || held.claimed.org?.orgId !== event.orgId) return WRONG;
+			const snapshot = event.snapshot;
+			if (snapshot.status === "value") {
+				if (String(snapshot.value.orgId) !== event.orgId) return { refused: "INVALID_INPUT" };
+				return { next: withOrg(held.state, held.claimed, {
+					orgId: event.orgId,
+					setup: snapshot.value,
+					observation: "connected"
+				}) };
+			}
 			return { next: withOrg(held.state, held.claimed, {
-				at: "settingUp",
-				orgId: org.orgId,
-				step: org.step
+				...held.claimed.org,
+				observation: snapshot.status === "loading" ? "loading" : "error",
+				...snapshot.status === "error" ? { failure: {
+					code: snapshot.error.code,
+					message: snapshot.error.message,
+					...snapshot.error.mode === void 0 ? {} : { mode: snapshot.error.mode },
+					error: snapshot.error
+				} } : {}
 			}) };
 		}
 		case "LeaveOrganization": {
@@ -7585,8 +7601,8 @@ const TelemetryEnvelopeProps = {
 * failure came from the chain path. Spread into every failure event and posted
 * on `$exception`, so one PostHog filter finds a cause wherever it was seen.
 */
-const FailureModeSchema = Schema.Literals(FAILURE_MODES$1);
-const ChainUpstreamSchema = Schema.Literals(CHAIN_UPSTREAMS);
+const FailureModeSchema$1 = Schema.Literals(FAILURE_MODES$1);
+const ChainUpstreamSchema$1 = Schema.Literals(CHAIN_UPSTREAMS);
 /**
 * The refusing upstream's response headers (#1818): exactly the names in
 * `RESPONSE_HEADER_ALLOWLIST`, each optional, so the catalog itself refuses a
@@ -7604,15 +7620,15 @@ const ResponseHeadersSchema = Schema.Struct({
 });
 /** One upstream tried, flat (#1818): the `chain_attempts` entry on every producer's row. */
 const ChainAttemptSchema = Schema.Struct({
-	upstream: ChainUpstreamSchema,
-	failure_mode: FailureModeSchema,
+	upstream: ChainUpstreamSchema$1,
+	failure_mode: FailureModeSchema$1,
 	http_status: Schema.optional(Schema.Number),
 	rpc_code: Schema.optional(Schema.Number),
 	duration_ms: Schema.Number
 });
 const ChainCauseTelemetryProps = {
-	failure_mode: Schema.optional(FailureModeSchema),
-	chain_upstream: Schema.optional(ChainUpstreamSchema),
+	failure_mode: Schema.optional(FailureModeSchema$1),
+	chain_upstream: Schema.optional(ChainUpstreamSchema$1),
 	chain_method: OptionalString,
 	chain_retryable: Schema.optional(Schema.Boolean),
 	chain_http_status: Schema.optional(Schema.Number),
@@ -7796,9 +7812,9 @@ const ChainUpstreamFallbackProps = Schema.Struct({
 	...TelemetryEnvelopeProps,
 	service: ChainServiceSchema,
 	method: Schema.String,
-	from_upstream: ChainUpstreamSchema,
-	to_upstream: Schema.optional(ChainUpstreamSchema),
-	failure_mode: FailureModeSchema,
+	from_upstream: ChainUpstreamSchema$1,
+	to_upstream: Schema.optional(ChainUpstreamSchema$1),
+	failure_mode: FailureModeSchema$1,
 	exhausted: Schema.Boolean,
 	http_status: Schema.optional(Schema.Number),
 	rpc_code: Schema.optional(Schema.Number),
@@ -7807,8 +7823,8 @@ const ChainUpstreamFallbackProps = Schema.Struct({
 const BundlerErrorProps = Schema.Struct({
 	...TelemetryEnvelopeProps,
 	method: Schema.String,
-	failure_mode: FailureModeSchema,
-	chain_upstream: ChainUpstreamSchema,
+	failure_mode: FailureModeSchema$1,
+	chain_upstream: ChainUpstreamSchema$1,
 	chain_retryable: Schema.Boolean,
 	http_status: Schema.optional(Schema.Number),
 	rpc_code: Schema.optional(Schema.Number),
@@ -7819,13 +7835,13 @@ const ReceiptPendingProps = Schema.Struct({
 	...TelemetryEnvelopeProps,
 	service: ChainServiceSchema,
 	method: Schema.String,
-	chain_upstream: ChainUpstreamSchema,
+	chain_upstream: ChainUpstreamSchema$1,
 	reason: Schema.Literals(["zero_block_hash", "no_receipt"])
 });
 const OperationRetriedProps = Schema.Struct({
 	...TelemetryEnvelopeProps,
 	operation: Schema.String,
-	failure_mode: FailureModeSchema,
+	failure_mode: FailureModeSchema$1,
 	reason: Schema.optional(Schema.Literal("connection-lost-in-flight")),
 	connection_id: OptionalString,
 	connection_count: Schema.optional(Schema.Number),
@@ -7866,14 +7882,16 @@ const OrganizationCreationStartedProps = Schema.Struct({
 	...TelemetryEnvelopeProps,
 	$insert_id: Schema.String,
 	organization_id: OrgIdTelemetrySchema,
-	attempt_number: AttemptNumberSchema
+	attempt_number: AttemptNumberSchema,
+	release: Schema.optional(Schema.String.check(Schema.isPattern(/^[0-9a-f]{40}$/u)))
 });
 const OrganizationCreationReadyProps = Schema.Struct({
 	...TelemetryEnvelopeProps,
 	$insert_id: Schema.String,
 	organization_id: OrgIdTelemetrySchema,
 	attempt_number: AttemptNumberSchema,
-	duration_ms: DurationMsSchema$1
+	duration_ms: DurationMsSchema$1,
+	release: Schema.optional(Schema.String.check(Schema.isPattern(/^[0-9a-f]{40}$/u)))
 });
 const OrganizationCreationFailedProps = Schema.Struct({
 	...TelemetryEnvelopeProps,
@@ -7884,20 +7902,13 @@ const OrganizationCreationFailedProps = Schema.Struct({
 	stage: OnboardingStageSchema,
 	error_code: Schema.String,
 	retryable: Schema.Boolean,
+	release: Schema.optional(Schema.String.check(Schema.isPattern(/^[0-9a-f]{40}$/u))),
 	/** #1655: the SDK's backoff before this attempt. Absent on the first attempt. */
 	backoff_ms: Schema.optional(DurationMsSchema$1),
 	failure_reason: Schema.optional(Schema.Literals([
-		"deterministic_address_mismatch",
 		"receipt_provider_unavailable",
-		"receipt_mismatch",
 		"block_provider_unavailable",
-		"authority_event_mismatch",
-		"allowance_timestamp_mismatch",
-		"receipt_identity_unavailable",
-		"receipt_identity_mismatch",
-		"contract_code_unavailable",
-		"contract_state_mismatch",
-		"permission_projection_mismatch"
+		...ORGANIZATION_SETUP_REASONS
 	]))
 });
 const OnboardingIntentSchema = Schema.Literals(["personal", "organization"]);
@@ -8654,12 +8665,17 @@ Schema.Struct({
 			"cancelled"
 		]),
 		duration_ms: Schema.Number,
+		organization_id: Schema.optional(OrgIdTelemetrySchema),
+		setup_status: Schema.optional(Schema.Literals(ORGANIZATION_SETUP_STATUSES)),
+		setup_reason: Schema.optional(Schema.Literals(ORGANIZATION_SETUP_REASONS)),
+		$groups: Schema.optional(Schema.Struct({ organization: OrgIdTelemetrySchema })),
 		error_code: Schema.optional(Schema.Literals([
 			...CAPXUL_ERROR_CODES,
 			"CLI_USAGE",
 			"CLI_CONFIG",
 			"CLI_STORAGE",
-			"CLI_DEFECT"
+			"CLI_DEFECT",
+			"CLI_DEADLINE"
 		]))
 	})
 });
@@ -9412,14 +9428,7 @@ const CAPXUL_FUNCTIONS = {
 		setOrgLogo: "media:setOrgLogo",
 		setProfileImage: "media:setProfileImage"
 	},
-	"org/actions": {
-		confirmBootstrap: "org/actions:confirmBootstrap",
-		prepareBootstrap: "org/actions:prepareBootstrap",
-		prepareFounderAccount: "org/actions:prepareFounderAccount",
-		readTreasury: "org/actions:readTreasury",
-		resumeBootstrapSubmission: "org/actions:resumeBootstrapSubmission",
-		submitBootstrap: "org/actions:submitBootstrap"
-	},
+	"org/actions": { readTreasury: "org/actions:readTreasury" },
 	"payroll/actions": { authorizeRun: "payroll/actions:authorizeRun" },
 	"payroll/mutations": {
 		removeGroup: "payroll/mutations:removeGroup",
@@ -9436,17 +9445,18 @@ const CAPXUL_FUNCTIONS = {
 		authorize: "permission/queries:authorize",
 		read: "permission/queries:read"
 	},
-	"org/lifecycle": {
-		getProofReceipt: "org/lifecycle:getProofReceipt",
-		load: "org/lifecycle:load",
-		recordFailure: "org/lifecycle:recordFailure",
-		retry: "org/lifecycle:retry",
-		startOrResume: "org/lifecycle:startOrResume"
+	"org/setup": {
+		begin: "org/setup:begin",
+		get: "org/setup:get",
+		getProofReceipt: "org/setup:getProofReceipt",
+		listMine: "org/setup:listMine",
+		prepareAuthorization: "org/setup:prepareAuthorization",
+		resume: "org/setup:resume",
+		submitAuthorization: "org/setup:submitAuthorization"
 	},
 	"org/mutations": {
 		accept: "org/mutations:accept",
 		cancel: "org/mutations:cancel",
-		createOrg: "org/mutations:createOrg",
 		decline: "org/mutations:decline",
 		invite: "org/mutations:invite",
 		resend: "org/mutations:resend",
@@ -9567,6 +9577,60 @@ const CLIENT_AUTHORIZATION_REFUSALS = [
 	"revoke_unconfirmed"
 ];
 //#endregion
+//#region ../../packages/wire/src/organization-setup.ts
+const FailureModeSchema = Schema.Literals(FAILURE_MODES$1);
+const ChainUpstreamSchema = Schema.Literals(CHAIN_UPSTREAMS);
+const ChainCauseSchema = Schema.Struct({
+	mode: FailureModeSchema,
+	upstream: ChainUpstreamSchema,
+	method: Schema.String,
+	retryable: Schema.Boolean,
+	httpStatus: Schema.optional(Schema.Number),
+	rpcCode: Schema.optional(Schema.Number),
+	revert: Schema.optional(Schema.Struct({
+		name: Schema.NullOr(Schema.String),
+		selector: Schema.String,
+		args: Schema.Record(Schema.String, Schema.String)
+	})),
+	providerMessage: Schema.optional(Schema.String),
+	attempts: Schema.optional(Schema.Array(Schema.Struct({
+		upstream: ChainUpstreamSchema,
+		mode: FailureModeSchema,
+		httpStatus: Schema.optional(Schema.Number),
+		rpcCode: Schema.optional(Schema.Number),
+		durationMs: Schema.Number
+	}))),
+	responseHeaders: Schema.optional(Schema.Record(Schema.String, Schema.String))
+});
+const ErrorSchema = Schema.Struct({
+	code: Schema.Literals(CAPXUL_ERROR_CODES),
+	message: Schema.String,
+	details: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
+	correlationId: Schema.optional(Schema.String),
+	layer: Schema.optional(Schema.String),
+	mode: Schema.optional(FailureModeSchema),
+	chain: Schema.optional(ChainCauseSchema)
+});
+const OrganizationSetupIssueSchema = Schema.Struct({
+	reason: Schema.Literals(ORGANIZATION_SETUP_REASONS),
+	error: Schema.optional(ErrorSchema)
+});
+const OrganizationSetupSchema = Schema.Struct({
+	orgId: Schema.String,
+	status: Schema.Literals(ORGANIZATION_SETUP_STATUSES),
+	completedAt: Schema.NullOr(Schema.Number),
+	lastCheckedAt: Schema.NullOr(Schema.Number),
+	nextCheckAt: Schema.NullOr(Schema.Number),
+	issue: Schema.NullOr(OrganizationSetupIssueSchema),
+	lastSendIssue: Schema.NullOr(OrganizationSetupIssueSchema),
+	recovery: Schema.Literals([
+		"authorize",
+		"checkAgain",
+		"none"
+	]),
+	phase: Schema.optional(Schema.Literals(["resolvingSubmission", "confirmingBootstrap"]))
+});
+//#endregion
 //#region ../../packages/wire/src/payment-document.ts
 const UINT256_MAX = 2n ** 256n - 1n;
 const INT256_MIN = -(2n ** 255n);
@@ -12357,7 +12421,7 @@ function signerFailure(source, operation, cause) {
 }
 //#endregion
 //#region ../../packages/sdk/package.json
-var version$2 = "4.20.0-beta.10";
+var version$2 = "4.20.0-beta.11";
 //#endregion
 //#region ../../packages/sdk/src/telemetry/exception-projection.ts
 /** Fixed fallback for failures that have no safe message. */
@@ -15569,7 +15633,7 @@ function mismatch(field, message) {
 		error: Errors.invalidInput(field, message)
 	};
 }
-function cancelled(operation) {
+function cancelled$1(operation) {
 	return {
 		ok: false,
 		error: Errors.cancelled({ operation })
@@ -15601,7 +15665,7 @@ async function abandonPrepared(deps, executionId, reason, result, onPreparedClos
 	return result;
 }
 async function executePersonalPayment(deps, payment, signal, requestKey, onPreparedClosed) {
-	if (isAborted$2(signal)) return cancelled(CAPXUL_OPERATIONS.payments.pay);
+	if (isAborted$2(signal)) return cancelled$1(CAPXUL_OPERATIONS.payments.pay);
 	if (deps.signer === void 0) return mismatch("signer", "payments.pay requires a configured CapxulSigner");
 	const session = deps.actor.authSession();
 	if (session === null) return {
@@ -15629,10 +15693,10 @@ async function executePersonalPayment(deps, payment, signal, requestKey, onPrepa
 		executionId: prepared.value.executionId,
 		recipient: prepared.value.recipientObservation
 	}, deps.runPromise);
-	if (isAborted$2(signal)) return abandonPrepared(deps, prepared.value.executionId, "cancelled", cancelled(CAPXUL_OPERATIONS.payments.pay), onPreparedClosed);
+	if (isAborted$2(signal)) return abandonPrepared(deps, prepared.value.executionId, "cancelled", cancelled$1(CAPXUL_OPERATIONS.payments.pay), onPreparedClosed);
 	const signature = await signerCall(deps.signer.source, "signUserOpHash", () => deps.signer.signUserOpHash(prepared.value.digest));
 	if (!signature.ok) return abandonPrepared(deps, prepared.value.executionId, "signer_rejected", signature, onPreparedClosed);
-	if (isAborted$2(signal)) return abandonPrepared(deps, prepared.value.executionId, "cancelled", cancelled(CAPXUL_OPERATIONS.payments.pay), onPreparedClosed);
+	if (isAborted$2(signal)) return abandonPrepared(deps, prepared.value.executionId, "cancelled", cancelled$1(CAPXUL_OPERATIONS.payments.pay), onPreparedClosed);
 	return runIfActive(void 0, CAPXUL_OPERATIONS.payments.submitExecution, () => deps.convexCall.action(deps.functions.submitPaymentExecution, { input: {
 		executionId: prepared.value.executionId,
 		signature: signature.value
@@ -40834,6 +40898,7 @@ const MINIMAL_LOG_NAMES = /* @__PURE__ */ new Set([
 	"convex.action.connection_lost",
 	"cli.command.completed",
 	"cli.sdk.operation.failed",
+	"cli.signer.wait",
 	"cli.wallet.step"
 ]);
 const MINIMAL_ERROR_CODES = /* @__PURE__ */ new Set([
@@ -40841,7 +40906,8 @@ const MINIMAL_ERROR_CODES = /* @__PURE__ */ new Set([
 	"CLI_USAGE",
 	"CLI_CONFIG",
 	"CLI_STORAGE",
-	"CLI_DEFECT"
+	"CLI_DEFECT",
+	"CLI_DEADLINE"
 ]);
 const MINIMAL_NUMBERS = /* @__PURE__ */ new Set([
 	"schema_version",
@@ -40921,6 +40987,13 @@ const MINIMAL_ENUM_VALUES = /* @__PURE__ */ new Map([
 	["provider", ["better-auth", "oidc"]],
 	["cli_identity_kind", ["anonymous", "identified"]],
 	["output_mode", ["human", "json"]],
+	["setup_status", ORGANIZATION_SETUP_STATUSES],
+	["setup_reason", ORGANIZATION_SETUP_REASONS],
+	["signer_stage", [
+		"address",
+		"readiness",
+		"sign"
+	]],
 	["unit", [
 		"1",
 		"s",
@@ -40941,6 +41014,7 @@ const MINIMAL_VERSION_KEYS = /* @__PURE__ */ new Set([
 ]);
 function minimalStringValue(key, text) {
 	if (key === "operation") return isCapxulOperation(text);
+	if (key === "organization_id") return /^org_[0-9A-Za-z]+$/u.test(text);
 	if (MINIMAL_CODE_KEYS.has(key)) return MINIMAL_ERROR_CODES.has(text);
 	if (MINIMAL_VERSION_KEYS.has(key)) return /^[A-Za-z0-9][A-Za-z0-9._+@-]{0,127}$/u.test(text);
 	if (key === "trace_id") return traceId(text);
@@ -45500,11 +45574,8 @@ const OBSERVED_CONVEX_ACTIONS = /* @__PURE__ */ new Set([
 	"account/actions:readBalance",
 	"holdings/actions:current",
 	"smartAccount/actions:claim",
-	"org/actions:prepareFounderAccount",
-	"org/actions:prepareBootstrap",
-	"org/actions:submitBootstrap",
-	"org/actions:resumeBootstrapSubmission",
-	"org/actions:confirmBootstrap",
+	"org/setup:prepareAuthorization",
+	"org/setup:submitAuthorization",
 	"org/actions:readTreasury",
 	"moneyExecution/actions:preparePermissionExecution",
 	"moneyExecution/actions:submitPermissionExecution",
@@ -45540,8 +45611,7 @@ const OBSERVED_CONVEX_QUERIES = /* @__PURE__ */ new Set([
 	"permission/queries:read",
 	"permission/queries:authorize",
 	"identity/queries:loadByAuthUserId",
-	"smartAccount/queries:loadByAuthUserId",
-	"org/lifecycle:load"
+	"smartAccount/queries:loadByAuthUserId"
 ]);
 const OBSERVED_CONVEX_MUTATIONS = /* @__PURE__ */ new Set([
 	"movement/activity:annotate",
@@ -45562,9 +45632,8 @@ const OBSERVED_CONVEX_MUTATIONS = /* @__PURE__ */ new Set([
 	"identity/mutations:update",
 	"identity/mutations:completeOnboarding",
 	"smartAccount/mutations:provision",
-	"org/lifecycle:startOrResume",
-	"org/lifecycle:recordFailure",
-	"org/lifecycle:retry",
+	"org/setup:begin",
+	"org/setup:resume",
 	"org/mutations:invite",
 	"org/mutations:accept"
 ]);
@@ -46107,6 +46176,43 @@ function orgErrorFromCapxul(operation, error, cause = error) {
 }
 var OrgPortTag = class extends Context.Service()("@capxul/sdk/ports/OrgPort") {};
 //#endregion
+//#region ../../packages/sdk/src/surface/org-lifecycle.ts
+function validateOrganizationSetupScope(orgId, setup) {
+	return String(setup.orgId) === String(orgId) ? {
+		ok: true,
+		value: setup
+	} : {
+		ok: false,
+		error: Errors.invalidInput("orgId", "Organization setup scope does not match")
+	};
+}
+function rehydrateSetupIssue(item) {
+	return item === null ? null : {
+		reason: item.reason,
+		...item.error === void 0 ? {} : { error: deserializeCapxulError(item.error) }
+	};
+}
+/** Validate the wire projection and restore its structured error causes. */
+function parseOrganizationSetup(value) {
+	try {
+		const wire = Schema.decodeUnknownSync(OrganizationSetupSchema)(value);
+		return {
+			ok: true,
+			value: {
+				...wire,
+				orgId: toOrgId(wire.orgId),
+				issue: rehydrateSetupIssue(wire.issue),
+				lastSendIssue: rehydrateSetupIssue(wire.lastSendIssue)
+			}
+		};
+	} catch (cause) {
+		return {
+			ok: false,
+			error: Errors.invalidInput("organizationSetup", String(cause))
+		};
+	}
+}
+//#endregion
 //#region ../../packages/sdk/src/adapters/org/parse.ts
 /** Brand the backend access projection without adding authority or profile fields. */
 function brandOrganizationAccess(wire) {
@@ -46119,37 +46225,17 @@ function brandOrganizationAccess(wire) {
 			address: toAddress(wire.account.address),
 			ready: wire.account.ready
 		},
-		setup: brandOrgLifecycle(wire.setup),
+		setup: brandOrgSetup(wire.setup),
 		member: wire.member === null ? null : brandMemberIdentity(wire.member),
 		capabilities: wire.capabilities,
 		custody: wire.custody,
 		observedAt: wire.observedAt
 	};
 }
-function brandOrgLifecycle(wire) {
-	const orgId = toOrgId(wire.orgId);
-	if (wire.status === "ready") return {
-		...wire,
-		orgId
-	};
-	if (wire.status === "settingUp") {
-		if (!isSetupStep$1(wire.step)) throw Errors.invalidInput("lifecycle.step", "Unknown setup step");
-		return {
-			...wire,
-			orgId,
-			step: wire.step
-		};
-	}
-	if (!isSetupStep$1(wire.at)) throw Errors.invalidInput("lifecycle.at", "Unknown setup step");
-	return {
-		...wire,
-		orgId,
-		at: wire.at,
-		error: new CapxulError(CAPXUL_ERROR_CODES.find((candidate) => candidate === wire.error.code) ?? "UNKNOWN", wire.error.message)
-	};
-}
-function isSetupStep$1(value) {
-	return value === "preparingFounderAccount" || value === "awaitingFounderAuthorization" || value === "submittingBootstrap" || value === "confirmingBootstrap";
+function brandOrgSetup(wire) {
+	const parsed = parseOrganizationSetup(wire);
+	if (!parsed.ok) throw parsed.error;
+	return parsed.value;
 }
 function brandMemberIdentity(wire) {
 	return {
@@ -46257,9 +46343,6 @@ var ConvexOrganizationAdapter = class {
 		this.#telemetry = input.telemetry;
 		this.#rates = input.rates ?? MONEY_READ_RATES;
 	}
-	createOrg(_input) {
-		return Effect.fail(orgErrorFromCapxul("createOrg", Errors.notImplemented("organizationSetup", "use onboarding.completeOrganization")));
-	}
 	listOrgs(input) {
 		return this.#convex.query(this.#fns.listAll, copyInvocationObservation(input, {})).pipe(Effect.mapError((error) => orgErrorFromCapxul("listOrgs", error.publicError, error)), Effect.map((wires) => wires.map(brandOrganizationAccess)), Effect.catchDefect((cause) => Effect.fail(toOrgError("listOrgs", cause))));
 	}
@@ -46301,267 +46384,234 @@ function partialOrgTruth(operation, currentState) {
 //#endregion
 //#region ../../packages/sdk/src/adapters/org/ConvexOrganizationSetupAdapter.ts
 const DEFAULT_FUNCTIONS = {
-	startOrResume: makeFunctionReference(CAPXUL_FUNCTIONS["org/lifecycle"].startOrResume),
-	prepareFounderAccount: makeFunctionReference(CAPXUL_FUNCTIONS["org/actions"].prepareFounderAccount),
-	prepareBootstrap: makeFunctionReference(CAPXUL_FUNCTIONS["org/actions"].prepareBootstrap),
-	submitBootstrap: makeFunctionReference(CAPXUL_FUNCTIONS["org/actions"].submitBootstrap),
-	resumeBootstrapSubmission: makeFunctionReference(CAPXUL_FUNCTIONS["org/actions"].resumeBootstrapSubmission),
-	confirmBootstrap: makeFunctionReference(CAPXUL_FUNCTIONS["org/actions"].confirmBootstrap),
-	recordFailure: makeFunctionReference(CAPXUL_FUNCTIONS["org/lifecycle"].recordFailure),
-	load: makeFunctionReference(CAPXUL_FUNCTIONS["org/lifecycle"].load),
-	retry: makeFunctionReference(CAPXUL_FUNCTIONS["org/lifecycle"].retry)
-};
-/** Durable Organization setup capability composed by the standard client. */
+	begin: makeFunctionReference(CAPXUL_FUNCTIONS["org/setup"].begin),
+	get: makeFunctionReference(CAPXUL_FUNCTIONS["org/setup"].get),
+	listMine: makeFunctionReference(CAPXUL_FUNCTIONS["org/setup"].listMine),
+	resume: makeFunctionReference(CAPXUL_FUNCTIONS["org/setup"].resume),
+	prepare: makeFunctionReference(CAPXUL_FUNCTIONS["org/setup"].prepareAuthorization),
+	submit: makeFunctionReference(CAPXUL_FUNCTIONS["org/setup"].submitAuthorization)
+};
+/** Convex transport for one backend-owned Organization setup. */
 var ConvexOrganizationSetupAdapter = class {
 	#convex;
 	#signer;
 	#chainId;
-	#fns;
+	#functions;
+	#runPromise;
+	#subscriptions = /* @__PURE__ */ new Set();
+	#generation = 0;
 	constructor(input) {
 		this.#convex = input.convex;
 		this.#signer = input.signer ?? null;
 		this.#chainId = input.chainId;
-		this.#fns = input.functions ?? DEFAULT_FUNCTIONS;
+		this.#functions = input.functions ?? DEFAULT_FUNCTIONS;
+		this.#runPromise = input.runPromise ?? Effect.runPromise;
 	}
-	async startOrResume(input) {
-		if (this.#signer === null) return fail$1(Errors.capabilityUnavailable("signer", "startOrResume"));
-		const result = await runCall("startOrResume", this.#convex.mutation(this.#fns.startOrResume, copyInvocationObservation(input, {
+	async begin(input) {
+		const result = await this.#call("begin", this.#convex.mutation(this.#functions.begin, copyInvocationObservation(input, {
 			...input,
 			chainId: this.#chainId
 		})));
 		if (!result.ok) return result;
-		const lifecycle = parseLifecycle("startOrResume", result.value.lifecycle);
-		if (!lifecycle.ok) return lifecycle;
-		const orgId = parseOrgId("startOrResume", result.value.orgId);
-		if (!orgId.ok) return orgId;
-		if (String(orgId.value) !== String(lifecycle.value.orgId)) return fail$1(Errors.invalidInput("orgId", "Organization lifecycle scope does not match"));
+		const setup = parseOrganizationSetup(result.value.setup);
+		if (!setup.ok) return setup;
+		try {
+			const orgId = toOrgId(result.value.orgId);
+			const scoped = validateOrganizationSetupScope(orgId, setup.value);
+			return scoped.ok ? {
+				ok: true,
+				value: {
+					orgId,
+					setup: scoped.value
+				}
+			} : scoped;
+		} catch (cause) {
+			return fail(Errors.invalidInput("orgId", String(cause)));
+		}
+	}
+	async get(orgId, options) {
+		if (options?.signal?.aborted) return cancelled();
+		const result = await this.#call("get", this.#convex.query(this.#functions.get, { orgId }));
+		if (!result.ok) return result;
+		if (result.value === null) return fail(Errors.invalidInput("orgId", "Organization setup was not found"));
+		const parsed = parseOrganizationSetup(result.value);
+		return parsed.ok ? validateOrganizationSetupScope(orgId, parsed.value) : parsed;
+	}
+	async listMine(input = {}, options) {
+		if (options?.signal?.aborted) return cancelled();
+		if (input.cursor !== void 0 && typeof input.cursor !== "string" || input.limit !== void 0 && (!Number.isSafeInteger(input.limit) || input.limit < 1 || input.limit > 50)) return fail(Errors.invalidInput("organizationSetupPage", "Invalid cursor or limit"));
+		const generation = this.#generation;
+		const result = await abortable(this.#call("listMine", this.#convex.query(this.#functions.listMine, input)), options?.signal);
+		if (generation !== this.#generation || options?.signal?.aborted) return cancelled();
+		if (!result.ok) return result;
+		const value = result.value;
+		if (typeof value !== "object" || value === null || !Array.isArray(value.page) || !(value.cursor === null || typeof value.cursor === "string") || typeof value.isDone !== "boolean") return fail(Errors.invalidInput("organizationSetupPage", "Invalid page envelope"));
+		const page = [];
+		for (const item of value.page) {
+			const parsed = parseOrganizationSetup(item);
+			if (!parsed.ok) return parsed;
+			page.push(parsed.value);
+		}
 		return {
 			ok: true,
 			value: {
-				orgId: orgId.value,
-				lifecycle: lifecycle.value
+				page,
+				cursor: value.cursor,
+				isDone: value.isDone
 			}
 		};
 	}
-	prepareFounderAccount(input) {
-		return this.#lifecycleAction("prepareFounderAccount", input, () => this.#convex.action(this.#fns.prepareFounderAccount, copyInvocationObservation(input, {
-			orgId: input.orgId,
-			...input.observationContext === void 0 ? {} : { observationContext: input.observationContext }
-		})));
-	}
-	async authorizeAndSubmitBootstrap(input) {
-		const cancelled = cancellation(input.signal);
-		if (cancelled !== void 0) return cancelled;
+	async resume(orgId, options) {
+		if (options?.signal?.aborted) return cancelled();
+		const result = await this.#call("resume", this.#convex.mutation(this.#functions.resume, { orgId }));
+		if (!result.ok) return result;
+		const parsed = parseOrganizationSetup(result.value);
+		return parsed.ok ? validateOrganizationSetupScope(orgId, parsed.value) : parsed;
+	}
+	async authorize(orgId, options) {
+		if (options?.signal?.aborted) return cancelled();
+		const current = await this.get(orgId, options);
+		if (options?.signal?.aborted) return cancelled();
+		if (!current.ok || current.value.status !== "awaitingAuthorization") return current;
 		const signer = this.#signer;
-		if (signer === null) return fail$1(Errors.capabilityUnavailable("signer", "authorizeAndSubmitBootstrap"));
-		const signerAddress = await signerResult(signer.source, "getAddress", () => signer.getAddress());
-		if (!signerAddress.ok) return signerAddress;
-		const prepared = await runCall("prepareBootstrap", this.#convex.action(this.#fns.prepareBootstrap, copyInvocationObservation(input, {
-			orgId: input.orgId,
-			signerAddress: signerAddress.value,
-			...input.observationContext === void 0 ? {} : { observationContext: input.observationContext }
-		})));
+		if (signer === null) return fail(Errors.capabilityUnavailable("signer", "authorize"));
+		const address = await signerResult(signer, "getAddress", () => signer.getAddress());
+		if (!address.ok) return address;
+		const prepared = await this.#call("prepareAuthorization", this.#convex.action(this.#functions.prepare, { orgId }));
 		if (!prepared.ok) return prepared;
-		const authority = validatePreparedAuthorities(prepared.value, signerAddress.value);
+		const authority = validatePrepared(prepared.value, orgId, address.value);
 		if (!authority.ok) return authority;
-		const cancelledAfterPrepare = cancellation(input.signal);
-		if (cancelledAfterPrepare !== void 0) return cancelledAfterPrepare;
-		const signature = await signerResult(signer.source, "signUserOpHash", () => signer.signUserOpHash(prepared.value.digest));
+		if (options?.signal?.aborted) return cancelled();
+		const signature = await signerResult(signer, "signUserOpHash", () => signer.signUserOpHash(prepared.value.digest));
 		if (!signature.ok) return signature;
-		const cancelledAfterSign = cancellation(input.signal);
-		if (cancelledAfterSign !== void 0) return cancelledAfterSign;
-		const submitted = await runCall("submitBootstrap", this.#convex.action(this.#fns.submitBootstrap, copyInvocationObservation(input, {
-			orgId: input.orgId,
-			signerAddress: signerAddress.value,
-			signature: signature.value,
+		if (options?.signal?.aborted) return cancelled();
+		const submitted = await this.#call("submitAuthorization", this.#convex.action(this.#functions.submit, {
+			orgId,
+			preparationId: prepared.value.preparationId,
 			userOp: prepared.value.userOp,
-			...input.observationContext === void 0 ? {} : { observationContext: input.observationContext }
-		})));
-		if (!submitted.ok) return submitted;
-		return parseLifecycle("submitBootstrap", submitted.value);
-	}
-	resumeSubmittedBootstrap(input) {
-		return this.#lifecycleAction("resumeBootstrapSubmission", input, () => this.#convex.action(this.#fns.resumeBootstrapSubmission, copyInvocationObservation(input, {
-			orgId: input.orgId,
-			...input.observationContext === void 0 ? {} : { observationContext: input.observationContext }
-		})));
-	}
-	confirmSubmittedBootstrap(input) {
-		return this.#lifecycleAction("confirmBootstrap", input, () => this.#convex.action(this.#fns.confirmBootstrap, copyInvocationObservation(input, {
-			orgId: input.orgId,
-			...input.observationContext === void 0 ? {} : { observationContext: input.observationContext },
-			...input.retryDelayMs === void 0 ? {} : { retryDelayMs: input.retryDelayMs }
-		})));
-	}
-	async recordFailure(input) {
-		const errorProvider = input.error.details?.provider;
-		const errorOperation = input.error.details?.operation;
-		const result = await runCall("recordFailure", this.#convex.mutation(this.#fns.recordFailure, copyInvocationObservation(input, {
-			orgId: input.orgId,
-			errorCode: input.error.code,
-			...typeof errorProvider === "string" && typeof errorOperation === "string" ? {
-				errorProvider,
-				errorOperation
-			} : {},
-			retryable: input.retryable,
-			...input.observationContext === void 0 ? {} : { observationContext: input.observationContext }
-		})));
-		return result.ok ? parseLifecycle("recordFailure", result.value) : result;
-	}
-	async loadLifecycle(input) {
-		const result = await runCall("loadLifecycle", this.#convex.query(this.#fns.load, input));
-		if (!result.ok) return result;
-		if (result.value === null) return fail$1(Errors.invalidInput("orgId", "Organization lifecycle was not found"));
-		return parseLifecycle("loadLifecycle", result.value);
-	}
-	async retry(input) {
-		const cancelled = cancellation(input.signal);
-		if (cancelled !== void 0) return cancelled;
-		const current = await this.loadLifecycle({
-			orgId: input.orgId,
-			...input.observationContext === void 0 ? {} : { observationContext: input.observationContext }
-		});
-		if (!current.ok) return current;
-		if (current.value.status === "failed" && current.value.retryable && current.value.at === "awaitingFounderAuthorization") {
-			if (this.#signer === null) return fail$1(Errors.capabilityUnavailable("signer", "retry"));
-			const reset = resetSignerSession(this.#signer);
-			if (!reset.ok) return reset;
+			signature: signature.value
+		}));
+		if (!submitted.ok) {
+			const acceptedSetup = await this.get(orgId);
+			return acceptedSetup.ok && acceptedSetup.value.status !== "awaitingAuthorization" ? acceptedSetup : submitted;
+		}
+		const parsed = parseOrganizationSetup(submitted.value);
+		return parsed.ok ? validateOrganizationSetupScope(orgId, parsed.value) : parsed;
+	}
+	async subscribe(orgId, listener, options) {
+		if (options?.signal?.aborted) return cancelled();
+		let active = true;
+		let remoteStop;
+		const stop = () => {
+			if (!active) return;
+			active = false;
+			options?.signal?.removeEventListener("abort", stop);
+			this.#subscriptions.delete(stop);
+			remoteStop?.();
+		};
+		const notify = (snapshot) => {
+			try {
+				Promise.resolve(listener(snapshot)).catch(() => void 0);
+			} catch {}
+		};
+		options?.signal?.addEventListener("abort", stop, { once: true });
+		this.#subscriptions.add(stop);
+		const result = await this.#call("subscribe", this.#convex.subscribe(this.#functions.get, { orgId }, (snapshot) => {
+			if (!active) return;
+			if (snapshot.status === "loading") return notify({ status: "loading" });
+			if (snapshot.status === "error") return notify({
+				status: "error",
+				error: snapshot.error
+			});
+			const parsed = snapshot.value === null ? fail(Errors.invalidInput("orgId", "Organization setup was not found")) : parseOrganizationSetup(snapshot.value);
+			const scoped = parsed.ok ? validateOrganizationSetupScope(orgId, parsed.value) : parsed;
+			notify(scoped.ok ? {
+				status: "value",
+				value: scoped.value
+			} : {
+				status: "error",
+				error: scoped.error
+			});
+		}));
+		if (!result.ok) {
+			stop();
+			return result;
+		}
+		remoteStop = result.value;
+		if (!active) {
+			remoteStop();
+			return cancelled();
 		}
-		const result = await runCall("retry", this.#convex.mutation(this.#fns.retry, copyInvocationObservation(input, {
-			orgId: input.orgId,
-			...input.observationContext === void 0 ? {} : { observationContext: input.observationContext }
-		})));
-		if (!result.ok) return result;
-		return parseLifecycle("retry", result.value);
-	}
-	async #lifecycleAction(operation, input, call) {
-		const cancelled = cancellation(input.signal);
-		if (cancelled !== void 0) return cancelled;
-		const result = await runCall(operation, call());
-		if (!result.ok) return result;
-		const cancelledAfter = cancellation(input.signal);
-		if (cancelledAfter !== void 0) return cancelledAfter;
-		return parseLifecycle(operation, result.value);
-	}
-};
-function resetSignerSession(signer) {
-	const resetSession = signer.resetSession;
-	if (typeof resetSession !== "function") return {
-		ok: true,
-		value: void 0
-	};
-	try {
-		resetSession.call(signer);
 		return {
 			ok: true,
-			value: void 0
+			value: stop
 		};
-	} catch (cause) {
-		return fail$1(signerFailure(signer.source, "resetSession", cause));
 	}
-}
-async function runCall(operation, effect) {
-	try {
-		const result = await Effect.runPromise(Effect.result(effect));
-		return Result.isSuccess(result) ? {
-			ok: true,
-			value: result.success
-		} : fail$1(publicError(operation, result.failure));
-	} catch (cause) {
-		return fail$1(publicError(operation, cause));
-	}
-}
-function publicError(operation, cause) {
-	if (cause instanceof CapxulError) return cause;
-	if (typeof cause === "object" && cause !== null) {
-		const carried = cause.publicError;
-		if (carried instanceof CapxulError) return carried;
+	invalidateSubscriptions() {
+		this.#generation += 1;
+		for (const stop of this.#subscriptions) stop();
 	}
-	return Errors.providerError("convex-organization", operation, cause);
-}
-async function signerResult(source, operation, run) {
-	try {
-		return {
-			ok: true,
-			value: await run()
-		};
-	} catch (cause) {
-		return fail$1(signerFailure(source, operation, cause));
+	async #call(operation, effect) {
+		try {
+			const result = await this.#runPromise(Effect.result(effect));
+			return Result.isSuccess(result) ? {
+				ok: true,
+				value: result.success
+			} : fail(publicError(result.failure));
+		} catch (cause) {
+			return fail(publicError(cause));
+		}
 	}
-}
-function validatePreparedAuthorities(prepared, signerAddress) {
+};
+function validatePrepared(prepared, orgId, signerAddress) {
 	const signer = signerAddress.toLowerCase();
-	const preparedSigner = prepared.signerAddress.toLowerCase();
+	if (prepared.orgId !== orgId || prepared.expectedSigner.toLowerCase() !== signer) return fail(Errors.invalidInput("authorization", "Prepared signer or Organization does not match"));
 	const founder = prepared.founderPersonalAccount.toLowerCase();
 	const organization = prepared.organizationAccountAddress.toLowerCase();
-	const sender = prepared.userOp.sender.toLowerCase();
-	if (preparedSigner !== signer) return fail$1(Errors.invalidInput("signerAddress", "Prepared signer does not match configured signer"));
-	if (founder === signer || organization === signer || organization === founder) return fail$1(Errors.invalidInput("organizationAuthority", "Signer EOA, founder Account, and Organization Account must be distinct"));
-	if (sender !== founder) return fail$1(Errors.invalidInput("userOp.sender", "Bootstrap sender must be the founder Account"));
-	if (!/^0x[0-9a-fA-F]{64}$/u.test(prepared.digest)) return fail$1(Errors.invalidInput("digest", "Prepared bootstrap digest must be 32-byte hex"));
+	if (founder === signer || organization === signer || organization === founder || prepared.userOp.sender.toLowerCase() !== founder) return fail(Errors.invalidInput("organizationAuthority", "Prepared authorities do not match"));
+	if (!/^0x[0-9a-fA-F]{64}$/u.test(prepared.digest)) return fail(Errors.invalidInput("digest", "Prepared digest must be 32-byte hex"));
 	return {
 		ok: true,
 		value: void 0
 	};
 }
-function parseLifecycle(operation, wire) {
-	const orgId = parseOrgId(operation, wire.orgId);
-	if (!orgId.ok) return orgId;
-	if (wire.status === "loading") return {
-		ok: true,
-		value: {
-			status: "loading",
-			orgId: orgId.value
-		}
-	};
-	if (wire.status === "ready") return {
-		ok: true,
-		value: {
-			status: "ready",
-			orgId: orgId.value,
-			canTransact: true
-		}
-	};
-	if (wire.status === "failed") {
-		if (!isSetupStep(wire.at)) return fail$1(Errors.invalidInput("lifecycle.at", "Unknown setup step"));
-		return {
-			ok: true,
-			value: {
-				status: "failed",
-				orgId: orgId.value,
-				at: wire.at,
-				error: new CapxulError(wire.error.code, wire.error.message),
-				retryable: wire.retryable
-			}
-		};
-	}
-	if (!isSetupStep(wire.step)) return fail$1(Errors.invalidInput("lifecycle.step", `Unknown setup step from ${operation}`));
-	return {
-		ok: true,
-		value: {
-			status: "settingUp",
-			orgId: orgId.value,
-			step: wire.step
-		}
-	};
-}
-function parseOrgId(operation, value) {
+async function signerResult(signer, operation, run) {
 	try {
 		return {
 			ok: true,
-			value: toOrgId(value)
+			value: await run()
 		};
 	} catch (cause) {
-		return fail$1(Errors.providerError("convex-organization", operation, cause));
+		return fail(signerFailure(signer.source, operation, cause));
+	}
+}
+function publicError(cause) {
+	if (cause instanceof CapxulError) return cause;
+	if (typeof cause === "object" && cause !== null && "publicError" in cause) {
+		const carried = cause.publicError;
+		if (carried instanceof CapxulError) return carried;
 	}
+	return Errors.unknown(cause);
 }
-function isSetupStep(value) {
-	return value === "preparingFounderAccount" || value === "awaitingFounderAuthorization" || value === "submittingBootstrap" || value === "confirmingBootstrap";
+function cancelled() {
+	return fail(Errors.cancelled({ operation: CAPXUL_OPERATIONS.organization.setup }));
 }
-function cancellation(signal) {
-	return signal?.aborted ? fail$1(Errors.cancelled({ operation: CAPXUL_OPERATIONS.organization.setup })) : void 0;
+async function abortable(pending, signal) {
+	if (signal === void 0) return pending;
+	if (signal.aborted) return cancelled();
+	let onAbort;
+	const interrupted = new Promise((resolve) => {
+		onAbort = () => resolve(cancelled());
+		signal.addEventListener("abort", onAbort, { once: true });
+		if (signal.aborted) onAbort();
+	});
+	try {
+		return await Promise.race([pending, interrupted]);
+	} finally {
+		signal.removeEventListener("abort", onAbort);
+	}
 }
-function fail$1(error) {
+function fail(error) {
 	return {
 		ok: false,
 		error
@@ -46726,22 +46776,27 @@ const IDENTITY_SLOT_BY_EVENT = {
 	AccountFailed: IDENTITY_SLOT.account,
 	CreateOrganization: IDENTITY_SLOT.org,
 	AttachOrganization: IDENTITY_SLOT.org,
-	RetryOrganization: IDENTITY_SLOT.org,
 	LeaveOrganization: IDENTITY_SLOT.org,
-	OrgAt: IDENTITY_SLOT.org,
-	OrgReady: IDENTITY_SLOT.org,
-	OrgFailed: IDENTITY_SLOT.org
+	ObserveOrganization: IDENTITY_SLOT.org,
+	OrgSelected: IDENTITY_SLOT.org,
+	OrgSelectionFailed: IDENTITY_SLOT.org
 };
 const identitySlot = (event) => IDENTITY_SLOT_BY_EVENT[event._tag];
 const initialIdentityState = () => RESTORING;
-function createIdentityAuthorityTracker(sessionStore) {
+function createIdentityAuthorityTracker(sessionStore, onGenerationChange = () => void 0) {
 	let generation = 0;
 	let authUserId = null;
 	let stopped = false;
 	let readState = initialIdentityState;
+	const advanceGeneration = () => {
+		generation += 1;
+		try {
+			onGenerationChange();
+		} catch {}
+	};
 	const revoke = () => {
 		if (stopped) return;
-		generation += 1;
+		advanceGeneration();
 		authUserId = null;
 	};
 	return {
@@ -46759,13 +46814,13 @@ function createIdentityAuthorityTracker(sessionStore) {
 		observe: (state) => {
 			if (stopped) return;
 			const next = state.phase === "authenticated" ? state.session.authUserId : null;
-			if (authUserId !== null && next !== authUserId) generation += 1;
+			if (authUserId !== null && next !== authUserId) advanceGeneration();
 			authUserId = next;
 		},
 		invalidate: () => {
 			if (stopped) return;
 			stopped = true;
-			generation += 1;
+			advanceGeneration();
 			authUserId = null;
 		},
 		matches: (captured, expectedAuthUserId) => {
@@ -46776,29 +46831,6 @@ function createIdentityAuthorityTracker(sessionStore) {
 		}
 	};
 }
-/** 2 s, 4 s, 8 s, 16 s, 32 s, 60 s, 60 s: about three minutes, then the user decides. */
-const DEFAULT_CONFIRMATION_BACKOFF = {
-	initialDelayMs: 2e3,
-	maxDelayMs: 6e4,
-	maxRetries: 7
-};
-/**
-* A public partial override must not bring the tight loop back: a zero,
-* negative, or non-finite delay, or a non-integer or infinite retry count,
-* falls back to the default for that field. `maxDelayMs` is never below
-* `initialDelayMs`.
-*/
-const positiveMs = (value, fallback) => value !== void 0 && Number.isFinite(value) && value > 0 ? value : fallback;
-function normalizeConfirmationBackoff(override) {
-	const initialDelayMs = positiveMs(override?.initialDelayMs, DEFAULT_CONFIRMATION_BACKOFF.initialDelayMs);
-	const maxDelayMs = Math.max(initialDelayMs, positiveMs(override?.maxDelayMs, DEFAULT_CONFIRMATION_BACKOFF.maxDelayMs));
-	const retries = override?.maxRetries;
-	return {
-		initialDelayMs,
-		maxDelayMs,
-		maxRetries: retries !== void 0 && Number.isSafeInteger(retries) && retries >= 0 ? retries : DEFAULT_CONFIRMATION_BACKOFF.maxRetries
-	};
-}
 const failureOf = (error) => {
 	if (error instanceof CapxulError) {
 		const mode = error.mode ?? error.details?.failure_mode;
@@ -46922,12 +46954,6 @@ const accountLane = (input, config, session, send, isCurrent) => Effect.gen(func
 		address: String(claimed.success.smartAccountAddress)
 	});
 });
-const orgStep = (lifecycle) => {
-	if (lifecycle.status === "ready") return "ready";
-	if (lifecycle.status === "settingUp") return lifecycle.step;
-	if (lifecycle.status === "failed") return lifecycle.at;
-	return "preparingFounderAccount";
-};
 const orgEngineeringContext = (controls, parent) => {
 	const correlationId = safeEngineeringIdentifier(controls.correlation_id);
 	const journeyId = safeEngineeringIdentifier(controls.journey_id);
@@ -46938,165 +46964,22 @@ const orgEngineeringContext = (controls, parent) => {
 		...traceparent === void 0 ? {} : { traceparent }
 	};
 };
-const runOrgStep = (setup, orgId, step, controls, retryDelayMs) => {
-	const [name, invoke] = step === "preparingFounderAccount" ? ["organization-setup.prepare-founder-account", (parent) => setup.prepareFounderAccount({
-		orgId,
-		observationContext: orgEngineeringContext(controls, parent)
-	})] : step === "awaitingFounderAuthorization" ? ["organization-setup.authorize-and-submit-bootstrap", (parent) => setup.authorizeAndSubmitBootstrap({
-		orgId,
+const beginOrganization$1 = (setup, draft, send, controls) => Effect.gen(function* () {
+	const opened = yield* Effect.result(resultEffect("organization-setup.begin", (parent) => setup.begin({
+		...draft,
 		observationContext: orgEngineeringContext(controls, parent)
-	})] : step === "submittingBootstrap" ? ["organization-setup.resume-submitted-bootstrap", (parent) => setup.resumeSubmittedBootstrap({
-		orgId,
-		observationContext: orgEngineeringContext(controls, parent)
-	})] : ["organization-setup.confirm-submitted-bootstrap", (parent) => setup.confirmSubmittedBootstrap({
-		orgId,
-		observationContext: orgEngineeringContext(controls, parent),
-		...retryDelayMs === void 0 ? {} : { retryDelayMs }
-	})];
-	return resultEffect(name, invoke);
-};
-const orgLane = (setup, start, send, controls, backoff, telemetry) => Effect.gen(function* () {
-	let orgId;
-	let lifecycle;
-	if (start.kind === "create") {
-		const opened = yield* Effect.result(resultEffect("organization-setup.start-or-resume", (parent) => setup.startOrResume({
-			...start.draft,
-			observationContext: orgEngineeringContext(controls, parent)
-		})));
-		if (Result.isFailure(opened)) {
-			yield* send({
-				_tag: "OrgFailed",
-				orgId: null,
-				step: "preparingFounderAccount",
-				failure: opened.failure
-			});
-			return yield* Effect.fail(opened.failure);
-		}
-		orgId = String(opened.success.orgId);
-		lifecycle = opened.success.lifecycle;
-	} else {
-		const opened = yield* Effect.result(start.kind === "retry" ? resultEffect("organization-setup.retry", (parent) => setup.retry({
-			orgId: start.orgId,
-			observationContext: orgEngineeringContext(controls, parent)
-		})) : resultEffect("organization-setup.load-lifecycle", (parent) => setup.loadLifecycle({
-			orgId: start.orgId,
-			observationContext: orgEngineeringContext(controls, parent)
-		})));
-		if (Result.isFailure(opened)) {
-			yield* send({
-				_tag: "OrgFailed",
-				orgId: start.orgId,
-				step: "preparingFounderAccount",
-				failure: opened.failure
-			});
-			return yield* Effect.fail(opened.failure);
-		}
-		orgId = start.orgId;
-		lifecycle = opened.success;
-	}
-	if (lifecycle.status === "failed") {
-		const failure = failureOf(lifecycle.error);
-		yield* send({
-			_tag: "OrgFailed",
-			orgId,
-			step: lifecycle.at,
-			failure,
-			retryable: lifecycle.retryable
-		});
-		return yield* Effect.fail(failure);
-	}
-	let step = orgStep(lifecycle);
-	if (step === "ready") {
+	})));
+	if (Result.isFailure(opened)) {
 		yield* send({
-			_tag: "OrgReady",
-			orgId
+			_tag: "OrgSelectionFailed",
+			failure: opened.failure
 		});
-		return;
+		return yield* Effect.fail(opened.failure);
 	}
 	yield* send({
-		_tag: "OrgAt",
-		orgId,
-		step
+		_tag: "OrgSelected",
+		setup: opened.success.setup
 	});
-	let retries = 0;
-	let retryDelayMs;
-	while (step !== "ready") {
-		const current = step;
-		const advanced = yield* Effect.result(runOrgStep(setup, orgId, current, controls, retryDelayMs));
-		retryDelayMs = void 0;
-		if (Result.isFailure(advanced)) {
-			yield* send({
-				_tag: "OrgFailed",
-				orgId,
-				step: current,
-				failure: advanced.failure
-			});
-			return yield* Effect.fail(advanced.failure);
-		}
-		lifecycle = advanced.success;
-		if (lifecycle.status === "failed") {
-			if (lifecycle.at === "confirmingBootstrap" && lifecycle.retryable && retries < backoff.maxRetries) {
-				const delayMs = Math.min(backoff.initialDelayMs * 2 ** retries, backoff.maxDelayMs);
-				retries += 1;
-				if (telemetry !== void 0) yield* telemetry.emit({
-					name: "operation_retried",
-					props: {
-						operation: CAPXUL_OPERATIONS.org.confirmBootstrap,
-						failure_mode: failureOf(lifecycle.error).mode ?? "unknown",
-						attempt: retries,
-						delay_ms: delayMs
-					}
-				}).pipe(Effect.catchDefect(() => Effect.void));
-				yield* Effect.sleep(Duration.millis(delayMs));
-				const reset = yield* Effect.result(resultEffect("organization-setup.retry", (parent) => setup.retry({
-					orgId,
-					observationContext: orgEngineeringContext(controls, parent)
-				})));
-				if (Result.isFailure(reset)) {
-					yield* send({
-						_tag: "OrgFailed",
-						orgId,
-						step: current,
-						failure: reset.failure
-					});
-					return yield* Effect.fail(reset.failure);
-				}
-				lifecycle = reset.success;
-				if (lifecycle.status !== "failed") {
-					retryDelayMs = delayMs;
-					step = orgStep(lifecycle);
-					yield* step === "ready" ? send({
-						_tag: "OrgReady",
-						orgId
-					}) : send({
-						_tag: "OrgAt",
-						orgId,
-						step
-					});
-					continue;
-				}
-			}
-			const failure = failureOf(lifecycle.error);
-			yield* send({
-				_tag: "OrgFailed",
-				orgId,
-				step: lifecycle.at,
-				failure,
-				retryable: lifecycle.retryable
-			});
-			return yield* Effect.fail(failure);
-		}
-		step = orgStep(lifecycle);
-		yield* step === "ready" ? send({
-			_tag: "OrgReady",
-			orgId
-		}) : send({
-			_tag: "OrgAt",
-			orgId,
-			step
-		});
-		if (step === current) yield* Effect.sleep("1 second");
-	}
 });
 const recoverIdentityFailure = (state, event, failure) => {
 	if (event === "ReadSession") return {
@@ -47127,23 +47010,8 @@ const recoverIdentityFailure = (state, event, failure) => {
 		failure
 	};
 	if (state.account.at !== "claimed" || state.account.org === null) return void 0;
-	const org = state.account.org;
-	if (org.at === "creating") return {
-		_tag: "OrgFailed",
-		orgId: null,
-		step: "preparingFounderAccount",
-		failure
-	};
-	if (org.at === "loading") return {
-		_tag: "OrgFailed",
-		orgId: org.orgId,
-		step: "preparingFounderAccount",
-		failure
-	};
-	return org.at === "settingUp" ? {
-		_tag: "OrgFailed",
-		orgId: org.orgId,
-		step: org.step,
+	return state.account.org.orgId === null ? {
+		_tag: "OrgSelectionFailed",
 		failure
 	} : void 0;
 };
@@ -47154,7 +47022,6 @@ const identitySpec = (input, sessionStore, authority) => {
 		hasSigner: input.signer !== void 0,
 		...input.otpTtlMs === void 0 ? {} : { otpTtlMs: input.otpTtlMs }
 	};
-	const backoff = normalizeConfirmationBackoff(input.confirmationBackoff);
 	return {
 		machine: "identity",
 		initial: RESTORING,
@@ -47171,7 +47038,7 @@ const identitySpec = (input, sessionStore, authority) => {
 			IDENTITY_SLOT.session,
 			IDENTITY_SLOT.account,
 			IDENTITY_SLOT.org
-		] : [],
+		] : event._tag === "LeaveOrganization" || event._tag === "AttachOrganization" ? [IDENTITY_SLOT.org] : [],
 		work: ({ state, event }) => {
 			const activeSession = state.phase === "authenticated" ? state.session : null;
 			const org = state.phase === "authenticated" && state.account.at === "claimed" ? state.account.org : null;
@@ -47265,29 +47132,10 @@ const identitySpec = (input, sessionStore, authority) => {
 						}
 					};
 				}
-				case "CreateOrganization": return input.organizationSetup === void 0 || org?.at !== "creating" ? void 0 : {
-					slot: IDENTITY_SLOT.org,
-					port: "organization-setup",
-					run: (send, controls) => orgLane(input.organizationSetup, {
-						kind: "create",
-						draft: event.draft
-					}, send, controls, backoff, input.telemetry)
-				};
-				case "AttachOrganization": return input.organizationSetup === void 0 || org?.at !== "loading" ? void 0 : {
-					slot: IDENTITY_SLOT.org,
-					port: "organization-setup",
-					run: (send, controls) => orgLane(input.organizationSetup, {
-						kind: "attach",
-						orgId: org.orgId
-					}, send, controls, backoff, input.telemetry)
-				};
-				case "RetryOrganization": return input.organizationSetup === void 0 || org?.at !== "settingUp" ? void 0 : {
+				case "CreateOrganization": return input.organizationSetup === void 0 || org === null || org.orgId !== null ? void 0 : {
 					slot: IDENTITY_SLOT.org,
 					port: "organization-setup",
-					run: (send, controls) => orgLane(input.organizationSetup, {
-						kind: "retry",
-						orgId: org.orgId
-					}, send, controls, backoff, input.telemetry)
+					run: (send, controls) => beginOrganization$1(input.organizationSetup, event.draft, send, controls)
 				};
 				default: return;
 			}
@@ -47296,10 +47144,69 @@ const identitySpec = (input, sessionStore, authority) => {
 };
 const bootIdentityFlow = (input, options = {}) => Effect.gen(function* () {
 	const sessionStore = { current: null };
-	const authority = createIdentityAuthorityTracker(sessionStore);
+	let invalidateOrganizationSubscriptions = () => input.organizationSetup?.invalidateSubscriptions?.();
+	const authority = createIdentityAuthorityTracker(sessionStore, () => invalidateOrganizationSubscriptions());
 	const actor = yield* boot(identitySpec(input, sessionStore, authority), options);
 	authority.bindState(actor.snapshot);
-	const unsubscribeAuthority = actor.subscribe(authority.observe);
+	const runPromise = input.runPromise ?? Effect.runPromise;
+	let selectedOrgId = null;
+	let stopRemote = null;
+	let selectionEpoch = 0;
+	invalidateOrganizationSubscriptions = () => {
+		selectionEpoch += 1;
+		const stop = stopRemote;
+		stopRemote = null;
+		try {
+			stop?.();
+		} finally {
+			input.organizationSetup?.invalidateSubscriptions?.();
+		}
+	};
+	const observe = (state) => {
+		authority.observe(state);
+		const nextOrgId = state.phase === "authenticated" && state.account.at === "claimed" ? state.account.org?.orgId ?? null : null;
+		if (nextOrgId === selectedOrgId) return;
+		selectedOrgId = nextOrgId;
+		selectionEpoch += 1;
+		const epoch = selectionEpoch;
+		stopRemote?.();
+		stopRemote = null;
+		if (nextOrgId === null || input.organizationSetup === void 0) return;
+		const capturedLifetime = authority.snapshot();
+		const expectedAuthUserId = state.phase === "authenticated" ? state.session.authUserId : null;
+		const emit = (snapshot) => {
+			if (epoch !== selectionEpoch || !authority.matches(capturedLifetime, expectedAuthUserId)) return;
+			runPromise(actor.tell({
+				_tag: "ObserveOrganization",
+				orgId: nextOrgId,
+				snapshot
+			})).catch(() => void 0);
+		};
+		try {
+			const orgId = toOrgId(nextOrgId);
+			input.organizationSetup.subscribe(orgId, emit).then((result) => {
+				if (epoch !== selectionEpoch) {
+					if (result.ok) result.value();
+					return;
+				}
+				if (result.ok) stopRemote = result.value;
+				else emit({
+					status: "error",
+					error: result.error
+				});
+			}).catch((cause) => emit({
+				status: "error",
+				error: Errors.unknown(cause)
+			}));
+		} catch (cause) {
+			emit({
+				status: "error",
+				error: Errors.unknown(cause)
+			});
+		}
+	};
+	const unsubscribeAuthority = actor.subscribe(observe);
+	observe(actor.snapshot());
 	yield* Effect.addFinalizer(() => Effect.sync(() => {
 		authority.invalidate();
 		unsubscribeAuthority();
@@ -47324,7 +47231,7 @@ const bootIdentityFlow = (input, options = {}) => Effect.gen(function* () {
 });
 //#endregion
 //#region ../../packages/sdk/src/contract/org-lifecycle.ts
-const organizationSetupProofReceiptQuery = makeFunctionReference(CAPXUL_FUNCTIONS["org/lifecycle"].getProofReceipt);
+const organizationSetupProofReceiptQuery = makeFunctionReference(CAPXUL_FUNCTIONS["org/setup"].getProofReceipt);
 //#endregion
 //#region ../../packages/sdk/src/surface/capxul-deps.ts
 /** The single Context tag the atoms + public methods both resolve. */
@@ -48007,6 +47914,10 @@ function normalizeOrganization(input) {
 		ok: false,
 		error: Errors.invalidInput("size", "must be text")
 	};
+	if (input.logoStorageId !== void 0 && typeof input.logoStorageId !== "string") return {
+		ok: false,
+		error: Errors.invalidInput("logoStorageId", "must be a storage ID")
+	};
 	let country;
 	try {
 		country = toCountryCode(input.country);
@@ -48025,7 +47936,8 @@ function normalizeOrganization(input) {
 			handle: handle.value,
 			country,
 			...bio.length === 0 ? {} : { bio },
-			...size.length === 0 ? {} : { size }
+			...size.length === 0 ? {} : { size },
+			...input.logoStorageId === void 0 ? {} : { logoStorageId: input.logoStorageId }
 		}
 	};
 }
@@ -48117,93 +48029,137 @@ async function reachClaimedAccount(deps, options) {
 		value: state
 	} : organizationWrongState(state.phase === "authenticated" ? state.account.at : state.phase, ["claimed"]);
 }
-async function createOrResumeOrganization(deps, state, draft, options) {
-	const selected = await selectOrganizationLane(deps, state, options);
-	if (!selected.ok) return selected;
-	state = selected.value;
-	const active = state.account.org;
-	if (active?.at === "ready") return {
-		ok: true,
-		value: { organizationId: active.orgId }
-	};
-	if (active?.at === "failed" && !active.retryable) return {
+async function beginOrganization(deps, input, options) {
+	const normalized = normalizeOrganization(input);
+	if (!normalized.ok) return normalized;
+	const setup = deps.organizationSetup;
+	if (setup === void 0) return {
 		ok: false,
-		error: publicIdentityFailure(active.failure)
+		error: Errors.notImplemented("organizationSetup", "begin")
 	};
-	if (active?.at === "failed" && active.orgId === null) {
-		const cleared = await deps.sendIdentity({ _tag: "LeaveOrganization" }, options);
-		if (!cleared.ok) return cleared;
+	const captured = deps.authLifetime();
+	try {
+		const session = await deps.restoreSession(options);
+		if (!session.ok) return session;
+		if (session.value === null) return {
+			ok: false,
+			error: Errors.notAuthenticated()
+		};
+		const authUserId = String(session.value.authUserId);
+		const current = () => deps.matchesAuthLifetime(captured, authUserId) && !requestCancelled(options);
+		if (!current()) return cancelledOrganization();
+		const profile = await deps.loadProfile(options);
+		if (!current()) return cancelledOrganization();
+		if (!profile.ok) return profile;
+		if (profile.value?.displayName === null || profile.value?.handle === null || profile.value === null) return organizationWrongState("profile-incomplete", ["profile-complete"]);
+		const refreshed = await deps.refreshIdentity(options);
+		if (!current()) return cancelledOrganization();
+		if (!refreshed.ok) return refreshed;
+		const claimed = await reachClaimedAccount(deps, options);
+		if (!current()) return cancelledOrganization();
+		if (!claimed.ok) return claimed;
+		const begun = await setup.begin(normalized.value);
+		if (!current()) return cancelledOrganization();
+		if (begun.ok) {
+			await deps.sendIdentity({
+				_tag: "AttachOrganization",
+				orgId: String(begun.value.orgId)
+			}, options);
+			if (!current()) return cancelledOrganization();
+		}
+		return begun;
+	} catch (cause) {
+		return {
+			ok: false,
+			error: Errors.unknown(cause)
+		};
 	}
-	const event = active?.at === "failed" && active.orgId !== null ? { _tag: "RetryOrganization" } : {
-		_tag: "CreateOrganization",
-		draft
-	};
-	const created = await deps.sendIdentity(event, options);
-	if (!created.ok) return created;
-	const final = created.value;
-	const organization = isClaimedIdentityState(final) ? final.account.org : null;
-	return organization?.at === "ready" ? {
-		ok: true,
-		value: { organizationId: organization.orgId }
-	} : organizationWrongState(organization?.at ?? "organization-missing", ["ready"], organization !== null && "orgId" in organization ? organization.orgId ?? void 0 : void 0);
 }
-async function selectOrganizationLane(deps, state, options) {
-	if (options?.intent !== "create") return {
-		ok: true,
-		value: state
+function setupFailure(setup) {
+	const issue = setup.issue;
+	const details = {
+		...issue?.error?.details,
+		organizationId: String(setup.orgId),
+		...issue !== null && { setupReason: issue.reason }
 	};
-	const active = state.account.org;
-	if (active?.at === "ready") {
-		const left = await deps.sendIdentity({ _tag: "LeaveOrganization" }, options);
-		if (!left.ok) return left;
-		return isClaimedIdentityState(left.value) ? {
-			ok: true,
-			value: left.value
-		} : organizationWrongState("organization-leave-incomplete", ["claimed"]);
+	if (issue?.error !== void 0) {
+		const error = issue.error;
+		return new CapxulError(error.code, error.message, {
+			details,
+			...error.mode === void 0 ? {} : { mode: error.mode },
+			...error.chain === void 0 ? {} : { chain: error.chain },
+			...error.layer === void 0 ? {} : { layer: error.layer },
+			...error.correlationId === void 0 ? {} : { correlationId: error.correlationId }
+		});
 	}
-	if (active === null || active === void 0) return {
-		ok: true,
-		value: state
-	};
-	const organizationId = "orgId" in active ? active.orgId ?? void 0 : void 0;
-	return organizationWrongState(active.at, ["no-active-organization"], organizationId);
+	const fallback = Errors.wrongState({
+		method: CAPXUL_OPERATIONS.onboarding.completeOrganization,
+		currentState: setup.status,
+		validStates: ["ready"],
+		organizationId: String(setup.orgId)
+	});
+	return new CapxulError(fallback.code, fallback.message, { details: {
+		...fallback.details,
+		...details
+	} });
 }
-function projectOrganizationState(state) {
-	if (state.phase !== "authenticated" || state.account.at !== "claimed") return {
-		organizationId: null,
-		lifecycle: null
-	};
-	const org = state.account.org;
-	if (org === null || org.at === "creating") return {
-		organizationId: null,
-		lifecycle: null
-	};
-	if (org.at === "failed" && org.orgId === null) return {
-		organizationId: null,
-		lifecycle: null
-	};
-	const organizationId = toOrgId(org.orgId);
-	return {
-		organizationId,
-		lifecycle: org.at === "loading" ? {
-			status: "loading",
-			orgId: organizationId
-		} : org.at === "settingUp" ? {
-			status: "settingUp",
-			orgId: organizationId,
-			step: org.step
-		} : org.at === "ready" ? {
-			status: "ready",
-			orgId: organizationId,
-			canTransact: true
-		} : {
-			status: "failed",
-			orgId: organizationId,
-			at: org.step,
-			error: publicIdentityFailure(org.failure),
-			retryable: org.retryable
-		}
-	};
+const cancelledOrganization = () => ({
+	ok: false,
+	error: Errors.cancelled({ operation: CAPXUL_OPERATIONS.onboarding.completeOrganization })
+});
+function awaitReady(deps, orgId, options) {
+	const setup = deps.organizationSetup;
+	if (setup === void 0) return Promise.resolve({
+		ok: false,
+		error: Errors.notImplemented("organizationSetup", "subscribe")
+	});
+	const lifetime = deps.authLifetime();
+	const isCurrent = () => deps.matchesAuthLifetime(lifetime, lifetime.authUserId);
+	return new Promise((resolve) => {
+		let done = false;
+		let stopRemote = null;
+		let stopIdentity = null;
+		const finish = (result) => {
+			if (done) return;
+			done = true;
+			stopRemote?.();
+			stopIdentity?.();
+			options?.signal?.removeEventListener("abort", onAbort);
+			resolve(result);
+		};
+		const onAbort = () => finish(cancelledOrganization());
+		options?.signal?.addEventListener("abort", onAbort, { once: true });
+		const releaseIdentity = deps.subscribeIdentity((state) => {
+			if (state.phase !== "authenticated" || !deps.matchesAuthLifetime(lifetime, state.session.authUserId)) finish(cancelledOrganization());
+		});
+		if (done) releaseIdentity();
+		else stopIdentity = releaseIdentity;
+		if (options?.signal?.aborted || !isCurrent()) return onAbort();
+		setup.subscribe(orgId, (snapshot) => {
+			if (done) return;
+			if (!isCurrent()) return finish(cancelledOrganization());
+			if (snapshot.status === "loading") return;
+			if (snapshot.status === "error") return finish({
+				ok: false,
+				error: snapshot.error
+			});
+			if (snapshot.value.status === "ready") return finish({
+				ok: true,
+				value: { organizationId: orgId }
+			});
+			if (snapshot.value.status === "needsAttention" || snapshot.value.status === "failed") finish({
+				ok: false,
+				error: setupFailure(snapshot.value)
+			});
+		}, options).then((result) => {
+			if (!result.ok) return finish(result);
+			if (done) result.value();
+			else stopRemote = result.value;
+		}).catch((cause) => finish({
+			ok: false,
+			error: Errors.unknown(cause)
+		}));
+	});
 }
 const cancelledPerson = () => ({
 	ok: false,
@@ -48257,8 +48213,22 @@ const samePersonInput = (left, right) => {
 function makeOnboardingMethods(deps) {
 	let personFlight = null;
 	return {
-		subscribeOrganization(observer) {
-			return deps.subscribeIdentity((state) => observer(projectOrganizationState(state)));
+		async listOrganizationSetups(input, options) {
+			if (requestCancelled(options)) return cancelledOrganization();
+			if (deps.organizationSetup === void 0) return {
+				ok: false,
+				error: Errors.notImplemented("organizationSetup", "listMine")
+			};
+			const lifetime = deps.authLifetime();
+			const session = await deps.restoreSession(options);
+			if (!session.ok) return session;
+			if (session.value === null) return {
+				ok: false,
+				error: Errors.notAuthenticated()
+			};
+			if (!deps.matchesAuthLifetime(lifetime, String(session.value.authUserId)) || requestCancelled(options)) return cancelledOrganization();
+			const listed = await deps.organizationSetup.listMine(input, options);
+			return deps.matchesAuthLifetime(lifetime, String(session.value.authUserId)) && !requestCancelled(options) ? listed : cancelledOrganization();
 		},
 		async completePerson(input, options) {
 			if (options?.signal?.aborted) return cancelledPerson();
@@ -48404,39 +48374,40 @@ function makeOnboardingMethods(deps) {
 				if (personFlight?.pending === pending) personFlight = null;
 			}
 		},
+		beginOrganization(input, options) {
+			return beginOrganization(deps, input, options);
+		},
 		async completeOrganization(input, options) {
-			const operation = CAPXUL_OPERATIONS.onboarding.completeOrganization;
-			const normalized = normalizeOrganization(input);
-			if (!normalized.ok) return normalized;
-			const session = await deps.restoreSession(options);
-			if (!session.ok) return session;
-			if (session.value === null) return {
-				ok: false,
-				error: Errors.notAuthenticated()
-			};
-			const profile = await deps.loadProfile(options);
-			if (!profile.ok) return profile;
-			if (profile.value === null || profile.value.displayName === null || profile.value.handle === null) return {
-				ok: false,
-				error: Errors.wrongState({
-					method: operation,
-					currentState: "profile-incomplete",
-					validStates: ["profile-complete"]
-				})
-			};
-			const refreshed = await deps.refreshIdentity(options);
-			if (!refreshed.ok) return refreshed;
-			if (requestCancelled(options)) return {
-				ok: false,
-				error: Errors.cancelled({ operation })
-			};
-			const claimed = await reachClaimedAccount(deps, options);
-			if (!claimed.ok) return claimed;
-			if (requestCancelled(options)) return {
-				ok: false,
-				error: Errors.cancelled({ operation })
-			};
-			return createOrResumeOrganization(deps, claimed.value, normalized.value, options);
+			try {
+				const begun = await beginOrganization(deps, input, options);
+				if (!begun.ok) return begun;
+				const lifetime = deps.authLifetime();
+				const isCurrent = () => deps.matchesAuthLifetime(lifetime, lifetime.authUserId);
+				if (!isCurrent()) return cancelledOrganization();
+				const { orgId } = begun.value;
+				let setup = begun.value.setup;
+				if (setup.status === "awaitingAuthorization") {
+					const authorized = await deps.organizationSetup.authorize(orgId, options);
+					if (!isCurrent()) return cancelledOrganization();
+					if (!authorized.ok) return authorized;
+					setup = authorized.value;
+				}
+				if (requestCancelled(options) || !isCurrent()) return cancelledOrganization();
+				if (setup.status === "ready") return {
+					ok: true,
+					value: { organizationId: orgId }
+				};
+				if (setup.status === "needsAttention" || setup.status === "failed") return {
+					ok: false,
+					error: setupFailure(setup)
+				};
+				return awaitReady(deps, orgId, options);
+			} catch (cause) {
+				return {
+					ok: false,
+					error: Errors.unknown(cause)
+				};
+			}
 		}
 	};
 }
@@ -49489,92 +49460,6 @@ function makeUnavailablePayrollMethods() {
 	};
 }
 //#endregion
-//#region ../../packages/sdk/src/surface/_shared/org-telemetry.ts
-/** Extract the domain from an email for telemetry (never the local part / PII). */
-function emailDomain$1(email) {
-	const at = email.lastIndexOf("@");
-	if (at < 0 || at === email.length - 1) return void 0;
-	return email.slice(at + 1).toLowerCase();
-}
-/** Fire-and-forget emit through an optional port; never throws. */
-async function emitOrgTelemetry(telemetry, event, runPromise) {
-	if (telemetry === void 0) return;
-	await Promise.resolve().then(() => runPromise(Effect.suspend(() => telemetry.emit(event)).pipe(Effect.catch((cause) => reportOrgTelemetryFailure("error", event.name, cause)), Effect.catchDefect((cause) => reportOrgTelemetryFailure("defect", event.name, cause))))).catch(() => void 0);
-}
-function emitOrgCreateStarted(telemetry, input, runPromise) {
-	const domain = input.email === void 0 ? void 0 : emailDomain$1(input.email);
-	return emitOrgTelemetry(telemetry, {
-		name: "org_create_started",
-		props: {
-			template: input.template,
-			...domain === void 0 ? {} : { email_domain: domain }
-		}
-	}, runPromise);
-}
-/** Spread the `chainId` prop only when known — never emit a misleading `0`. */
-function chainIdProp(chainId) {
-	return chainId === void 0 ? {} : { chainId };
-}
-function emitOrgSafeCreated(telemetry, input, runPromise) {
-	return emitOrgTelemetry(telemetry, {
-		name: "org_safe_created",
-		props: {
-			org_id: input.orgId,
-			safe_address: input.safeAddress,
-			...chainIdProp(input.chainId)
-		}
-	}, runPromise);
-}
-function emitOrgSafeConfirmed(telemetry, input, runPromise) {
-	return emitOrgTelemetry(telemetry, {
-		name: "org_safe_confirmed",
-		props: {
-			org_id: input.orgId,
-			safe_address: input.safeAddress,
-			...chainIdProp(input.chainId)
-		}
-	}, runPromise);
-}
-function emitOrgRolesSeeded(telemetry, input, runPromise) {
-	return emitOrgTelemetry(telemetry, {
-		name: "org_roles_seeded",
-		props: {
-			org_id: input.orgId,
-			role: input.role
-		}
-	}, runPromise);
-}
-function emitOrgCreated(telemetry, input, runPromise) {
-	return emitOrgTelemetry(telemetry, {
-		name: "org_created",
-		props: {
-			org_id: input.orgId,
-			safe_address: input.safeAddress,
-			...chainIdProp(input.chainId)
-		}
-	}, runPromise);
-}
-function emitOrgCreateFailed(telemetry, error, runPromise) {
-	return emitOrgTelemetry(telemetry, {
-		name: "org_create_failed",
-		props: {
-			...failureDetail(error),
-			reason: error.code
-		}
-	}, runPromise);
-}
-function reportOrgTelemetryFailure(kind, name, cause) {
-	if (!isOrgTelemetryDebugEnabled()) return Effect.void;
-	return Effect.logWarning("org.telemetry.dropped").pipe(Effect.annotateLogs({
-		kind,
-		event_name: name,
-		...failureDetail(cause)
-	}));
-}
-function isOrgTelemetryDebugEnabled() {
-	return globalThis.process?.env?.CAPXUL_DEBUG_TELEMETRY === "1";
-}
-//#endregion
 //#region ../../packages/sdk/src/surface/org-deps.ts
 var OrgDepsTag = class extends Context.Service()("@capxul/sdk/OrgDeps") {};
 function orgDepsLayer(deps) {
@@ -49596,91 +49481,6 @@ function stripPrefix(value) {
 	const cleaned = (underscore < 0 ? value : value.slice(underscore + 1)).replace(/[^0-9A-Za-z]/g, "");
 	return cleaned.length > 0 ? cleaned : "0";
 }
-/** Map an arbitrary string deterministically into lowercase hex chars. */
-function toHexSeed(value) {
-	let out = "";
-	for (const ch of value) out += (ch.codePointAt(0) ?? 0).toString(16).padStart(2, "0");
-	return out.length > 0 ? out : "0";
-}
-/**
-* Build the hermetic `OrgView` for the no-port L1 path: a deterministic
-* counterfactual-shaped placeholder Org Safe + a `$0` treasury (D3). The live
-* path replaces this with the real deployed address + RPC balance.
-*/
-function hermeticOrgView(input) {
-	const orgId = toOrgId(`org_${stripPrefix(`x_${input.handle}`)}`);
-	const placeholder = `0x${toHexSeed(input.handle).padEnd(40, "0").slice(0, 40)}`;
-	return {
-		id: orgId,
-		name: input.name,
-		handle: input.handle,
-		safeAddress: toAddress(placeholder),
-		role: ADMIN_ROLE_LABEL,
-		treasury: zeroTreasury(orgId),
-		bio: null,
-		size: null,
-		logoUrl: null,
-		account: {
-			id: null,
-			address: toAddress(placeholder),
-			ready: null
-		},
-		setup: {
-			status: "settingUp",
-			orgId,
-			step: "preparingFounderAccount"
-		},
-		member: null,
-		capabilities: {
-			canManagePeople: false,
-			canSpend: false
-		},
-		custody: { status: "unknown" },
-		observedAt: 0
-	};
-}
-function createOrgProgram(input) {
-	return Effect.gen(function* () {
-		const deps = yield* OrgDepsTag;
-		const chainId = deps.chainId;
-		yield* Effect.promise(() => emitOrgCreateStarted(deps.telemetry, { template: input.template }, deps.runPromise));
-		return yield* Effect.gen(function* () {
-			if (deps.orgPort !== void 0) {
-				const org = yield* deps.orgPort.createOrg({ input }).pipe(Effect.mapError((error) => error.publicError));
-				yield* emitCreationFunnelTail(deps.telemetry, org, chainId, deps.runPromise);
-				return org;
-			}
-			const org = hermeticOrgView(input);
-			yield* emitCreationFunnelTail(deps.telemetry, org, chainId, deps.runPromise);
-			return org;
-		}).pipe(Effect.tapError((error) => Effect.promise(() => emitOrgCreateFailed(deps.telemetry, error, deps.runPromise))));
-	});
-}
-/** Emit the remaining `org_creation` funnel steps once the org is built. */
-function emitCreationFunnelTail(telemetry, org, chainId, runPromise) {
-	return Effect.promise(async () => {
-		const chain = chainId === void 0 ? {} : { chainId };
-		await emitOrgSafeCreated(telemetry, {
-			orgId: org.id,
-			safeAddress: org.safeAddress,
-			...chain
-		}, runPromise);
-		await emitOrgSafeConfirmed(telemetry, {
-			orgId: org.id,
-			safeAddress: org.safeAddress,
-			...chain
-		}, runPromise);
-		if (org.role !== null) await emitOrgRolesSeeded(telemetry, {
-			orgId: org.id,
-			role: org.role
-		}, runPromise);
-		await emitOrgCreated(telemetry, {
-			orgId: org.id,
-			safeAddress: org.safeAddress,
-			...chain
-		}, runPromise);
-	});
-}
 function readTreasuryProgram(orgId) {
 	return Effect.gen(function* () {
 		const deps = yield* OrgDepsTag;
@@ -49747,90 +49547,6 @@ function listOrgsProgram() {
 	});
 }
 //#endregion
-//#region ../../packages/sdk/src/surface/org-lifecycle.ts
-function fail(error) {
-	return {
-		ok: false,
-		error
-	};
-}
-function validateOrganizationLifecycleScope(orgId, lifecycle) {
-	if (String(lifecycle.orgId) !== String(orgId)) return fail(Errors.invalidInput("orgId", "Organization lifecycle scope does not match"));
-	return {
-		ok: true,
-		value: lifecycle
-	};
-}
-/** Advance only the steps still required by one durable Organization lane. */
-async function advanceOrganizationSetup(setup, orgId, initial, context) {
-	const { signal, observationSource } = context ?? {};
-	const scopedInitial = validateOrganizationLifecycleScope(orgId, initial);
-	if (!scopedInitial.ok) return scopedInitial;
-	let lifecycle = scopedInitial.value;
-	for (let transition = 0; transition < 3; transition += 1) {
-		if (lifecycle.status !== "settingUp") return {
-			ok: true,
-			value: lifecycle
-		};
-		const currentStep = lifecycle.step;
-		if (signal?.aborted) return recordSetupFailure(setup, orgId, Errors.cancelled({ operation: CAPXUL_OPERATIONS.organization.setup }), true, observationSource);
-		const stepInput = copyInvocationObservation(observationSource, {
-			orgId,
-			...signal === void 0 ? {} : { signal }
-		});
-		const next = lifecycle.step === "preparingFounderAccount" ? await setup.prepareFounderAccount(stepInput) : lifecycle.step === "awaitingFounderAuthorization" ? await setup.authorizeAndSubmitBootstrap(stepInput) : lifecycle.step === "submittingBootstrap" ? await setup.resumeSubmittedBootstrap(stepInput) : await setup.confirmSubmittedBootstrap(stepInput);
-		if (!next.ok) return recordSetupFailure(setup, orgId, next.error, isRetryableOrganizationSetupFailure(next.error), observationSource);
-		const scopedNext = validateOrganizationLifecycleScope(orgId, next.value);
-		if (!scopedNext.ok) return recordSetupFailure(setup, orgId, scopedNext.error, false, observationSource);
-		lifecycle = scopedNext.value;
-		if (currentStep === "confirmingBootstrap") return {
-			ok: true,
-			value: lifecycle
-		};
-	}
-	if (lifecycle.status !== "settingUp" || lifecycle.step === "confirmingBootstrap") return {
-		ok: true,
-		value: lifecycle
-	};
-	return recordSetupFailure(setup, orgId, Errors.wrongState({
-		method: CAPXUL_OPERATIONS.organization.setup,
-		currentState: lifecycle.step,
-		validStates: [
-			"confirmingBootstrap",
-			"ready",
-			"failed"
-		]
-	}), false, observationSource);
-}
-async function recordSetupFailure(setup, orgId, error, retryable, observationSource) {
-	const recorded = await setup.recordFailure(copyInvocationObservation(observationSource, {
-		orgId,
-		error,
-		retryable
-	}));
-	if (!recorded.ok) return recorded;
-	const scopedRecorded = validateOrganizationLifecycleScope(orgId, recorded.value);
-	if (!scopedRecorded.ok) return scopedRecorded;
-	return scopedRecorded;
-}
-/**
-* ADR-0023 R7: the layer that saw the chain failure says whether the same
-* request can succeed later; its word wins over the mode table. The table is
-* the one `identity/model.ts` uses, so the two gates read one list
-* (`org.account.get` retried a `transient: false` 403 in 1.5 s, 2026-09-03).
-*/
-function isRetryableProviderFailure(error) {
-	if (error.chain !== void 0) return error.chain.retryable;
-	const mode = error.mode ?? error.details?.failure_mode;
-	return !DEFINITIVE_PROVIDER_MODES.has(isFailureMode(mode) ? mode : void 0);
-}
-/** @internal Exported for the retry-gate test; the surface calls it from the setup loop. */
-function isRetryableOrganizationSetupFailure(error) {
-	if (error.code === "CANCELLED" || error.code === "SIGNER_REJECTED") return true;
-	if (error.code === "PROVIDER_ERROR") return isRetryableProviderFailure(error);
-	return error.code === "NETWORK_ERROR" || error.code === "UNKNOWN";
-}
-//#endregion
 //#region ../../packages/sdk/src/surface/org.ts
 /**
 * Org method surface (canon §C2/§C3, D13). The entity-scoped bundle is
@@ -49858,6 +49574,20 @@ function invitationMethodsDeps(deps, convexCall) {
 		...deps.signer === void 0 ? {} : { signer: deps.signer }
 	};
 }
+async function invokeSetup(setup, method, call) {
+	if (setup === void 0) return {
+		ok: false,
+		error: Errors.notImplemented("organizationSetup", method)
+	};
+	try {
+		return await call();
+	} catch (cause) {
+		return {
+			ok: false,
+			error: Errors.unknown(cause)
+		};
+	}
+}
 function makeOrgMethods(deps) {
 	const orgDeps = {
 		runPromise: deps.runPromise,
@@ -49883,13 +49613,6 @@ function makeOrgMethods(deps) {
 		}))), controls, CAPXUL_OPERATIONS.org.orgs, deps.runPromise);
 	};
 	return {
-		createOrg(input, options) {
-			if (options?.signal?.aborted) return Promise.resolve({
-				ok: false,
-				error: Errors.cancelled({ operation: CAPXUL_OPERATIONS.org.createOrg })
-			});
-			return toCapxulResult(createOrgProgram(input), layer, deps.runPromise);
-		},
 		orgs: Object.assign((options) => listOrganizations(deps.invocationControls?.(options) ?? options), { invitations: deps.convexCall === void 0 ? () => Promise.resolve({
 			ok: false,
 			error: Errors.notImplemented("invitations", "listOwn")
@@ -49910,38 +49633,11 @@ function makeOrgMethods(deps) {
 					convexCall,
 					...observedRunnerDeps(deps)
 				}, String(orgId)),
-				async getLifecycle(options) {
-					if (options?.signal?.aborted) return {
-						ok: false,
-						error: Errors.cancelled({ operation: CAPXUL_OPERATIONS.org.getLifecycle })
-					};
-					if (deps.organizationSetup === void 0) return {
-						ok: false,
-						error: Errors.notImplemented("organizationSetup", "getLifecycle")
-					};
-					const loaded = await deps.organizationSetup.loadLifecycle({ orgId });
-					if (!loaded.ok) return loaded;
-					return validateOrganizationLifecycleScope(orgId, loaded.value);
-				},
-				async retrySetup(options) {
-					if (options?.signal?.aborted) return {
-						ok: false,
-						error: Errors.cancelled({ operation: CAPXUL_OPERATIONS.org.retrySetup })
-					};
-					const setup = deps.organizationSetup;
-					if (setup === void 0) return {
-						ok: false,
-						error: Errors.notImplemented("organizationSetup", "retrySetup")
-					};
-					const retried = await setup.retry(copyInvocationObservation(options, {
-						orgId,
-						...options?.signal === void 0 ? {} : { signal: options.signal }
-					}));
-					if (!retried.ok) return retried;
-					return advanceOrganizationSetup(setup, orgId, retried.value, {
-						signal: options?.signal,
-						observationSource: options
-					});
+				setup: {
+					get: (options) => invokeSetup(deps.organizationSetup, "get", () => deps.organizationSetup.get(orgId, options)),
+					subscribe: (listener, options) => invokeSetup(deps.organizationSetup, "subscribe", () => deps.organizationSetup.subscribe(orgId, listener, options)),
+					resume: (options) => invokeSetup(deps.organizationSetup, "resume", () => deps.organizationSetup.resume(orgId, options)),
+					authorize: (options) => invokeSetup(deps.organizationSetup, "authorize", () => deps.organizationSetup.authorize(orgId, options))
 				},
 				profile: {
 					get(_options) {
@@ -50297,8 +49993,8 @@ const APPLIED_ACTION_BY_EVENT = {
 	RetryAccount: "none",
 	CreateOrganization: "none",
 	AttachOrganization: "none",
-	RetryOrganization: "none",
 	LeaveOrganization: "none",
+	ObserveOrganization: "none",
 	OtpSent: "otp-requested",
 	OtpFailed: "failed",
 	Verified: "verified",
@@ -50312,9 +50008,8 @@ const APPLIED_ACTION_BY_EVENT = {
 	AccountClaiming: "none",
 	AccountClaimed: "none",
 	AccountFailed: "none",
-	OrgAt: "none",
-	OrgReady: "none",
-	OrgFailed: "none"
+	OrgSelected: "none",
+	OrgSelectionFailed: "none"
 };
 const linkage = (record) => ({
 	...record.correlation_id === void 0 ? {} : { correlation_id: record.correlation_id },
@@ -50377,8 +50072,7 @@ const REFUSAL_EVENTS = /* @__PURE__ */ new Set([
 	"ClaimAccount",
 	"RetryAccount",
 	"CreateOrganization",
-	"AttachOrganization",
-	"RetryOrganization"
+	"AttachOrganization"
 ]);
 function mapIdentityProductObservation(record, state) {
 	if (record.machine !== "identity" || !IDENTITY_EVENT_TAG_SET.has(record.event)) return NONE;
@@ -50557,7 +50251,7 @@ function assembleCapxulClient(input) {
 		...input.signer === void 0 ? {} : { signer: input.signer },
 		...input.organizationSetup === void 0 ? {} : { organizationSetup: input.organizationSetup },
 		...input.otpTtlMs === void 0 ? {} : { otpTtlMs: input.otpTtlMs },
-		...input.ports.telemetry === void 0 ? {} : { telemetry: input.ports.telemetry }
+		runPromise: effectRunner.runPromise
 	}), scope)), observation.hostObservationSnapshot);
 	const unsubscribeProductTelemetry = actor.subscribeTransitions((record) => {
 		effectRunner.runPromise(executeIdentityProductObservation(input.ports.telemetry, record, actor.snapshot())).catch(() => {});
@@ -50585,7 +50279,7 @@ function assembleCapxulClient(input) {
 		return stopPromise;
 	};
 	if (input.signal !== void 0) input.signal.addEventListener("abort", () => void stopActor(), { once: true });
-	const selectedOrgPort = input.orgPort ?? input.orgDeploymentPort;
+	const selectedOrgPort = input.orgPort;
 	let kickProvisioning;
 	const financialOps = makeFinancialOpsMethods({
 		runPromise: effectRunner.runPromise,
@@ -50672,7 +50366,8 @@ function assembleCapxulClient(input) {
 		getLifecycle: account.getLifecycle,
 		snapshotIdentity: actor.snapshot,
 		subscribeIdentity: actor.subscribe,
-		sendIdentity: (event, options) => runCapxulEffect(askIdentity(actor, event, options), options, CAPXUL_OPERATIONS._internal.identity.send, effectRunner.runPromise)
+		sendIdentity: (event, options) => runCapxulEffect(askIdentity(actor, event, options), options, CAPXUL_OPERATIONS._internal.identity.send, effectRunner.runPromise),
+		...input.organizationSetup === void 0 ? {} : { organizationSetup: input.organizationSetup }
 	});
 	const system = makeSystemMethods({
 		convexCall: input.ports.convexCall,
@@ -50802,7 +50497,6 @@ function assembleCapxulClient(input) {
 		offramp: financialOps.offramp,
 		paymentDocuments: financialOps.paymentDocuments,
 		media,
-		createOrg: orgMethods.createOrg,
 		orgs: orgMethods.orgs,
 		org: orgMethods.org,
 		signer: input.signer?.statusStore ?? UNOBSERVABLE_SIGNER_STATUS,
@@ -51978,7 +51672,8 @@ async function createCapxulClientWithSignerControls(input, controls) {
 			organizationSetup: new ConvexOrganizationSetupAdapter({
 				convex: adapters.value.ports.convexCall,
 				...signer === void 0 ? {} : { signer },
-				chainId: adapters.value.bootstrap.chainId
+				chainId: adapters.value.bootstrap.chainId,
+				runPromise: effectRunner.runPromise
 			}),
 			...input.signal === void 0 ? {} : { signal: input.signal },
 			...input.otpTtlMs === void 0 ? {} : { otpTtlMs: input.otpTtlMs },
@@ -52722,7 +52417,7 @@ function stdioIdentity(env = process.env, options = {}) {
 }
 //#endregion
 //#region package.json
-var version = "4.20.0-beta.10";
+var version = "4.20.0-beta.11";
 //#endregion
 //#region src/deps.ts
 const NO_IDENTITY = async () => void 0;