@p4code/cli 0.0.52 → 0.1.0

package/dist/bin.mjs

@@ -233,7 +233,7 @@ const make$72 = () => {
 const layer$68 = Layer.sync(NetService, make$72);
 //#endregion
 //#region package.json
-var version = "0.0.52";
+var version = "0.1.0";
 //#endregion
 //#region src/config.ts
 /**
@@ -7734,6 +7734,47 @@ const AgentAssetDeleteInput = Schema$1.Struct({
 	expectedVersion: Schema$1.optional(PositiveInt)
 });
 /**
+* Create an asset on this machine's disk, and only there.
+*
+* The hub is not involved: a new skill starts as an unmanaged local file, the
+* same as one written by hand, and becomes shared only through an explicit
+* publish. That keeps "nothing uploads by accident" true for assets p4code
+* itself creates, and it means creation works on a machine with no hub
+* configured at all.
+*/
+const AgentAssetCreateLocalInput = Schema$1.Struct({
+	kind: AgentAssetKind,
+	name: AgentAssetName,
+	files: AgentAssetFiles
+});
+/**
+* What a local create or remove did, or why it did nothing.
+*
+* An enum rather than an error, because every branch is an ordinary answer a
+* panel has to render: `exists` and `missing` are races with the filesystem,
+* `managed` is the guard that keeps a hub-synced asset from being deleted
+* locally only to be re-materialized by the next sync pass, `refused` is a
+* policy answer (a skill without `SKILL.md`, a memory name outside the
+* allowlist, an MCP registration that belongs to `mcp.save`), `no-root` is an
+* unconfigured provider, and `failed` is a disk that would not take the write.
+*/
+const AgentAssetLocalMutationOutcome = Schema$1.Literals([
+	"created",
+	"removed",
+	"exists",
+	"missing",
+	"managed",
+	"refused",
+	"no-root",
+	"failed"
+]);
+const AgentAssetLocalMutation = Schema$1.Struct({
+	outcome: AgentAssetLocalMutationOutcome,
+	/** Absolute path of the created asset, so a panel can hand it to an agent. */
+	path: Schema$1.NullOr(Schema$1.String),
+	detail: Schema$1.NullOr(Schema$1.String)
+});
+/**
 * Changing the hub link failed.
 *
 * Only the link operations can fail. Syncing cannot: an unreachable hub, a
@@ -8153,6 +8194,8 @@ const WS_METHODS = {
 	assetsRead: "assets.read",
 	assetsSave: "assets.save",
 	assetsDelete: "assets.delete",
+	assetsCreateLocal: "assets.createLocal",
+	assetsRemoveLocal: "assets.removeLocal",
 	mcpList: "mcp.list",
 	mcpSave: "mcp.save",
 	mcpRemove: "mcp.remove",
@@ -8351,6 +8394,31 @@ const WsAssetsDeleteRpc = Rpc.make(WS_METHODS.assetsDelete, {
 	error: Schema$1.Union([EnvironmentAuthorizationError])
 });
 /**
+* Creating and removing assets on this machine only.
+*
+* These are the hub-free half of asset management: they write and delete the
+* local files directly, work on a server with no hub configured, and leave
+* sharing to the explicit publish. Removal refuses managed assets — deleting
+* only the local copy of a synced asset would just re-materialize on the next
+* pass, so the honest operations there are unpublish or `assets.delete`.
+*/
+const WsAssetsCreateLocalRpc = Rpc.make(WS_METHODS.assetsCreateLocal, {
+	payload: AgentAssetCreateLocalInput,
+	success: Schema$1.Struct({
+		result: AgentAssetLocalMutation,
+		status: AgentSyncStatus
+	}),
+	error: Schema$1.Union([EnvironmentAuthorizationError])
+});
+const WsAssetsRemoveLocalRpc = Rpc.make(WS_METHODS.assetsRemoveLocal, {
+	payload: AgentAssetRefInput,
+	success: Schema$1.Struct({
+		result: AgentAssetLocalMutation,
+		status: AgentSyncStatus
+	}),
+	error: Schema$1.Union([EnvironmentAuthorizationError])
+});
+/**
 * Registering the user's own MCP servers.
 *
 * Every one of these answers with the whole list, for the same reason the sync
@@ -8750,7 +8818,7 @@ const WsSubscribeAuthAccessRpc = Rpc.make(WS_METHODS.subscribeAuthAccess, {
 	error: Schema$1.Union([AuthAccessStreamError, EnvironmentAuthorizationError]),
 	stream: true
 });
-const WsRpcGroup = RpcGroup.make(WsServerProbeRpc, WsServerGetConfigRpc, WsServerRefreshProvidersRpc, WsServerUpdateProviderRpc, WsServerUpdateServerRpc, WsServerUpsertKeybindingRpc, WsServerRemoveKeybindingRpc, WsServerGetSettingsRpc, WsServerUpdateSettingsRpc, WsServerDiscoverSourceControlRpc, WsServerGetTraceDiagnosticsRpc, WsServerGetProcessDiagnosticsRpc, WsServerGetProcessResourceHistoryRpc, WsServerSignalProcessRpc, WsSourceControlLookupRepositoryRpc, WsSourceControlCloneRepositoryRpc, WsSourceControlPublishRepositoryRpc, WsProjectsListEntriesRpc, WsProjectsReadFileRpc, WsProjectsSearchEntriesRpc, WsProjectsWriteFileRpc, WsShellOpenInEditorRpc, WsFilesystemBrowseRpc, WsAssetsCreateUrlRpc, WsSubscribeVcsStatusRpc, WsVcsPullRpc, WsVcsRefreshStatusRpc, WsGitRunStackedActionRpc, WsGitResolvePullRequestRpc, WsGitPreparePullRequestThreadRpc, WsVcsListRefsRpc, WsVcsCreateWorktreeRpc, WsVcsRemoveWorktreeRpc, WsVcsCreateRefRpc, WsVcsSwitchRefRpc, WsVcsInitRpc, WsReviewGetDiffPreviewRpc, WsTerminalOpenRpc, WsTerminalAttachRpc, WsTerminalWriteRpc, WsTerminalResizeRpc, WsTerminalClearRpc, WsTerminalRestartRpc, WsTerminalCloseRpc, WsSubscribeTerminalEventsRpc, WsSubscribeTerminalMetadataRpc, WsPreviewOpenRpc, WsPreviewNavigateRpc, WsPreviewResizeRpc, WsPreviewRefreshRpc, WsPreviewCloseRpc, WsPreviewListRpc, WsPreviewReportStatusRpc, WsPreviewAutomationConnectRpc, WsPreviewAutomationRespondRpc, WsPreviewAutomationFocusHostRpc, WsSubscribePreviewEventsRpc, WsSubscribeDiscoveredLocalServersRpc, WsSubscribeServerConfigRpc, WsSubscribeServerLifecycleRpc, WsSubscribeAuthAccessRpc, WsTasksListRpc, WsTasksGetRpc, WsTasksCreateRpc, WsTasksUpdateRpc, WsTasksDeleteRpc, WsTasksStartThreadRpc, WsSubscribeTasksRpc, WsHubGetSyncStatusRpc, WsHubConnectRpc, WsHubDisconnectRpc, WsHubSetSyncModeRpc, WsHubSetShareModeRpc, WsHubMintTokenRpc, WsSkillsSyncRpc, WsSkillsPublishRpc, WsSkillsPublishAllRpc, WsSkillsUnpublishRpc, WsAssetsReadRpc, WsAssetsSaveRpc, WsAssetsDeleteRpc, WsMcpListRpc, WsMcpSaveRpc, WsMcpRemoveRpc, WsMcpSetSecretRpc, WsOrchestrationDispatchCommandRpc, WsOrchestrationGetTurnDiffRpc, WsOrchestrationGetFullThreadDiffRpc, WsOrchestrationGetArchivedShellSnapshotRpc, WsOrchestrationSubscribeShellRpc, WsOrchestrationSubscribeThreadRpc);
+const WsRpcGroup = RpcGroup.make(WsServerProbeRpc, WsServerGetConfigRpc, WsServerRefreshProvidersRpc, WsServerUpdateProviderRpc, WsServerUpdateServerRpc, WsServerUpsertKeybindingRpc, WsServerRemoveKeybindingRpc, WsServerGetSettingsRpc, WsServerUpdateSettingsRpc, WsServerDiscoverSourceControlRpc, WsServerGetTraceDiagnosticsRpc, WsServerGetProcessDiagnosticsRpc, WsServerGetProcessResourceHistoryRpc, WsServerSignalProcessRpc, WsSourceControlLookupRepositoryRpc, WsSourceControlCloneRepositoryRpc, WsSourceControlPublishRepositoryRpc, WsProjectsListEntriesRpc, WsProjectsReadFileRpc, WsProjectsSearchEntriesRpc, WsProjectsWriteFileRpc, WsShellOpenInEditorRpc, WsFilesystemBrowseRpc, WsAssetsCreateUrlRpc, WsSubscribeVcsStatusRpc, WsVcsPullRpc, WsVcsRefreshStatusRpc, WsGitRunStackedActionRpc, WsGitResolvePullRequestRpc, WsGitPreparePullRequestThreadRpc, WsVcsListRefsRpc, WsVcsCreateWorktreeRpc, WsVcsRemoveWorktreeRpc, WsVcsCreateRefRpc, WsVcsSwitchRefRpc, WsVcsInitRpc, WsReviewGetDiffPreviewRpc, WsTerminalOpenRpc, WsTerminalAttachRpc, WsTerminalWriteRpc, WsTerminalResizeRpc, WsTerminalClearRpc, WsTerminalRestartRpc, WsTerminalCloseRpc, WsSubscribeTerminalEventsRpc, WsSubscribeTerminalMetadataRpc, WsPreviewOpenRpc, WsPreviewNavigateRpc, WsPreviewResizeRpc, WsPreviewRefreshRpc, WsPreviewCloseRpc, WsPreviewListRpc, WsPreviewReportStatusRpc, WsPreviewAutomationConnectRpc, WsPreviewAutomationRespondRpc, WsPreviewAutomationFocusHostRpc, WsSubscribePreviewEventsRpc, WsSubscribeDiscoveredLocalServersRpc, WsSubscribeServerConfigRpc, WsSubscribeServerLifecycleRpc, WsSubscribeAuthAccessRpc, WsTasksListRpc, WsTasksGetRpc, WsTasksCreateRpc, WsTasksUpdateRpc, WsTasksDeleteRpc, WsTasksStartThreadRpc, WsSubscribeTasksRpc, WsHubGetSyncStatusRpc, WsHubConnectRpc, WsHubDisconnectRpc, WsHubSetSyncModeRpc, WsHubSetShareModeRpc, WsHubMintTokenRpc, WsSkillsSyncRpc, WsSkillsPublishRpc, WsSkillsPublishAllRpc, WsSkillsUnpublishRpc, WsAssetsReadRpc, WsAssetsSaveRpc, WsAssetsDeleteRpc, WsAssetsCreateLocalRpc, WsAssetsRemoveLocalRpc, WsMcpListRpc, WsMcpSaveRpc, WsMcpRemoveRpc, WsMcpSetSecretRpc, WsOrchestrationDispatchCommandRpc, WsOrchestrationGetTurnDiffRpc, WsOrchestrationGetFullThreadDiffRpc, WsOrchestrationGetArchivedShellSnapshotRpc, WsOrchestrationSubscribeShellRpc, WsOrchestrationSubscribeThreadRpc);
 //#endregion
 //#region ../../packages/shared/src/oauthScope.ts
 const OAUTH_SCOPE_TOKEN = /^[\u0021\u0023-\u005b\u005d-\u007e]+$/u;
@@ -15593,6 +15661,48 @@ const writeSkillManifest = Effect.fn("skillManifest.write")(function* (manifestP
 	});
 });
 //#endregion
+//#region src/sync/localAssetOps.ts
+const refuse = (outcome, detail) => ({
+	_tag: "refuse",
+	outcome,
+	detail
+});
+const PROCEED = { _tag: "proceed" };
+/**
+* May this asset be created here?
+*
+* - MCP registrations have their own write path (`mcp.save`), which is where
+*   the definition/secret split is enforced. Creating one as a bare file would
+*   bypass the decode-before-write rule, so it is refused rather than routed.
+* - A skill without `SKILL.md` would be invisible to discovery: the picker
+*   skips directories without one, so the create would look like it silently
+*   failed. Refused with the reason instead.
+* - An existing local name is never overwritten. Create means create; editing
+*   is a different operation with a different surface.
+*/
+function decideCreateLocal(input) {
+	if (input.asset.kind === "mcp") return refuse("refused", "MCP registrations are created through mcp.save, not as files.");
+	if (input.asset.kind === "skill" && !input.asset.files.some((file) => file.path === "SKILL.md")) return refuse("refused", "A skill needs a SKILL.md at its root; without one, discovery skips the directory.");
+	if (input.localNames.has(input.asset.name)) return refuse("exists", `An asset named '${input.asset.name}' already exists locally.`);
+	return PROCEED;
+}
+/**
+* May this asset be removed from this machine?
+*
+* The managed refusal is the load-bearing one. A managed asset is a hub-synced
+* asset, and the sync plan's answer to "managed and missing locally" is to
+* re-materialize it - so a local-only delete would quietly undo itself on the
+* next pass. The honest operations for a managed asset are unpublish (keep it
+* here, stop sharing) or a hub delete (remove it everywhere), and the refusal
+* detail names both.
+*/
+function decideRemoveLocal(input) {
+	if (input.ref.kind === "mcp") return refuse("refused", "MCP registrations are removed through mcp.remove, not as files.");
+	if (input.managedNames.has(input.ref.name)) return refuse("managed", `'${input.ref.name}' is synced with the hub; deleting it here would be undone by the next sync. Unpublish it to keep sharing off this machine, or delete it from the hub to remove it everywhere.`);
+	if (!input.localNames.has(input.ref.name)) return refuse("missing", `No local asset named '${input.ref.name}' exists.`);
+	return PROCEED;
+}
+//#endregion
 //#region src/sync/skillSyncPlan.ts
 /**
 * Deciding what a skill sync should do, given three views of the world.
@@ -16362,6 +16472,85 @@ const make$58 = Effect.gen(function* () {
 		};
 		return yield* run;
 	}).pipe(Effect.provide(services), Effect.catchCause((cause) => Effect.logWarning("asset delete failed", { cause }).pipe(Effect.as(EMPTY_REPORT))));
+	const FAILED_MUTATION = {
+		outcome: "failed",
+		path: null,
+		detail: "The write failed; see the server log."
+	};
+	const createLocal = (input) => Effect.gen(function* () {
+		const driver = driverFor(input.kind);
+		if (driver === void 0) return {
+			outcome: "refused",
+			path: null,
+			detail: `Unknown asset kind '${input.kind}'.`
+		};
+		const root = yield* driver.resolveRoot;
+		if (root === null) return {
+			outcome: "no-root",
+			path: null,
+			detail: "This asset kind has no home here - the provider is not configured."
+		};
+		const local = yield* driver.read(root);
+		const decision = decideCreateLocal({
+			asset: input,
+			localNames: new Set(local.skills.map((skill) => skill.name))
+		});
+		if (decision._tag === "refuse") return {
+			outcome: decision.outcome,
+			path: null,
+			detail: decision.detail
+		};
+		const written = yield* driver.write({
+			root,
+			name: input.name,
+			files: input.files
+		});
+		if (written !== "written") return {
+			outcome: written,
+			path: null,
+			detail: written === "refused" ? "This kind does not accept that name here." : "The disk would not take the write."
+		};
+		return {
+			outcome: "created",
+			path: path.join(root, input.name),
+			detail: null
+		};
+	}).pipe(Effect.provide(services), Effect.catchCause((cause) => Effect.logWarning("asset create-local failed", { cause }).pipe(Effect.as(FAILED_MUTATION))));
+	const removeLocal = (ref) => Effect.gen(function* () {
+		const driver = driverFor(ref.kind);
+		if (driver === void 0) return {
+			outcome: "refused",
+			path: null,
+			detail: `Unknown asset kind '${ref.kind}'.`
+		};
+		const root = yield* driver.resolveRoot;
+		if (root === null) return {
+			outcome: "no-root",
+			path: null,
+			detail: "This asset kind has no home here - the provider is not configured."
+		};
+		const local = yield* driver.read(root);
+		const manifest = yield* readSkillManifest(manifestPath);
+		const decision = decideRemoveLocal({
+			ref,
+			localNames: new Set(local.skills.map((skill) => skill.name)),
+			managedNames: new Set(entriesFor(manifest, root).map((entry) => entry.name))
+		});
+		if (decision._tag === "refuse") return {
+			outcome: decision.outcome,
+			path: null,
+			detail: decision.detail
+		};
+		yield* driver.remove({
+			root,
+			name: ref.name
+		});
+		return {
+			outcome: "removed",
+			path: null,
+			detail: null
+		};
+	}).pipe(Effect.provide(services), Effect.catchCause((cause) => Effect.logWarning("asset remove-local failed", { cause }).pipe(Effect.as(FAILED_MUTATION))));
 	return {
 		run,
 		status: assetStatus,
@@ -16370,7 +16559,9 @@ const make$58 = Effect.gen(function* () {
 		unpublish,
 		read,
 		save,
-		deleteFromHub
+		deleteFromHub,
+		createLocal,
+		removeLocal
 	};
 });
 const layer$53 = Layer.effect(AssetSync, make$58);
@@ -41128,6 +41319,8 @@ const RPC_REQUIRED_SCOPE = /* @__PURE__ */ new Map([
 	[WS_METHODS.assetsRead, AuthOrchestrationReadScope],
 	[WS_METHODS.assetsSave, AuthOrchestrationOperateScope],
 	[WS_METHODS.assetsDelete, AuthOrchestrationOperateScope],
+	[WS_METHODS.assetsCreateLocal, AuthOrchestrationOperateScope],
+	[WS_METHODS.assetsRemoveLocal, AuthOrchestrationOperateScope],
 	[WS_METHODS.mcpList, AuthOrchestrationReadScope],
 	[WS_METHODS.mcpSave, AuthOrchestrationOperateScope],
 	[WS_METHODS.mcpRemove, AuthOrchestrationOperateScope],
@@ -41812,6 +42005,18 @@ const makeWsRpcLayer = (currentSession, previewAutomationBroker) => WsRpcGroup.t
 				status: yield* assetSync.status
 			};
 		}), { "rpc.aggregate": "skills" }),
+		[WS_METHODS.assetsCreateLocal]: (input) => observeRpcEffect$1(WS_METHODS.assetsCreateLocal, Effect.gen(function* () {
+			return {
+				result: yield* assetSync.createLocal(input),
+				status: yield* assetSync.status
+			};
+		}), { "rpc.aggregate": "skills" }),
+		[WS_METHODS.assetsRemoveLocal]: (input) => observeRpcEffect$1(WS_METHODS.assetsRemoveLocal, Effect.gen(function* () {
+			return {
+				result: yield* assetSync.removeLocal(input),
+				status: yield* assetSync.status
+			};
+		}), { "rpc.aggregate": "skills" }),
 		[WS_METHODS.mcpList]: (_input) => observeRpcEffect$1(WS_METHODS.mcpList, mcpRegistry.list.pipe(Effect.map((servers) => ({ servers }))), { "rpc.aggregate": "mcp" }),
 		[WS_METHODS.mcpSave]: ({ registration }) => observeRpcEffect$1(WS_METHODS.mcpSave, mcpRegistry.save(registration).pipe(Effect.andThen(mcpRegistry.list.pipe(Effect.map((servers) => ({ servers }))))), { "rpc.aggregate": "mcp" }),
 		[WS_METHODS.mcpRemove]: ({ name }) => observeRpcEffect$1(WS_METHODS.mcpRemove, mcpRegistry.remove(name).pipe(Effect.andThen(mcpRegistry.list.pipe(Effect.map((servers) => ({ servers }))))), { "rpc.aggregate": "mcp" }),
@@ -46643,6 +46848,80 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 		};
 		yield* updateResumeCursor(context);
 	});
+	const applyTurnSessionOptions = Effect.fn("applyTurnSessionOptions")(function* (context, modelSelection, interactionMode) {
+		if (modelSelection?.model) {
+			const apiModelId = resolveClaudeApiModelId(modelSelection);
+			if (context.currentApiModelId !== apiModelId) {
+				yield* Effect.tryPromise({
+					try: () => context.query.setModel(apiModelId),
+					catch: (cause) => toRequestError$1(context.session.threadId, "turn/setModel", cause)
+				});
+				context.currentApiModelId = apiModelId;
+			}
+			context.session = {
+				...context.session,
+				model: modelSelection.model
+			};
+		}
+		if (interactionMode === "plan") yield* Effect.tryPromise({
+			try: () => context.query.setPermissionMode("plan"),
+			catch: (cause) => toRequestError$1(context.session.threadId, "turn/setPermissionMode", cause)
+		});
+		else if (interactionMode === "default") yield* Effect.tryPromise({
+			try: () => context.query.setPermissionMode(context.basePermissionMode ?? "default"),
+			catch: (cause) => toRequestError$1(context.session.threadId, "turn/setPermissionMode", cause)
+		});
+	});
+	const beginTurn = Effect.fn("beginTurn")(function* (context, turnId, model) {
+		const turnState = {
+			turnId,
+			startedAt: yield* nowIso,
+			items: [],
+			assistantTextBlocks: /* @__PURE__ */ new Map(),
+			assistantTextBlockOrder: [],
+			capturedProposedPlanKeys: /* @__PURE__ */ new Set(),
+			nextSyntheticAssistantBlockIndex: -1
+		};
+		const updatedAt = yield* nowIso;
+		context.turnState = turnState;
+		context.session = {
+			...context.session,
+			status: "running",
+			activeTurnId: turnId,
+			updatedAt
+		};
+		const turnStartedStamp = yield* makeEventStamp();
+		yield* offerRuntimeEvent({
+			type: "turn.started",
+			eventId: turnStartedStamp.eventId,
+			provider: PROVIDER$5,
+			createdAt: turnStartedStamp.createdAt,
+			threadId: context.session.threadId,
+			turnId,
+			payload: model ? { model } : {},
+			providerRefs: {}
+		});
+	});
+	/**
+	* Start the next queued sendTurn, if the session has gone idle.
+	*
+	* Runs after every turn completion. A message sent during a running turn
+	* waits here for the agent loop to end; pressing Stop ends the loop early,
+	* and the same drain is what makes Stop mean "and run my message now".
+	* One request per drain, so each queued message gets its own turn boundary -
+	* the next one starts when this turn's result arrives.
+	*/
+	const drainPendingTurns = Effect.fn("drainPendingTurns")(function* (context) {
+		if (context.stopped || context.turnState !== void 0) return;
+		const pending = context.pendingTurnRequests.shift();
+		if (pending === void 0) return;
+		yield* applyTurnSessionOptions(context, pending.modelSelection, pending.interactionMode).pipe(Effect.catchCause((cause) => Effect.logWarning("claude pending turn session options failed", { cause })));
+		yield* beginTurn(context, pending.turnId, pending.modelSelection?.model);
+		yield* Queue.offer(context.promptQueue, {
+			type: "message",
+			message: pending.message
+		}).pipe(Effect.ignore);
+	});
 	const handleStreamEvent = Effect.fn("handleStreamEvent")(function* (context, message) {
 		if (message.type !== "stream_event") return;
 		const { event } = message;
@@ -46978,6 +47257,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 		const errorMessage = message.subtype === "success" ? void 0 : message.errors[0];
 		if (status === "failed") yield* emitRuntimeError(context, errorMessage ?? "Claude turn failed.");
 		yield* completeTurn(context, status, errorMessage, message);
+		yield* drainPendingTurns(context);
 	});
 	const handleSystemMessage = Effect.fn("handleSystemMessage")(function* (context, message) {
 		if (message.type !== "system") return;
@@ -47718,6 +47998,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 			inFlightTools,
 			claudeTasks,
 			turnState: void 0,
+			pendingTurnRequests: [],
 			lastKnownContextWindow: initialContextWindow,
 			lastKnownTokenUsage: void 0,
 			lastKnownTotalProcessedTokens: void 0,
@@ -47778,66 +48059,29 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 	const sendTurn = Effect.fn("sendTurn")(function* (input) {
 		const context = yield* requireSession(input.threadId);
 		const modelSelection = input.modelSelection !== void 0 && input.modelSelection.instanceId === boundInstanceId ? input.modelSelection : void 0;
-		const steeringTurnState = context.turnState && context.turnState.synthetic !== true ? context.turnState : null;
-		if (context.turnState && steeringTurnState === null) yield* completeTurn(context, "completed");
-		if (modelSelection?.model) {
-			const apiModelId = resolveClaudeApiModelId(modelSelection);
-			if (context.currentApiModelId !== apiModelId) {
-				yield* Effect.tryPromise({
-					try: () => context.query.setModel(apiModelId),
-					catch: (cause) => toRequestError$1(input.threadId, "turn/setModel", cause)
-				});
-				context.currentApiModelId = apiModelId;
-			}
-			context.session = {
-				...context.session,
-				model: modelSelection.model
-			};
-		}
-		if (input.interactionMode === "plan") yield* Effect.tryPromise({
-			try: () => context.query.setPermissionMode("plan"),
-			catch: (cause) => toRequestError$1(input.threadId, "turn/setPermissionMode", cause)
-		});
-		else if (input.interactionMode === "default") yield* Effect.tryPromise({
-			try: () => context.query.setPermissionMode(context.basePermissionMode ?? "default"),
-			catch: (cause) => toRequestError$1(input.threadId, "turn/setPermissionMode", cause)
-		});
-		const turnId = steeringTurnState?.turnId ?? TurnId.make(yield* randomUUIDv4);
-		if (steeringTurnState === null) {
-			const turnState = {
-				turnId,
-				startedAt: yield* nowIso,
-				items: [],
-				assistantTextBlocks: /* @__PURE__ */ new Map(),
-				assistantTextBlockOrder: [],
-				capturedProposedPlanKeys: /* @__PURE__ */ new Set(),
-				nextSyntheticAssistantBlockIndex: -1
-			};
-			const updatedAt = yield* nowIso;
-			context.turnState = turnState;
-			context.session = {
-				...context.session,
-				status: "running",
-				activeTurnId: turnId,
-				updatedAt
-			};
-			const turnStartedStamp = yield* makeEventStamp();
-			yield* offerRuntimeEvent({
-				type: "turn.started",
-				eventId: turnStartedStamp.eventId,
-				provider: PROVIDER$5,
-				createdAt: turnStartedStamp.createdAt,
-				threadId: context.session.threadId,
-				turnId,
-				payload: modelSelection?.model ? { model: modelSelection.model } : {},
-				providerRefs: {}
-			});
-		}
+		if (context.turnState?.synthetic === true) yield* completeTurn(context, "completed");
 		const message = yield* buildUserMessageEffect(input, {
 			fileSystem,
 			attachmentsDir: serverConfig.attachmentsDir,
 			boundInstanceId
 		});
+		if (context.turnState) {
+			const turnId = TurnId.make(yield* randomUUIDv4);
+			context.pendingTurnRequests.push({
+				turnId,
+				message,
+				modelSelection,
+				interactionMode: input.interactionMode
+			});
+			return {
+				threadId: context.session.threadId,
+				turnId,
+				...context.session.resumeCursor !== void 0 ? { resumeCursor: context.session.resumeCursor } : {}
+			};
+		}
+		yield* applyTurnSessionOptions(context, modelSelection, input.interactionMode);
+		const turnId = TurnId.make(yield* randomUUIDv4);
+		yield* beginTurn(context, turnId, modelSelection?.model);
 		yield* Queue.offer(context.promptQueue, {
 			type: "message",
 			message
@@ -82405,6 +82649,15 @@ const make$1 = Effect.gen(function* () {
 			}).pipe(Effect.catch(() => Effect.void));
 			return;
 		}
+		if ((yield* providerService.listSessions()).find((session) => session.threadId !== event.payload.threadId && session.cwd === sessionRuntime.value.cwd)) {
+			yield* appendRevertFailureActivity({
+				threadId: event.payload.threadId,
+				turnCount: event.payload.turnCount,
+				detail: "Another active thread is working in the same directory; reverting would overwrite or delete its uncommitted work. Settle or stop that thread first.",
+				createdAt: now
+			}).pipe(Effect.catch(() => Effect.void));
+			return;
+		}
 		const currentTurnCount = thread.checkpoints.reduce((maxTurnCount, checkpoint) => Math.max(maxTurnCount, checkpoint.checkpointTurnCount), 0);
 		if (event.payload.turnCount > currentTurnCount) {
 			yield* appendRevertFailureActivity({