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

package/dist/main.mjs

@@ -95,8 +95,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",
@@ -114,8 +113,8 @@ const EVENT_TAGS = [
 	"RetryAccount",
 	"CreateOrganization",
 	"AttachOrganization",
-	"RetryOrganization",
-	"LeaveOrganization"
+	"LeaveOrganization",
+	"ObserveOrganization"
 ];
 const PRIVATE_EVENT_TAGS = [
 	"OtpSent",
@@ -131,9 +130,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. */
@@ -183,18 +181,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 = {
@@ -274,36 +265,24 @@ const privateTransition = (state, event) => {
 			failure: event.failure,
 			retryable: isRetryable(event.failure)
 		}) } : WRONG;
-		case "OrgAt": {
-			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": {
+		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 === "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
+			}) };
 		}
 	}
 };
@@ -372,35 +351,43 @@ const transition$1 = (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": {
@@ -2335,6 +2322,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;
@@ -4501,9 +4520,6 @@ function deriveCapxulSafeAddressForOwner(input) {
 	}).toLowerCase();
 }
 //#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 = [
@@ -5973,8 +5989,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
@@ -5992,15 +6008,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),
@@ -6199,9 +6215,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),
@@ -6210,8 +6226,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),
@@ -6222,13 +6238,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),
@@ -6269,14 +6285,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,
@@ -6287,20 +6305,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"]);
@@ -7057,12 +7068,17 @@ const CliCommandCompletedTelemetryEventSchema = 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"
 		]))
 	})
 });
@@ -7968,14 +7984,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",
@@ -7992,17 +8001,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",
@@ -8123,6 +8133,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);
@@ -10929,7 +10993,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. */
@@ -14350,7 +14414,7 @@ function mismatch(field, message) {
 		error: Errors.invalidInput(field, message)
 	};
 }
-function cancelled(operation) {
+function cancelled$1(operation) {
 	return {
 		ok: false,
 		error: Errors.cancelled({ operation })
@@ -14382,7 +14446,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 {
@@ -14410,10 +14474,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
@@ -40685,6 +40749,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([
@@ -40692,7 +40757,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",
@@ -40772,6 +40838,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",
@@ -40792,6 +40865,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);
@@ -45357,11 +45431,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",
@@ -45397,8 +45468,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",
@@ -45419,9 +45489,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"
 ]);
@@ -45964,6 +46033,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) {
@@ -45976,37 +46082,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 {
@@ -46114,9 +46200,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))));
 	}
@@ -46158,267 +46241,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$2(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$2(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$1(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$1(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$1(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$1(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$2(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$1(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$2(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$2(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$1(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$2(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$2(publicError(operation, result.failure));
-	} catch (cause) {
-		return fail$2(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$2(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$1(publicError(result.failure));
+		} catch (cause) {
+			return fail$1(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$1(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$2(Errors.invalidInput("signerAddress", "Prepared signer does not match configured signer"));
-	if (founder === signer || organization === signer || organization === founder) return fail$2(Errors.invalidInput("organizationAuthority", "Signer EOA, founder Account, and Organization Account must be distinct"));
-	if (sender !== founder) return fail$2(Errors.invalidInput("userOp.sender", "Bootstrap sender must be the founder Account"));
-	if (!/^0x[0-9a-fA-F]{64}$/u.test(prepared.digest)) return fail$2(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$1(Errors.invalidInput("organizationAuthority", "Prepared authorities do not match"));
+	if (!/^0x[0-9a-fA-F]{64}$/u.test(prepared.digest)) return fail$1(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$2(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$2(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$2(Errors.providerError("convex-organization", operation, cause));
+		return fail$1(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$1(Errors.cancelled({ operation: CAPXUL_OPERATIONS.organization.setup }));
 }
-function cancellation(signal) {
-	return signal?.aborted ? fail$2(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$2(error) {
+function fail$1(error) {
 	return {
 		ok: false,
 		error
@@ -46583,22 +46633,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 {
@@ -46616,13 +46671,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) => {
@@ -46633,29 +46688,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;
@@ -46779,12 +46811,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);
@@ -46795,165 +46821,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 {
@@ -46984,23 +46867,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;
 };
@@ -47011,7 +46879,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,
@@ -47028,7 +46895,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;
@@ -47122,29 +46989,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;
 			}
@@ -47153,10 +47001,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();
@@ -47181,7 +47088,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. */
@@ -47864,6 +47771,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);
@@ -47882,7 +47793,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 }
 		}
 	};
 }
@@ -47974,93 +47886,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,
@@ -48114,8 +48070,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();
@@ -48261,39 +48231,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)
+				};
+			}
 		}
 	};
 }
@@ -49346,92 +49317,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) {
@@ -49453,91 +49338,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;
@@ -49604,90 +49404,6 @@ function listOrgsProgram() {
 	});
 }
 //#endregion
-//#region ../../packages/sdk/src/surface/org-lifecycle.ts
-function fail$1(error) {
-	return {
-		ok: false,
-		error
-	};
-}
-function validateOrganizationLifecycleScope(orgId, lifecycle) {
-	if (String(lifecycle.orgId) !== String(orgId)) return fail$1(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
@@ -49715,6 +49431,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,
@@ -49740,13 +49470,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")
@@ -49767,38 +49490,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) {
@@ -50154,8 +49850,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",
@@ -50169,9 +49865,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 },
@@ -50234,8 +49929,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;
@@ -50414,7 +50108,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(() => {});
@@ -50442,7 +50136,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,
@@ -50529,7 +50223,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,
@@ -50659,7 +50354,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,
@@ -51754,7 +51448,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 },
@@ -52091,8 +51786,8 @@ function captureException(telemetry, error, context) {
 }
 //#endregion
 //#region src/version.ts
-const cliVersion = "4.20.0-beta.10";
-const sdkVersion = "4.20.0-beta.10";
+const cliVersion = "4.20.0-beta.11";
+const sdkVersion = "4.20.0-beta.11";
 const ReleaseVersion = Schema.String.check(Schema.isMaxLength(256), Schema.isPattern(/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+[0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*)?$/u)).pipe(Schema.brand("CliReleaseVersion"));
 const parts = (version) => {
 	const [core = "", ...prerelease] = version.split("+")[0].split("-");
@@ -52850,20 +52545,31 @@ const authInputMessage = (error) => {
 	if (PROFILE_FIELDS.has(field)) return PROFILE_INPUT_MESSAGE;
 	return INPUT_MESSAGE;
 };
-/**
-* The one allowlist. Only a WRONG_STATE whose SDK details carry an Organization
-* ID the public constructor accepts emits that ID, and it never enters message
-* text or valid states. No other error detail reaches terminal output, and a
-* malformed SDK value is omitted rather than published as an identifier.
-*/
+/** Keep validated identifiers and structured provider causes; omit unknown details. */
 function allowlistedDetails(error) {
-	if (error.code !== "WRONG_STATE") return void 0;
+	const safe = {};
 	try {
 		const organizationId = String(toOrgId(error.details?.organizationId));
-		return organizationId.trim().length === 0 ? void 0 : { organizationId };
-	} catch {
-		return;
-	}
+		if (organizationId.trim().length > 0) safe.organizationId = organizationId;
+	} catch {}
+	if (typeof error.details?.setupReason === "string" && ORGANIZATION_SETUP_REASONS.some((reason) => reason === error.details?.setupReason)) safe.setupReason = error.details.setupReason;
+	if (typeof error.details?.retryable === "boolean") safe.retryable = error.details.retryable;
+	if (error.chain !== void 0) {
+		safe.retryable = error.chain.retryable;
+		safe.upstream = error.chain.upstream;
+		safe.method = error.chain.method;
+		if (error.chain.httpStatus !== void 0) safe.httpStatus = error.chain.httpStatus;
+		if (error.chain.rpcCode !== void 0) safe.rpcCode = error.chain.rpcCode;
+	}
+	if (typeof error.details?.httpStatus === "number" && Number.isSafeInteger(error.details.httpStatus)) safe.httpStatus = error.details.httpStatus;
+	if (typeof error.details?.rpcCode === "number" && Number.isSafeInteger(error.details.rpcCode)) safe.rpcCode = error.details.rpcCode;
+	if (typeof error.details?.provider === "string" && [
+		"openfort",
+		"browserBridge",
+		"better-auth",
+		"signer"
+	].includes(error.details.provider)) safe.provider = error.details.provider;
+	return Object.keys(safe).length === 0 ? void 0 : safe;
 }
 function walletDetails(error) {
 	if (!isWalletStage(error.details?.walletStage)) return void 0;
@@ -52934,14 +52640,17 @@ function classifyFailure(cause, command) {
 		const wrongState = error.code === "WRONG_STATE";
 		const input = error.code === "INVALID_INPUT" || error.code === "OTP_EXPIRED";
 		const wallet = walletDetails(error);
-		const details = wallet ?? allowlistedDetails(error);
+		const details = {
+			...allowlistedDetails(error),
+			...wallet
+		};
 		return {
 			code: error.code,
 			message: applicationMessage(error, command, wallet),
 			exitCode: auth ? 3 : denied ? 4 : input || wrongState ? 2 : 5,
 			outcome: auth || denied || input || wrongState ? "refused" : "failed",
 			...error.mode === void 0 ? {} : { mode: error.mode },
-			...details === void 0 ? {} : { details }
+			...Object.keys(details).length === 0 ? {} : { details }
 		};
 	}
 	return {
@@ -53037,7 +52746,8 @@ const codes = [
 	"CLI_USAGE",
 	"CLI_CONFIG",
 	"CLI_STORAGE",
-	"CLI_DEFECT"
+	"CLI_DEFECT",
+	"CLI_DEADLINE"
 ];
 const identifier = Schema.String.check(Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u));
 const version = Schema.String.check(Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._+-]{0,127}$/u));
@@ -53049,6 +52759,37 @@ const completionSchema = Schema.Struct({
 	wait_duration_ms: Schema.Number,
 	retry_count: Schema.Literal(0)
 });
+const SETUP_COMMANDS = /* @__PURE__ */ new Set([
+	CAPXUL_OPERATIONS.org.create,
+	CAPXUL_OPERATIONS.org.retry,
+	"org.status",
+	"org.wait"
+]);
+/** Project one backend-checked Organization result, never a local pointer. */
+function organizationCompletion(command, result, failure) {
+	if (!SETUP_COMMANDS.has(command)) return { fields: {} };
+	const schemas = CliCommandCompletedTelemetryEventSchema.fields.props.fields;
+	const data = Exit.isSuccess(result) ? own(result.value, "data") : void 0;
+	const lifecycle = own(data, "lifecycle");
+	const rawOrgId = Exit.isSuccess(result) ? own(data, "organizationId") : failure?.details?.organizationId;
+	const decodedId = Schema.decodeUnknownOption(schemas.organization_id)(rawOrgId);
+	if (Option.isNone(decodedId) || typeof decodedId.value !== "string") return { fields: {} };
+	const organizationId = decodedId.value;
+	const verified = Exit.isSuccess(result) && own(lifecycle, "orgId") === organizationId;
+	if (Exit.isSuccess(result) && !verified) return { fields: {} };
+	const rawStatus = verified ? own(lifecycle, "status") : failure?.details?.lastObservedSetup?.status;
+	const rawReason = verified ? own(own(lifecycle, "issue"), "reason") : failure?.details?.setupReason;
+	const decodedStatus = Schema.decodeUnknownOption(schemas.setup_status)(rawStatus);
+	const decodedReason = Schema.decodeUnknownOption(schemas.setup_reason)(rawReason);
+	return {
+		fields: {
+			organization_id: organizationId,
+			...Option.isSome(decodedStatus) && decodedStatus.value !== void 0 ? { setup_status: decodedStatus.value } : {},
+			...Option.isSome(decodedReason) && decodedReason.value !== void 0 ? { setup_reason: decodedReason.value } : {}
+		},
+		...verified ? { group: { organization: organizationId } } : {}
+	};
+}
 const CAPTURE_CAPACITY = 32;
 const CAPTURE_BYTES = 8192;
 const textEncoder = new TextEncoder();
@@ -53226,12 +52967,15 @@ function observeInvocation(input, work) {
 				const client = { capture: (event, properties) => {
 					if (!enabled()) return;
 					if (event === "$exception" || event === "capxul_sdk_expected_outcome") {
-						const code = safeCode(own(properties, "error_kind"));
+						const code = safeCode(own(properties, "error_kind")) ?? (event === "$exception" ? "UNKNOWN" : void 0);
 						const operation = own(properties, "operation");
 						if (code !== void 0 && sdkDiagnostics.length < CAPTURE_CAPACITY) sdkDiagnostics.push({
-							...projectSdkProperties(properties),
-							error_code: code,
-							...isCapxulOperation(operation) ? { operation } : {}
+							log: {
+								...projectSdkProperties(properties),
+								error_code: code,
+								...isCapxulOperation(operation) ? { operation } : {}
+							},
+							...event === "$exception" ? { exception: projectException(properties, input.command, "SDK_DEFECT") } : {}
 						});
 						else dropped += 1;
 						return;
@@ -53339,6 +53083,7 @@ function observeInvocation(input, work) {
 						const errorCode = failure?.code;
 						const outcome = failure?.outcome ?? "succeeded";
 						const duration = Math.max(0, clock.currentTimeMillisUnsafe() - started);
+						const organization = organizationCompletion(input.command, result, failure);
 						const completion = Schema.decodeUnknownSync(completionSchema)({
 							...engineeringEnvelope,
 							...input.anonymousIdentity === void 0 ? {} : { posthogDistinctId: input.anonymousIdentity.id },
@@ -53352,13 +53097,14 @@ function observeInvocation(input, work) {
 							wait_duration_ms: waitDuration,
 							retry_count: 0,
 							output_mode: input.outputMode ?? "human",
-							...errorCode === void 0 ? {} : { error_code: errorCode }
+							...errorCode === void 0 ? {} : { error_code: errorCode },
+							...organization.fields
 						});
 						yield* Effect.annotateCurrentSpan(completion);
 						yield* logEngineeringInfo("cli.command.completed", completion);
 						for (const diagnostic of sdkDiagnostics) yield* logEngineeringInfo("cli.sdk.operation.failed", {
 							...engineeringEnvelope,
-							...diagnostic
+							...diagnostic.log
 						});
 						const metricAttributes = {
 							command: input.command,
@@ -53390,7 +53136,9 @@ function observeInvocation(input, work) {
 								occurred_at: clock.currentTimeMillisUnsafe(),
 								outcome,
 								duration_ms: duration,
-								...errorCode === void 0 ? {} : { error_code: errorCode }
+								...errorCode === void 0 ? {} : { error_code: errorCode },
+								...organization.fields,
+								...organization.group === void 0 ? {} : { $groups: organization.group }
 							}
 						});
 						capture("cli_command_completed", { ...terminal.props });
@@ -53419,6 +53167,9 @@ function observeInvocation(input, work) {
 									group: () => Effect.void,
 									reset: () => Effect.void
 								}, error, { capxul_error_code: "UNKNOWN" });
+							} else if (failure?.code === "UNKNOWN") {
+								const sdkDefect = sdkDiagnostics.find((item) => item.exception !== void 0)?.exception;
+								if (sdkDefect !== void 0) capture("$exception", sdkDefect);
 							}
 						}
 					}).pipe(Effect.catchCause(() => Effect.void));
@@ -53473,7 +53224,7 @@ function projectSdkProperties(properties) {
 	if (failureMode !== void 0) output.failure_mode = failureMode;
 	return output;
 }
-function projectException(properties, command) {
+function projectException(properties, command, kind = "CLI_DEFECT") {
 	const sanitized = sanitizePostHogBrowserEvent({
 		event: "$exception",
 		properties: { ...properties }
@@ -53494,17 +53245,17 @@ function projectException(properties, command) {
 		};
 	});
 	return {
-		$exception_type: "CLI_DEFECT",
-		$exception_message: "CLI command failed",
+		$exception_type: kind,
+		$exception_message: kind === "CLI_DEFECT" ? "CLI command failed" : "SDK operation failed",
 		$exception_level: "error",
-		$exception_fingerprint: `cli.${command}.CLI_DEFECT:${frames[0]?.filename ?? "boundary"}:${frames[0]?.function ?? "unknown"}`,
-		$issue_name: `CLI ${command} defect`,
+		$exception_fingerprint: `cli.${command}.${kind}:${frames[0]?.filename ?? "boundary"}:${frames[0]?.function ?? "unknown"}`,
+		$issue_name: `${kind === "CLI_DEFECT" ? "CLI" : "SDK"} ${command} defect`,
 		$exception_list: [{
-			type: "CLI_DEFECT",
-			value: "CLI command failed",
+			type: kind,
+			value: kind === "CLI_DEFECT" ? "CLI command failed" : "SDK operation failed",
 			mechanism: {
 				handled: true,
-				type: "capxul_cli_boundary"
+				type: kind === "CLI_DEFECT" ? "capxul_cli_boundary" : "capxul_cli_sdk_boundary"
 			},
 			stacktrace: {
 				type: "raw",
@@ -53664,7 +53415,8 @@ const runCommand = (options, work) => Effect.gen(function* () {
 			outcome: "succeeded",
 			data: result.data
 		}, result.lines);
-	}), options.network);
+		return result;
+	}), options.network).pipe(Effect.asVoid);
 });
 //#endregion
 //#region src/platform/capxul.ts
@@ -55259,27 +55011,25 @@ const saveOrganizationSelection = (config, authUserId, organizationId, stillAuth
 });
 //#endregion
 //#region src/org.ts
-/**
-* The exact Organization a read uses when the caller named no ID: the saved read
-* default first, then the recorded recovery handle for this person's
-* Organization journey. `recoverable` marks the handle source, whose Organization
-* may still run its setup lane and be absent from the own-access list.
-*/
+/** Resolve a scoped local pointer without treating it as backend authority. */
 const readResolvedOrganization = (config, authUserId, organizationId) => Effect.gen(function* () {
-	if (organizationId !== null) return {
-		organizationId,
-		recoverable: false
-	};
-	const selected = yield* readOrganizationSelection(config, authUserId);
-	if (selected !== null) return {
-		organizationId: selected,
-		recoverable: false
-	};
-	const recovery = yield* readOrganizationRecovery(config, authUserId);
-	return {
-		organizationId: recovery?.organizationId ?? null,
-		recoverable: recovery?.organizationId !== null && recovery?.organizationId !== void 0
-	};
+	const selected = organizationId ?? (yield* readOrganizationSelection(config, authUserId));
+	if (selected !== null) return selected;
+	return (yield* readOrganizationRecovery(config, authUserId))?.organizationId ?? null;
+});
+const listUnfinishedSetups = (client) => Effect.gen(function* () {
+	const setups = [];
+	let cursor;
+	do {
+		const page = yield* Effect.promise((signal) => client.onboarding.listOrganizationSetups({
+			...cursor === void 0 ? {} : { cursor },
+			limit: 50
+		}, { signal })).pipe(Effect.flatMap(resultValue));
+		setups.push(...page.page);
+		if (page.isDone) return setups;
+		if (page.cursor === null || page.cursor === cursor) return yield* Effect.fail(Errors.invalidInput("cursor", "Organization setup page did not advance"));
+		cursor = page.cursor;
+	} while (true);
 });
 /**
 * A ready Organization this command reports must satisfy current access.
@@ -55290,6 +55040,51 @@ const readResolvedOrganization = (config, authUserId, organizationId) => Effect.
 * Organization the person cannot reach refuses instead of reporting its state.
 */
 const requireCurrentAccess = (client, organizationId, lifecycle) => lifecycle.status !== "ready" ? Effect.void : Effect.promise((signal) => client.orgs({ signal })).pipe(Effect.flatMap(resultValue), Effect.flatMap((organizations) => organizations.some((organization) => organization.id === organizationId) ? Effect.void : Effect.fail(Errors.invalidInput("org", "The Organization is not accessible."))));
+const setupIsTerminal = (setup) => setup.status === "ready" || setup.status === "failed" || setup.status === "awaitingAuthorization" || setup.status === "needsAttention" && setup.nextCheckAt === null;
+/** One exact subscription owns the wait; the backend owns every follow-up check. */
+const observeOrganizationSetup = (scoped, organizationId, initial, onValue) => {
+	if (initial !== null) onValue?.(initial);
+	return initial !== null && setupIsTerminal(initial) ? Effect.succeed(initial) : Effect.promise((signal) => new Promise((resolve) => {
+		let closed = false;
+		let unsubscribe = null;
+		const finish = (result) => {
+			if (closed) return;
+			closed = true;
+			signal.removeEventListener("abort", onAbort);
+			unsubscribe?.();
+			resolve(result);
+		};
+		const onAbort = () => finish({
+			ok: false,
+			error: Errors.cancelled({ operation: CAPXUL_OPERATIONS.organization.setup })
+		});
+		signal.addEventListener("abort", onAbort, { once: true });
+		scoped.setup.subscribe((snapshot) => {
+			if (closed || snapshot.status === "loading") return;
+			if (snapshot.status === "error") return finish({
+				ok: false,
+				error: snapshot.error
+			});
+			if (String(snapshot.value.orgId) !== String(organizationId)) return finish({
+				ok: false,
+				error: Errors.invalidInput("orgId", "Organization setup scope does not match")
+			});
+			onValue?.(snapshot.value);
+			if (setupIsTerminal(snapshot.value)) finish({
+				ok: true,
+				value: snapshot.value
+			});
+		}, { signal }).then((result) => {
+			if (!result.ok) return finish(result);
+			unsubscribe = result.value;
+			if (closed) unsubscribe();
+		}).catch((cause) => finish({
+			ok: false,
+			error: Errors.unknown(cause)
+		}));
+		if (signal.aborted) onAbort();
+	})).pipe(Effect.flatMap(resultValue));
+};
 const readOrganization = (config, command, input) => Effect.gen(function* () {
 	const timeout = yield* Schema.decodeUnknownEffect(Schema.Int.check(Schema.isBetween({
 		minimum: 1,
@@ -55307,17 +55102,30 @@ const readOrganization = (config, command, input) => Effect.gen(function* () {
 		catch: () => inputRequired("Provide a valid Organization ID.")
 	});
 	const { client, session, stillAuthenticated } = yield* restoreAuthenticatedClient(config, input.email);
-	const organizations = yield* Effect.promise((signal) => client.orgs({ signal })).pipe(Effect.flatMap(resultValue));
+	const local = command === "list" ? null : yield* readResolvedOrganization(config, session.authUserId, organizationId);
+	const setupRead = command === "status" || command === "wait";
+	let unfinished = [];
+	if (setupRead && local === null) unfinished = yield* listUnfinishedSetups(client);
+	if (setupRead && unfinished.length > 1) return yield* Effect.fail(inputRequired("Provide --org to select one unfinished Organization setup."));
+	const resolved = setupRead && local === null && unfinished.length === 1 ? unfinished[0].orgId : local;
+	const exactSetupRead = setupRead && resolved !== null;
+	const organizations = exactSetupRead ? [] : yield* Effect.promise((signal) => client.orgs({ signal })).pipe(Effect.flatMap(resultValue));
+	if (command === "list") unfinished = yield* listUnfinishedSetups(client);
 	if (command === "list") return {
-		data: { organizations },
-		lines: organizations.map((org) => JSON.stringify({
+		data: {
+			organizations,
+			unfinishedSetups: unfinished
+		},
+		lines: [...organizations.map((org) => JSON.stringify({
 			id: org.id,
 			name: org.name,
 			address: org.account.address
-		}))
+		})), ...unfinished.map((setup) => JSON.stringify({
+			id: setup.orgId,
+			setup: setup.status
+		}))]
 	};
-	const resolved = yield* readResolvedOrganization(config, session.authUserId, organizationId);
-	organizationId = resolved.organizationId;
+	organizationId = resolved;
 	if (organizationId === null) {
 		const runtime = yield* CliRuntime;
 		if (!runtime.tty || runtime.ci || runtime.mode === "json" || organizations.length === 0) return yield* Effect.fail(inputRequired("Provide --org or select a read default with org use."));
@@ -55332,7 +55140,7 @@ const readOrganization = (config, command, input) => Effect.gen(function* () {
 			}))
 		});
 	}
-	if (!organizations.some((org) => org.id === organizationId) && !resolved.recoverable) return yield* Effect.fail(Errors.invalidInput("org", "The Organization is not accessible."));
+	if (!exactSetupRead && !organizations.some((org) => org.id === organizationId)) return yield* Effect.fail(Errors.invalidInput("org", "The Organization is not accessible."));
 	if (command === "use") {
 		yield* saveOrganizationSelection(config, session.authUserId, organizationId, stillAuthenticated);
 		return {
@@ -55382,24 +55190,16 @@ const readOrganization = (config, command, input) => Effect.gen(function* () {
 			lines: [JSON.stringify(matches[0])]
 		};
 	}
-	const read = Effect.promise((signal) => scoped.getLifecycle({ signal })).pipe(Effect.flatMap(resultValue));
+	let lastObserved = null;
 	const observed = yield* Effect.gen(function* () {
-		let lifecycle = yield* read;
-		if (resolved.recoverable) yield* requireCurrentAccess(client, organizationId, lifecycle);
-		if (command !== "wait") return lifecycle;
-		while (lifecycle.status !== "ready" && lifecycle.status !== "failed") {
-			yield* Effect.sleep(1e3);
-			lifecycle = yield* read;
-		}
-		if (resolved.recoverable) yield* requireCurrentAccess(client, organizationId, lifecycle);
+		const lifecycle = command === "wait" ? yield* observeOrganizationSetup(scoped, organizationId, null, (value) => {
+			lastObserved = value;
+		}) : yield* Effect.promise((signal) => scoped.setup.get({ signal })).pipe(Effect.flatMap(resultValue));
+		lastObserved = lifecycle;
+		yield* requireCurrentAccess(client, organizationId, lifecycle);
 		return lifecycle;
 	}).pipe(Effect.timeoutOption(timeout * 1e3));
-	if (Option.isNone(observed)) return yield* Effect.fail(new CliFailure({
-		code: "NETWORK_ERROR",
-		message: "The Organization read exceeded its deadline.",
-		exitCode: 5,
-		outcome: "failed"
-	}));
+	if (Option.isNone(observed)) return yield* Effect.fail(organizationWaitTimeout(String(organizationId), lastObserved));
 	const lifecycle = observed.value;
 	return {
 		data: {
@@ -55418,10 +55218,7 @@ const requiredText = (label, value) => Effect.gen(function* () {
 	return trimmed;
 });
 /** An optional flag contributes nothing when it is absent or blank. */
-const optionalText = (value) => {
-	const trimmed = value?.trim() ?? "";
-	return trimmed.length === 0 ? void 0 : trimmed;
-};
+const optionalText = (value) => value?.trim() || void 0;
 /**
 * Bounded local validation for `org create`. Every refusal here precedes any
 * authenticated service, browser signer, or mutation.
@@ -55486,6 +55283,7 @@ const makeOrganizationProgress = (mode, run, persist) => {
 	const heldSet = /* @__PURE__ */ new Set();
 	const written = /* @__PURE__ */ new Set();
 	let committed = null;
+	let lastObserved = null;
 	let persisted = null;
 	let readyAllowed = false;
 	let failure = null;
@@ -55519,11 +55317,10 @@ const makeOrganizationProgress = (mode, run, persist) => {
 		queued.push(text);
 	};
 	const render = (state) => {
-		const organizationId = state.organizationId;
-		if (organizationId === null) return null;
+		const organizationId = state.orgId;
 		if (!retain(String(organizationId))) return null;
-		const status = state.lifecycle?.status;
-		if (status === void 0) return null;
+		lastObserved = state;
+		const status = state.status;
 		return {
 			text: `${mode === "json" ? JSON.stringify({
 				type: "organization.lifecycle",
@@ -55558,6 +55355,7 @@ const makeOrganizationProgress = (mode, run, persist) => {
 		},
 		/** The committed ID this command observed, or null when it observed none. */
 		committed: () => committed,
+		lastObserved: () => lastObserved,
 		failure: () => failure,
 		flush: async () => {
 			while (queued.length > 0) {
@@ -55603,7 +55401,9 @@ const confirmWrite = (preview) => Effect.gen(function* () {
 */
 const organizationPreview = (client, organizationId, recovery, requestedHandle) => organizationId === null ? Effect.gen(function* () {
 	const organizations = yield* Effect.promise((signal) => client.orgs({ signal })).pipe(Effect.flatMap(resultValue));
+	const unfinished = yield* listUnfinishedSetups(client);
 	const lines = organizations.length === 0 ? ["Existing Organizations: none"] : [`Existing Organizations: ${organizations.length}`, ...organizations.map((organization) => `  ${JSON.stringify(String(organization.id))} ${JSON.stringify(organization.name)}`)];
+	lines.push(...unfinished.map((setup) => `Unfinished setup: ${JSON.stringify(String(setup.orgId))} (${setup.status})`));
 	if (recovery === null) return {
 		lines,
 		recovery,
@@ -55620,7 +55420,7 @@ const organizationPreview = (client, organizationId, recovery, requestedHandle)
 		recovery,
 		recoveryLifecycle: null
 	};
-	const lifecycle = yield* Effect.promise((signal) => client.org(exact).getLifecycle({ signal })).pipe(Effect.flatMap(resultValue));
+	const lifecycle = yield* Effect.promise((signal) => client.org(exact).setup.get({ signal })).pipe(Effect.flatMap(resultValue));
 	yield* requireCurrentAccess(client, exact, lifecycle);
 	return {
 		lines: [
@@ -55633,7 +55433,7 @@ const organizationPreview = (client, organizationId, recovery, requestedHandle)
 	};
 }) : Effect.gen(function* () {
 	return {
-		lines: [`Current lifecycle: ${(yield* Effect.promise((signal) => client.org(organizationId).getLifecycle({ signal })).pipe(Effect.flatMap(resultValue))).status}`],
+		lines: [`Current lifecycle: ${(yield* Effect.promise((signal) => client.org(organizationId).setup.get({ signal })).pipe(Effect.flatMap(resultValue))).status}`],
 		recovery,
 		recoveryLifecycle: null
 	};
@@ -55648,28 +55448,15 @@ const createOrganizationQuestion = (handle, preview) => {
 	return preview.recoveryLifecycle?.status === "ready" ? "Return this ready Organization?" : "Resume this Organization's setup?";
 };
 /**
-* Settle one exact Organization lifecycle read: poll every second with no
-* overlapping read until the lane is ready or failed. The command's own deadline
-* bounds this loop together with the write that preceded it.
-*/
-const settleOrganizationLifecycle = (read) => Effect.gen(function* () {
-	let lifecycle = yield* Effect.promise(read).pipe(Effect.flatMap(resultValue));
-	while (lifecycle.status !== "ready" && lifecycle.status !== "failed") {
-		yield* Effect.sleep(1e3);
-		lifecycle = yield* Effect.promise(read).pipe(Effect.flatMap(resultValue));
-	}
-	return lifecycle;
-});
-/**
 * Resume the exact durable Organization lane through the SDK recovery owner, then
 * settle that exact lifecycle. It never creates an Organization and never
 * resubmits a recorded bootstrap submission.
 */
-const resumeOrganizationSetup = (operation, scoped, deadline) => Effect.gen(function* () {
-	yield* Effect.promise(() => scoped.retrySetup({ signal: deadline.signal })).pipe(Effect.flatMap(resultValue));
-	const lifecycle = yield* settleOrganizationLifecycle(() => scoped.getLifecycle({ signal: deadline.signal }));
-	yield* requireReadyLifecycle(operation, lifecycle);
-	return lifecycle;
+const resumeOrganizationSetup = (scoped, deadline, observe) => Effect.gen(function* () {
+	const current = yield* Effect.promise(() => scoped.setup.get({ signal: deadline.signal })).pipe(Effect.flatMap(resultValue));
+	observe?.(current);
+	const updated = current.status === "awaitingAuthorization" ? yield* Effect.promise(() => scoped.setup.authorize({ signal: deadline.signal })).pipe(Effect.flatMap(resultValue)) : yield* Effect.promise(() => scoped.setup.resume({ signal: deadline.signal })).pipe(Effect.flatMap(resultValue));
+	return yield* observeOrganizationSetup(scoped, updated.orgId, updated, observe);
 });
 /**
 * A prepared handle owns the next durable Organization for that handle, so a
@@ -55691,28 +55478,19 @@ const preparedJourneyRefusal = (handle) => new CliFailure({
 * Organization reaches ready.
 */
 const readCreateRoute = (client, recovery, handle, signal) => Effect.gen(function* () {
-	if (recovery === null) return {
-		kind: "create",
-		continuesRecorded: false
-	};
+	if (recovery === null) return { kind: "create" };
 	if (recovery.organizationId === null) {
-		if (recovery.handle === handle) return {
-			kind: "create",
-			continuesRecorded: true
-		};
+		if (recovery.handle === handle) return { kind: "create" };
 		return yield* Effect.fail(preparedJourneyRefusal(recovery.handle));
 	}
-	const lifecycle = yield* Effect.promise(() => client.org(recovery.organizationId).getLifecycle({ signal })).pipe(Effect.flatMap(resultValue));
+	const lifecycle = yield* Effect.promise(() => client.org(recovery.organizationId).setup.get({ signal })).pipe(Effect.flatMap(resultValue));
 	if (recovery.handle === handle) return {
 		kind: "recover",
 		organizationId: recovery.organizationId,
 		handle: recovery.handle,
 		lifecycle
 	};
-	if (lifecycle.status === "ready") return {
-		kind: "create",
-		continuesRecorded: false
-	};
+	if (lifecycle.status === "ready") return { kind: "create" };
 	return yield* Effect.fail(Errors.wrongState({
 		method: CAPXUL_OPERATIONS.onboarding.completeOrganization,
 		currentState: lifecycle.status,
@@ -55740,12 +55518,26 @@ const organizationWriteDefect = () => new CliFailure({
 * command stops and the signer forwards nothing further, while the durable
 * backend lane keeps running and stays resumable by `org retry`.
 */
-const organizationWaitTimeout = () => new CliFailure({
-	code: "NETWORK_ERROR",
-	message: "The Organization did not settle within the command deadline.",
-	exitCode: 5,
-	outcome: "failed"
-});
+const organizationWaitTimeout = (organizationId, lastObserved) => {
+	const issue = lastObserved?.issue ?? lastObserved?.lastSendIssue;
+	return new CliFailure({
+		code: "CLI_DEADLINE",
+		message: lastObserved?.nextCheckAt != null && (lastObserved.status === "processing" || lastObserved.status === "rechecking" || lastObserved.status === "needsAttention") ? "Stopped waiting. Organization setup continues in the background." : "Stopped waiting. Read the Organization setup status.",
+		exitCode: 5,
+		outcome: "failed",
+		...issue?.error?.mode === void 0 ? {} : { mode: issue.error.mode },
+		details: {
+			...issue?.error === void 0 ? {} : allowlistedDetails(issue.error),
+			...organizationId === null ? {} : { organizationId },
+			...lastObserved === null ? {} : { lastObservedSetup: {
+				status: lastObserved.status,
+				nextCheckAt: lastObserved.nextCheckAt,
+				recovery: lastObserved.recovery
+			} },
+			...issue === null || issue === void 0 ? {} : { setupReason: issue.reason }
+		}
+	});
+};
 /**
 * The command-scoped browser signer for one Organization write.
 *
@@ -55767,6 +55559,23 @@ const organizationWaitTimeout = () => new CliFailure({
 const organizationWriteSigner = (config, opened, run, beforeSignature) => Effect.gen(function* () {
 	const runtime = yield* CliRuntime;
 	const invocation = yield* Ref.get(runtime.current);
+	const timed = async (stage, work) => {
+		const started = Date.now();
+		let outcome = "succeeded";
+		try {
+			return await work();
+		} catch (cause) {
+			outcome = "failed";
+			throw cause;
+		} finally {
+			await run(logEngineeringInfo("cli.signer.wait", {
+				signer_stage: stage,
+				duration_ms: Math.max(0, Date.now() - started),
+				outcome,
+				...invocation === null ? {} : { invocation_id: invocation.invocationId }
+			})).catch(() => void 0);
+		}
+	};
 	const listeners = /* @__PURE__ */ new Set();
 	let bridge = null;
 	let stopStatus = null;
@@ -55795,7 +55604,7 @@ const organizationWriteSigner = (config, opened, run, beforeSignature) => Effect
 	return (bootstrap) => {
 		return {
 			source: open(bootstrap).source,
-			getAddress: () => live(bootstrap).getAddress(),
+			getAddress: () => timed("address", () => live(bootstrap).getAddress()),
 			statusStore: {
 				status: () => bridge?.signer.statusStore?.status() ?? "unknown",
 				subscribe: (listener) => {
@@ -55805,7 +55614,7 @@ const organizationWriteSigner = (config, opened, run, beforeSignature) => Effect
 					};
 				}
 			},
-			ensureWalletReady: () => live(bootstrap).ensureWalletReady?.() ?? Promise.resolve(),
+			ensureWalletReady: () => timed("readiness", () => live(bootstrap).ensureWalletReady?.() ?? Promise.resolve()),
 			resetSession: () => {
 				const stopped = bridge;
 				stopStatus?.();
@@ -55816,29 +55625,40 @@ const organizationWriteSigner = (config, opened, run, beforeSignature) => Effect
 			},
 			async signUserOpHash(hash) {
 				await beforeSignature();
-				return live(bootstrap).signUserOpHash(hash);
+				return timed("sign", () => live(bootstrap).signUserOpHash(hash));
 			}
 		};
 	};
 });
 /** Cancellation is reported before any other work the interrupted write would do. */
 const cancelledWrite = (operation, signal) => signal?.aborted === true ? Errors.cancelled({ operation }) : null;
-/** The public onboarding result the CLI scopes every later read to. */
-const onboardingOrganizationId = (value) => Effect.try({
-	try: () => toOrgId(value),
-	catch: () => new CliFailure({
-		code: "PROVIDER_ERROR",
-		message: "The onboarding result did not carry an Organization ID.",
-		exitCode: 5,
-		outcome: "failed"
-	})
-});
 /** A write is successful only against a ready Organization. */
-const requireReadyLifecycle = (operation, lifecycle) => lifecycle.status === "ready" ? Effect.void : Effect.fail(Errors.wrongState({
-	method: operation,
-	currentState: lifecycle.status,
-	validStates: ["ready"]
-}));
+const requireReadyLifecycle = (operation, lifecycle) => {
+	if (lifecycle.status === "ready") return Effect.void;
+	const issue = lifecycle.issue;
+	if (issue?.error !== void 0) {
+		const error = issue.error;
+		return Effect.fail(new CapxulError(error.code, error.message, {
+			details: {
+				...error.details,
+				organizationId: String(lifecycle.orgId),
+				setupReason: issue.reason
+			},
+			...error.mode === void 0 ? {} : { mode: error.mode },
+			...error.chain === void 0 ? {} : { chain: error.chain }
+		}));
+	}
+	const fallback = Errors.wrongState({
+		method: operation,
+		currentState: lifecycle.status,
+		validStates: ["ready"],
+		organizationId: String(lifecycle.orgId)
+	});
+	return Effect.fail(new CapxulError(fallback.code, fallback.message, { details: {
+		...fallback.details,
+		...issue === null ? {} : { setupReason: issue.reason }
+	} }));
+};
 /**
 * Create one Organization through the public onboarding lane: confirm the exact
 * draft, subscribe to the committed Organization projection, complete with an
@@ -55894,12 +55714,9 @@ const createOrganization = (config, input) => Effect.gen(function* () {
 		openfortSignerFactory
 	});
 	const recovery = yield* openOrganizationRecovery(config, session.authUserId, stillAuthenticated);
-	const persistRecovery = (organizationId) => Effect.gen(function* () {
-		const committed = yield* onboardingOrganizationId(organizationId);
-		yield* recovery.save({
-			handle: draft.handle,
-			organizationId: committed
-		});
+	const persistRecovery = (organizationId) => recovery.save({
+		handle: draft.handle,
+		organizationId: toOrgId(organizationId)
 	});
 	const progress = makeOrganizationProgress(runtime.mode, run, (organizationId) => run(persistRecovery(organizationId)));
 	yield* Ref.set(progressRef, progress);
@@ -55916,7 +55733,6 @@ const createOrganization = (config, input) => Effect.gen(function* () {
 		if (route.kind === "recover") {
 			if (route.lifecycle.status === "ready") {
 				yield* requireCurrentAccess(client, route.organizationId, route.lifecycle);
-				progress.allowReady();
 				return {
 					organizationId: route.organizationId,
 					lifecycle: route.lifecycle
@@ -55924,9 +55740,12 @@ const createOrganization = (config, input) => Effect.gen(function* () {
 			}
 			progress.notice(recoveryNotice(runtime.mode, route));
 			yield* flushProgress;
-			const lifecycle = yield* resumeOrganizationSetup(operation, client.org(route.organizationId), deadline);
+			const lifecycle = yield* resumeOrganizationSetup(client.org(route.organizationId), deadline, progress.observe);
+			yield* flushProgress;
+			yield* requireReadyLifecycle(operation, lifecycle);
 			yield* requireCurrentAccess(client, route.organizationId, lifecycle);
 			progress.allowReady();
+			yield* flushProgress;
 			return {
 				organizationId: route.organizationId,
 				lifecycle
@@ -55936,24 +55755,25 @@ const createOrganization = (config, input) => Effect.gen(function* () {
 			handle: draft.handle,
 			organizationId: null
 		});
-		const unsubscribe = client.onboarding.subscribeOrganization(progress.observe);
-		const completed = yield* Effect.promise(() => client.onboarding.completeOrganization(draft, {
+		const begun = yield* Effect.promise(() => client.onboarding.beginOrganization(draft, {
 			intent: "create",
 			signal: deadline.signal
-		})).pipe(Effect.ensuring(Effect.sync(unsubscribe)));
-		if (!completed.ok) {
+		}));
+		if (!begun.ok) {
 			yield* flushProgress;
-			if (refusedOrganizationHandle(completed.error) && progress.committed() === null) yield* recovery.release();
-			return yield* Effect.fail(completed.error);
+			if (refusedOrganizationHandle(begun.error) && progress.committed() === null) yield* recovery.release();
+			return yield* Effect.fail(begun.error);
 		}
-		const onboarding = completed.value;
-		const organizationId = yield* onboardingOrganizationId(onboarding.organizationId);
+		const organizationId = begun.value.orgId;
 		progress.commit(String(organizationId));
+		progress.observe(begun.value.setup);
 		yield* flushProgress;
 		const scoped = client.org(organizationId);
-		const lifecycle = yield* settleOrganizationLifecycle(() => scoped.getLifecycle({ signal: deadline.signal }));
+		const started = begun.value.setup.status === "awaitingAuthorization" ? yield* Effect.promise(() => scoped.setup.authorize({ signal: deadline.signal })).pipe(Effect.flatMap(resultValue)) : begun.value.setup;
+		const lifecycle = yield* observeOrganizationSetup(scoped, organizationId, started, progress.observe);
+		yield* flushProgress;
 		yield* requireReadyLifecycle(operation, lifecycle);
-		if (route.continuesRecorded) yield* requireCurrentAccess(client, organizationId, lifecycle);
+		yield* requireCurrentAccess(client, organizationId, lifecycle);
 		progress.allowReady();
 		yield* flushProgress;
 		return {
@@ -55967,7 +55787,7 @@ const createOrganization = (config, input) => Effect.gen(function* () {
 			catch: (cause) => cause
 		}).pipe(Effect.catch(() => Effect.void));
 	}))).pipe(Effect.timeoutOption(timeout * 1e3));
-	if (Option.isNone(settled)) return yield* Effect.fail(organizationWaitTimeout());
+	if (Option.isNone(settled)) return yield* Effect.fail(organizationWaitTimeout(progress.committed(), progress.lastObserved()));
 	const { organizationId, lifecycle } = settled.value;
 	return {
 		data: {
@@ -56018,8 +55838,13 @@ const retryOrganization = (config, input) => Effect.gen(function* () {
 		openfortSignerFactory
 	});
 	const scoped = client.org(organizationId);
-	const settled = yield* resumeOrganizationSetup(operation, scoped, deadline).pipe(Effect.onInterrupt(() => Effect.sync(() => deadline.abort()))).pipe(Effect.timeoutOption(timeout * 1e3));
-	if (Option.isNone(settled)) return yield* Effect.fail(organizationWaitTimeout());
+	let lastObserved = null;
+	const settled = yield* resumeOrganizationSetup(scoped, deadline, (setup) => {
+		lastObserved = setup;
+	}).pipe(Effect.onInterrupt(() => Effect.sync(() => deadline.abort()))).pipe(Effect.timeoutOption(timeout * 1e3));
+	if (Option.isNone(settled)) return yield* Effect.fail(organizationWaitTimeout(String(organizationId), lastObserved));
+	yield* requireReadyLifecycle(operation, settled.value);
+	yield* requireCurrentAccess(client, organizationId, settled.value);
 	return {
 		data: {
 			organizationId,