@p4code/cli 0.1.38 → 0.1.40

package/dist/bin.mjs

@@ -236,7 +236,7 @@ const make$76 = () => {
 const layer$72 = Layer.sync(NetService, make$76);
 //#endregion
 //#region package.json
-var version = "0.1.38";
+var version = "0.1.40";
 //#endregion
 //#region src/config.ts
 /**
@@ -19251,6 +19251,8 @@ No self-reference. Never name or announce the style. No compressed answer plus n
 
 ## Auto-Clarity
 
+Warnings are substance, never fluff. A destructive or irreversible request (deleting data, prod mutations, force-push, secret exposure) always gets the uncompressed warning block, even when the user tells you to skip it. The warning is complete sentences from its heading to its last word; compression never decides whether it appears.
+
 Drop compression and write normally when:
 - Security warnings
 - Irreversible action confirmations
@@ -24232,7 +24234,16 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti
 				return;
 			}
 			case "thread.turn-interrupt-requested": {
-				if (event.payload.turnId === void 0) return;
+				if (event.payload.turnId === void 0) {
+					const threadTurns = yield* projectionTurnRepository.listByThreadId({ threadId: event.payload.threadId });
+					yield* Effect.forEach(threadTurns.filter((turn) => turn.turnId !== null && turn.state === "running"), (turn) => turn.turnId === null ? Effect.void : projectionTurnRepository.upsertByTurnId({
+						...turn,
+						turnId: turn.turnId,
+						state: "interrupted",
+						completedAt: turn.completedAt ?? event.payload.createdAt
+					}), { concurrency: 1 });
+					return;
+				}
 				const existingTurn = yield* projectionTurnRepository.getByTurnId({
 					threadId: event.payload.threadId,
 					turnId: event.payload.turnId
@@ -24282,7 +24293,7 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti
 					yield* projectionTurnRepository.upsertByTurnId({
 						...existingTurn.value,
 						assistantMessageId: event.payload.assistantMessageId,
-						state: turnStillRunning ? existingTurn.value.state : nextState,
+						state: turnStillRunning ? existingTurn.value.state : existingTurn.value.state === "interrupted" ? "interrupted" : nextState,
 						checkpointTurnCount: event.payload.checkpointTurnCount,
 						checkpointRef: event.payload.checkpointRef,
 						checkpointStatus: event.payload.status,
@@ -32264,6 +32275,12 @@ const staticAndDevRouteLayer = HttpRouter.add("GET", "*", Effect.gen(function* (
 		contentType
 	});
 }));
+//#endregion
+//#region src/provider/Services/ProviderService.ts
+/**
+* ProviderService - Service tag for provider orchestration.
+*/
+var ProviderService = class extends Context.Service()("@p4code/cli/provider/Services/ProviderService") {};
 (() => {
 	try {
 		return process.env.NODE_ENV === "development";
@@ -32798,25 +32815,6 @@ function createContentGroup(type, deletionLineIndex, additionLineIndex) {
 }
 //#endregion
 //#region src/checkpointing/ThreadChangedFiles.ts
-/**
-* Per-thread changed-file attribution for checkpoint diffs.
-*
-* A checkpoint snapshots the whole working tree (`git add -A`), so on a shared
-* worktree the diff between two of a thread's checkpoints also contains every
-* edit other threads made in the window. The thread's own tool activities are
-* per-thread by construction, and the inline changed-files summary the clients
-* derive from them is already the surface users trust. These helpers extract
-* that same path list on the server and cut a checkpoint diff down to it.
-*
-* `collectActivityChangedFilePaths` must stay in lockstep with
-* `collectChangedFiles` in `apps/web/src/session-logic.ts` (and the mobile
-* copy in `threadActivity.ts`): same field names, same nested keys, same depth
-* bound. The one deliberate difference is dropping the cap of 12 paths - that
-* cap exists for display, and a filter that stopped collecting would silently
-* drop real work from the diff.
-*
-* @module ThreadChangedFiles
-*/
 const CHANGED_FILE_FIELDS = [
 	"path",
 	"filePath",
@@ -32885,6 +32883,16 @@ function normalizeChangedFilePaths(changedPaths, workspaceCwd) {
 	}
 	return normalized;
 }
+/**
+* Whether another thread's live session is bound to the same workspace
+* directory. This is the shared-worktree signal: a thread whose activities
+* name no paths keeps its unfiltered diff only while it is alone in the
+* directory, because with a concurrent neighbour the unfiltered tree diff
+* would present the neighbour's edits as this thread's own.
+*/
+function otherSessionSharesWorkspace(sessions, threadId, workspaceCwd) {
+	return sessions.some((session) => session.threadId !== threadId && session.cwd === workspaceCwd);
+}
 const DIFF_FILE_HEADER = /^diff --git /gm;
 function splitUnifiedDiffBlocks(diff) {
 	const starts = [];
@@ -35517,6 +35525,7 @@ const make$40 = Effect.gen(function* () {
 	const projectionSnapshotQuery = yield* ProjectionSnapshotQuery;
 	const checkpointStore = yield* CheckpointStore;
 	const threadActivities = yield* ProjectionThreadActivityRepository;
+	const providerService = yield* ProviderService;
 	/**
 	* The file paths this thread's own tool activities name, optionally limited
 	* to a set of turns. This is the attribution a checkpoint cannot provide: a
@@ -35535,13 +35544,17 @@ const make$40 = Effect.gen(function* () {
 		return changedPaths;
 	});
 	/**
-	* A thread whose activities name no paths at all gets the unfiltered diff.
-	* That is the deliberate escape valve: a thread working purely through shell
-	* commands never names the files it touched, and erasing its whole diff
-	* would be worse than the shared-worktree contamination this filter exists
-	* to remove.
+	* A thread whose activities name no paths at all (shell-only work) keeps
+	* the unfiltered diff only while no other live session shares the
+	* directory. Alone, the whole tree diff is the thread's own work and
+	* erasing it would lose real changes; with a concurrent neighbour the same
+	* diff presents the neighbour's edits as this thread's, so it is
+	* suppressed instead.
 	*/
-	const attributeDiffToThread = (diff, changedPaths, workspaceCwd) => changedPaths.size === 0 ? diff : filterUnifiedDiffToChangedFiles(diff, changedPaths, workspaceCwd);
+	const attributeDiffToThread = Effect.fn("CheckpointDiffQuery.attributeDiffToThread")(function* (threadId, diff, changedPaths, workspaceCwd) {
+		if (changedPaths.size > 0) return filterUnifiedDiffToChangedFiles(diff, changedPaths, workspaceCwd);
+		return otherSessionSharesWorkspace(yield* providerService.listSessions(), threadId, workspaceCwd) ? "" : diff;
+	});
 	const getTurnDiff = Effect.fn("getTurnDiff")(function* (input) {
 		const operation = "CheckpointDiffQuery.getTurnDiff";
 		const ignoreWhitespace = input.ignoreWhitespace ?? true;
@@ -35604,7 +35617,7 @@ const make$40 = Effect.gen(function* () {
 		}).pipe(Effect.withSpan("checkpoint.turnDiff.diffCheckpoints"));
 		const turnIdsInRange = new Set(threadContext.value.checkpoints.filter((checkpoint) => checkpoint.checkpointTurnCount > input.fromTurnCount && checkpoint.checkpointTurnCount <= input.toTurnCount).map((checkpoint) => checkpoint.turnId));
 		const changedPaths = yield* collectThreadChangedFilePaths(input.threadId, turnIdsInRange);
-		const turnDiff = buildTurnDiffResult(input, attributeDiffToThread(diff, changedPaths, workspaceCwd));
+		const turnDiff = buildTurnDiffResult(input, yield* attributeDiffToThread(input.threadId, diff, changedPaths, workspaceCwd));
 		if (!isTurnDiffResult(turnDiff)) return yield* new CheckpointDiffResultInvalidError({
 			operation,
 			threadId: input.threadId
@@ -35667,7 +35680,7 @@ const make$40 = Effect.gen(function* () {
 			threadId: input.threadId,
 			fromTurnCount: 0,
 			toTurnCount: input.toTurnCount
-		}, attributeDiffToThread(diff, changedPaths, workspaceCwd));
+		}, yield* attributeDiffToThread(input.threadId, diff, changedPaths, workspaceCwd));
 		if (!isTurnDiffResult(turnDiff)) return yield* new CheckpointDiffResultInvalidError({
 			operation,
 			threadId: input.threadId
@@ -49392,12 +49405,6 @@ const ProviderEventLoggersLive = Layer.effect(ProviderEventLoggers, Effect.gen(f
 	};
 }));
 //#endregion
-//#region src/provider/Services/ProviderService.ts
-/**
-* ProviderService - Service tag for provider orchestration.
-*/
-var ProviderService = class extends Context.Service()("@p4code/cli/provider/Services/ProviderService") {};
-//#endregion
 //#region src/mcp/McpProviderSession.ts
 /**
 * The name p4code declares its own toolkit under, in every provider.
@@ -52299,6 +52306,37 @@ function formatAskUserQuestionAnswers(answers) {
 	return formatted;
 }
 //#endregion
+//#region src/provider/Layers/ClaudePromptAppends.ts
+/**
+* Setting-driven system prompt appends for the Claude adapter.
+*
+* Kept out of `ClaudeAdapter.ts` so their regression evals
+* (`ClaudePromptAppends.evals.ts`) and any future prompt constant of the same
+* shape can import the text without dragging in the adapter's whole module
+* graph. The join point is `ClaudeAdapter.ts`, which appends these to the
+* claude_code preset system prompt per setting.
+*/
+/**
+* Appended to the preset system prompt when `narrateBeforeTools` is on. The SDK
+* preset drops the interactive CLI's terminal-tone sections, so without this the
+* model opens a turn with a tool call rather than a line saying what it is doing.
+*/
+const NARRATE_BEFORE_TOOLS_PROMPT = "Before your first tool call in a turn, write one short sentence saying what you are about to do. Keep it to a single line and skip it when you are answering without tools.";
+/**
+* Said whichever way the setting is set, and said as an override.
+*
+* The preset system prompt this adapter requests already carries an
+* instruction not to spawn subagents unless the user asked — and a preset is
+* taken wholesale, so there is no version of it with that line removed. An
+* append that merely stayed silent when subagents are allowed would therefore
+* leave the restriction standing, which is the one outcome the setting exists
+* to change. Both texts name the earlier instruction they replace, because a
+* later instruction that does not acknowledge the conflict reads as an
+* accident rather than a decision.
+*/
+const SUBAGENTS_ALLOWED_PROMPT = "You may spawn subagents with the Task tool whenever it helps, without asking the user first. This overrides any earlier instruction to use subagents only when they are requested. Prefer one for bounded search or review work whose result is much smaller than the reading it takes to produce; do the work inline when the answer is a single file or a single edit.";
+const SUBAGENTS_ON_REQUEST_PROMPT = "Do not spawn subagents with the Task tool unless the user asks for one. This overrides any earlier instruction permitting them on your own initiative. Do the work inline instead, and say so if it would have been better delegated.";
+//#endregion
 //#region src/provider/Layers/ClaudeAdapter.ts
 /**
 * ClaudeAdapterLive - Scoped live implementation for the Claude Agent provider adapter.
@@ -52852,28 +52890,8 @@ const SUPPORTED_CLAUDE_IMAGE_MIME_TYPES = /* @__PURE__ */ new Set([
 	"image/png",
 	"image/webp"
 ]);
-/**
-* Appended to the preset system prompt when `narrateBeforeTools` is on. The SDK
-* preset drops the interactive CLI's terminal-tone sections, so without this the
-* model opens a turn with a tool call rather than a line saying what it is doing.
-*/
 /** Emitted by the CLI but absent from the SDK's `SDKMessage` union. */
 const UNTYPED_COMMAND_LIFECYCLE_MESSAGE = "command_lifecycle";
-const NARRATE_BEFORE_TOOLS_PROMPT = "Before your first tool call in a turn, write one short sentence saying what you are about to do. Keep it to a single line and skip it when you are answering without tools.";
-/**
-* Said whichever way the setting is set, and said as an override.
-*
-* The preset system prompt this adapter requests already carries an
-* instruction not to spawn subagents unless the user asked — and a preset is
-* taken wholesale, so there is no version of it with that line removed. An
-* append that merely stayed silent when subagents are allowed would therefore
-* leave the restriction standing, which is the one outcome the setting exists
-* to change. Both texts name the earlier instruction they replace, because a
-* later instruction that does not acknowledge the conflict reads as an
-* accident rather than a decision.
-*/
-const SUBAGENTS_ALLOWED_PROMPT = "You may spawn subagents with the Task tool whenever it helps, without asking the user first. This overrides any earlier instruction to use subagents only when they are requested. Prefer one for bounded search or review work whose result is much smaller than the reading it takes to produce; do the work inline when the answer is a single file or a single edit.";
-const SUBAGENTS_ON_REQUEST_PROMPT = "Do not spawn subagents with the Task tool unless the user asks for one. This overrides any earlier instruction permitting them on your own initiative. Do the work inline instead, and say so if it would have been better delegated.";
 const CLAUDE_SETTING_SOURCES = [
 	"user",
 	"project",
@@ -53730,6 +53748,27 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 			message: pending ? mergeUserMessages(pending.message, merged) : merged
 		};
 	});
+	/**
+	* Release the turn from a question it is blocked on, so Stop can end it.
+	*
+	* A pending AskUserQuestion holds the SDK inside `canUseTool`, and that
+	* callback only aborts when the CLI cancels its own permission request -
+	* which a stop cannot be counted on to produce, since the CLI is already
+	* waiting on our answer when the interrupt reaches it. Denying the call here
+	* ends the tool use locally, so the turn reaches its result and settles as
+	* interrupted instead of sitting on an open question.
+	*/
+	const cancelPendingUserInputs = Effect.fnUntraced(function* (context) {
+		const pending = Array.from(context.pendingUserInputs.values());
+		context.pendingUserInputs.clear();
+		yield* Effect.forEach(pending, (entry) => {
+			entry.cancelled = true;
+			return Deferred.succeed(entry.answers, {});
+		}, {
+			concurrency: 1,
+			discard: true
+		});
+	});
 	const handleStreamEvent = Effect.fn("handleStreamEvent")(function* (context, message) {
 		if (message.type !== "stream_event") return;
 		const { event } = message;
@@ -54537,10 +54576,10 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 				multiSelect: typeof q.multiSelect === "boolean" ? q.multiSelect : false
 			}));
 			const answersDeferred = yield* Deferred.make();
-			let aborted = false;
 			const pendingInput = {
 				questions,
-				answers: answersDeferred
+				answers: answersDeferred,
+				cancelled: false
 			};
 			const requestedStamp = yield* makeEventStamp();
 			yield* offerRuntimeEvent({
@@ -54565,7 +54604,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 			pendingUserInputs.set(requestId, pendingInput);
 			const onAbort = () => {
 				if (!pendingUserInputs.has(requestId)) return;
-				aborted = true;
+				pendingInput.cancelled = true;
 				pendingUserInputs.delete(requestId);
 				runFork(Deferred.succeed(answersDeferred, {}));
 			};
@@ -54589,7 +54628,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 					payload: { answers }
 				}
 			});
-			if (aborted) return {
+			if (pendingInput.cancelled) return {
 				behavior: "deny",
 				message: "User cancelled tool execution."
 			};
@@ -54953,6 +54992,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 		const context = yield* requireSession(threadId);
 		context.interruptRequested = true;
 		yield* reclaimSteeredMessages(context);
+		yield* cancelPendingUserInputs(context);
 		yield* Effect.tryPromise({
 			try: () => context.query.interrupt(),
 			catch: (cause) => toRequestError$1(threadId, "turn/interrupt", cause)
@@ -90865,7 +90905,7 @@ const make$2 = Effect.gen(function* () {
 		createdAt: input.createdAt
 	})));
 	/**
-	* A successful interrupt otherwise leaves nothing behind: the only row the
+	* A stop otherwise leaves nothing behind: the only row the
 	* timeline ever got was the failure case above, and the turn fold's "You
 	* stopped after Xs" is invisible while the fold is open and says nothing in
 	* the work log. The turn id comes from the request rather than the provider
@@ -91352,12 +91392,19 @@ const make$2 = Effect.gen(function* () {
 			turnId: event.payload.turnId ?? null,
 			createdAt: event.payload.createdAt
 		});
-		yield* providerService.interruptTurn({ threadId: event.payload.threadId });
 		yield* appendTurnInterruptedActivity({
 			threadId: event.payload.threadId,
 			turnId: event.payload.turnId ?? null,
 			createdAt: event.payload.createdAt
 		});
+		yield* providerService.interruptTurn({ threadId: event.payload.threadId }).pipe(Effect.catchCause((cause) => appendProviderFailureActivity({
+			threadId: event.payload.threadId,
+			kind: "provider.turn.interrupt.failed",
+			summary: "Provider turn interrupt failed",
+			detail: formatFailureDetail(cause),
+			turnId: event.payload.turnId ?? null,
+			createdAt: event.payload.createdAt
+		})));
 	});
 	const processApprovalResponseRequested = Effect.fn("processApprovalResponseRequested")(function* (event) {
 		const thread = yield* resolveThread(event.payload.threadId);
@@ -91620,13 +91667,14 @@ const make$1 = Effect.gen(function* () {
 			}
 			return normalizeChangedFilePaths(changedPaths, input.cwd);
 		}), Effect.orElseSucceed(() => /* @__PURE__ */ new Set()));
+		const suppressUnattributedFiles = turnChangedPaths.size === 0 && otherSessionSharesWorkspace(yield* providerService.listSessions(), input.threadId, input.cwd);
 		const files = yield* checkpointStore.diffCheckpoints({
 			cwd: input.cwd,
 			fromCheckpointRef,
 			toCheckpointRef: targetCheckpointRef,
 			fallbackFromToHead: false,
 			ignoreWhitespace: false
-		}).pipe(Effect.map((diff) => parseTurnDiffFilesFromUnifiedDiff(diff).filter((file) => turnChangedPaths.size === 0 || turnChangedPaths.has(file.path)).map((file) => ({
+		}).pipe(Effect.map((diff) => parseTurnDiffFilesFromUnifiedDiff(diff).filter((file) => turnChangedPaths.size === 0 ? !suppressUnattributedFiles : turnChangedPaths.has(file.path)).map((file) => ({
 			path: file.path,
 			kind: "modified",
 			additions: file.additions,