@iowarp/clio-coder 0.3.4 → 0.3.7

package/src/interactive/worker-stream.ts

@@ -8,6 +8,13 @@
  * to a bus, or renders; the chat panel owns presentation and the wiring owns
  * I/O, so every sequence below is testable as a pure fold.
  *
+ * What a worker is saying and doing is not decided here. That is the canonical
+ * {@link WorkerProgressSnapshot} projection in `worker-progress.ts`, which the
+ * Fleet Runs board reads from the same events, so the two surfaces cannot drift
+ * on the answer tail, the tool names, or what a call is touching. This module
+ * owns the half the board has no use for: which assignment an event belongs to,
+ * which attempt is current, and what the receipt sealed.
+ *
  * Three rules the fold enforces rather than documents:
  *
  *   - Tool *names* only. Names come exclusively from the `clio_*` telemetry
@@ -34,10 +41,16 @@ import type {
 	DispatchStartedPayload,
 	RunAbortedPayload,
 } from "../core/bus-events.js";
-import { durableAssistantTextFromEvent, WORKER_OUTPUT_MAX_BYTES } from "../domains/dispatch/event-pump.js";
 import type { RunKind } from "../domains/dispatch/types.js";
 import type { WorkerRunOrigin, WorkerRunRuntime, WorkerRunRuntimeKind } from "../domains/session/index.js";
-import { truncateUtf8 } from "../tools/truncate-utf8.js";
+import { createWorkerProgressFold, type WorkerProgressFold, type WorkerProgressSnapshot } from "./worker-progress.js";
+
+export {
+	boundSettledText,
+	WORKER_LIVE_TAIL_LINES,
+	WORKER_TOOL_NAME_LIMIT,
+} from "./worker-progress.js";
+export type { WorkerProgressSnapshot };
 
 export interface WorkerAttempt {
 	runId: string;
@@ -95,9 +108,17 @@ export interface WorkerEntryState {
 	droppedLines: number;
 	/** Distinct tool names in first-use order, bounded. */
 	tools: string[];
+	/** Canonical live projection. Absent only on receipt-based session replay. */
+	progress?: WorkerProgressSnapshot;
 	/** Every attempt of this assignment, oldest first. */
 	attempts: WorkerAttempt[];
 	pending: boolean;
+	/**
+	 * Council provenance, present only on a run of a council group. `/share`
+	 * reads it so a member's answer reaches the main agent under the roster label
+	 * the operator watched it under, rather than as one unattributed voice.
+	 */
+	council?: { group: string; label: string; color?: string; round: number };
 	receipt?: WorkerReceiptSummary;
 	/** Agent origin: the tool call whose execution spawned this run. */
 	parentToolCallId?: string;
@@ -143,23 +164,6 @@ export interface WorkerStream {
 	reset(): void;
 }
 
-/**
- * Lines of worker prose kept while a run is live. The tail is what a streaming
- * answer is about, so the head is what gets dropped; once the run settles the
- * body is replaced by the receipt-sealed answer and anchors at the head, which
- * is the same rule the thinking block already follows.
- */
-export const WORKER_LIVE_TAIL_LINES = 40;
-
-/** Distinct tool names carried on an entry. The receipt's call count carries the total. */
-export const WORKER_TOOL_NAME_LIMIT = 8;
-
-const WORKER_TEXT_TRUNCATION_MARKER = "";
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
 function nonEmptyString(value: unknown): string | undefined {
 	return typeof value === "string" && value.trim().length > 0 ? value : undefined;
 }
@@ -202,58 +206,6 @@ export function workerTargetLabel(runtime: WorkerRunRuntime): string {
 	return runtime.targetId ?? runtime.wireModelId ?? "unknown";
 }
 
-/**
- * Incremental assistant prose carried by one worker event.
- *
- * Native workers slim `message_update` down to `assistantMessageEvent.delta`
- * before it crosses the NDJSON seam (src/worker/event-projection.ts); the ACP
- * mapper emits a top-level `text_delta` carrying `text`. Both spellings are
- * read here so ACP peers need no separate UI path.
- */
-function textDelta(event: unknown): string {
-	if (!isRecord(event)) return "";
-	if (event.type === "message_update") {
-		const assistantEvent = isRecord(event.assistantMessageEvent) ? event.assistantMessageEvent : null;
-		if (assistantEvent?.type !== "text_delta") return "";
-		return typeof assistantEvent.delta === "string" ? assistantEvent.delta : "";
-	}
-	if (event.type !== "text_delta") return "";
-	if (typeof event.delta === "string") return event.delta;
-	return typeof event.text === "string" ? event.text : "";
-}
-
-/** Tool name from Clio's own telemetry. Never from `tool_execution_*`, whose args are the call's arguments. */
-function toolName(event: unknown): string | undefined {
-	if (!isRecord(event)) return undefined;
-	if (event.type !== "clio_tool_start" && event.type !== "clio_tool_finish") return undefined;
-	const payload = isRecord(event.payload) ? event.payload : null;
-	return nonEmptyString(payload?.tool);
-}
-
-function lineCount(text: string): number {
-	if (text.length === 0) return 0;
-	let lines = 1;
-	for (let index = 0; index < text.length; index += 1) {
-		if (text[index] === "\n") lines += 1;
-	}
-	return lines;
-}
-
-/** Keep the newest `WORKER_LIVE_TAIL_LINES` lines; report what that cost. */
-function boundLiveText(text: string): { text: string; dropped: number } {
-	const lines = text.split("\n");
-	if (lines.length <= WORKER_LIVE_TAIL_LINES) return { text, dropped: 0 };
-	const dropped = lines.length - WORKER_LIVE_TAIL_LINES;
-	return { text: lines.slice(dropped).join("\n"), dropped };
-}
-
-/** Head-anchored byte bound for a settled answer, matching the receipt's own bound. */
-export function boundSettledText(text: string): { text: string; dropped: number } {
-	const bounded = truncateUtf8(text, WORKER_OUTPUT_MAX_BYTES, WORKER_TEXT_TRUNCATION_MARKER);
-	if (bounded === text) return { text, dropped: 0 };
-	return { text: bounded, dropped: Math.max(0, lineCount(text) - lineCount(bounded)) };
-}
-
 /**
  * Terminal facts a lifecycle payload can supply on its own. Used only when the
  * sealed receipt is unreadable, so the block still reports an honest outcome
@@ -294,8 +246,21 @@ export function createWorkerStream(options: WorkerStreamOptions = {}): WorkerStr
 	const attemptByAssignment = new Map<string, number>();
 	/** Every attempt run id to its assignment, so progress and terminal events find their entry. */
 	const assignmentByRun = new Map<string, string>();
-	/** Durable answer text observed live, per attempt; the receipt wins when it is readable. */
-	const durableTextByRun = new Map<string, string>();
+	/**
+	 * The canonical progress projection per assignment. One fold spans every
+	 * attempt of an assignment, because a failover keeps streaming into the block
+	 * the operator is already reading.
+	 */
+	const progressByAssignment = new Map<string, WorkerProgressFold>();
+
+	/** Copy the canonical projection onto the entry fields the block renders. */
+	const applyProgress = (entry: WorkerEntryState, fold: WorkerProgressFold): void => {
+		const snapshot = fold.snapshot();
+		entry.text = snapshot.tailText;
+		entry.droppedLines = snapshot.droppedLines;
+		entry.tools = [...snapshot.toolNames];
+		entry.progress = snapshot;
+	};
 
 	/** The entry a run id addresses, and only while that run is the entry's current attempt. */
 	const currentEntryForRun = (runId: unknown): WorkerEntryState | undefined => {
@@ -315,11 +280,10 @@ export function createWorkerStream(options: WorkerStreamOptions = {}): WorkerStr
 		// Terminal truth is the sealed answer. A run whose receipt could not be
 		// read keeps whatever durable text its own stream produced, and a run that
 		// produced none keeps the live tail rather than blanking the block.
-		const settled = nonEmptyString(facts.text) ?? nonEmptyString(durableTextByRun.get(entry.runId));
-		if (settled !== undefined) {
-			const bounded = boundSettledText(settled);
-			entry.text = bounded.text;
-			entry.droppedLines = bounded.dropped;
+		const fold = progressByAssignment.get(entry.assignmentId);
+		if (fold !== undefined) {
+			fold.settle(nonEmptyString(facts.text));
+			applyProgress(entry, fold);
 		}
 		return { kind: "updated", entry };
 	};
@@ -343,10 +307,16 @@ export function createWorkerStream(options: WorkerStreamOptions = {}): WorkerStr
 				delete existing.receipt;
 				existing.attempts.push({ runId, targetLabel: workerTargetLabel(runtime) });
 				assignmentByRun.set(runId, assignmentId);
+				const progress = progressByAssignment.get(assignmentId);
+				if (progress !== undefined) {
+					progress.restart();
+					applyProgress(existing, progress);
+				}
 				return { kind: "updated", entry: existing };
 			}
 			if (payload.requestOrigin !== "user" && payload.requestOrigin !== "agent") return null;
 			attemptByAssignment.set(assignmentId, payload.attempt);
+			const progress = createWorkerProgressFold();
 			const entry: WorkerEntryState = {
 				assignmentId,
 				runId,
@@ -356,49 +326,27 @@ export function createWorkerStream(options: WorkerStreamOptions = {}): WorkerStr
 				text: "",
 				droppedLines: 0,
 				tools: [],
+				progress: progress.snapshot(),
 				attempts: [{ runId, targetLabel: workerTargetLabel(runtime) }],
 				pending: true,
+				...(payload.council !== undefined ? { council: { ...payload.council } } : {}),
 				...(payload.parentToolCallId !== undefined ? { parentToolCallId: payload.parentToolCallId } : {}),
 			};
 			byAssignment.set(assignmentId, entry);
 			assignmentByRun.set(runId, assignmentId);
+			progressByAssignment.set(assignmentId, progress);
 			return { kind: "created", entry };
 		},
 
 		progress(payload): WorkerStreamChange | null {
 			const entry = currentEntryForRun(payload.runId);
 			if (entry === undefined || !entry.pending) return null;
-			const event = payload.event;
-			let changed = false;
-
-			const delta = textDelta(event);
-			if (delta.length > 0) {
-				const bounded = boundLiveText(entry.text + delta);
-				entry.text = bounded.text;
-				entry.droppedLines += bounded.dropped;
-				changed = true;
-			}
-
-			// A durable message_end is the answer as the receipt will seal it. An
-			// ACP peer that streamed no deltas reaches the transcript only here.
-			const durable = durableAssistantTextFromEvent(event);
-			if (durable.trim().length > 0) {
-				durableTextByRun.set(entry.runId, durable);
-				if (delta.length === 0 && entry.text.trim().length === 0) {
-					const bounded = boundLiveText(durable);
-					entry.text = bounded.text;
-					entry.droppedLines += bounded.dropped;
-				}
-				changed = true;
-			}
-
-			const tool = toolName(event);
-			if (tool !== undefined && !entry.tools.includes(tool) && entry.tools.length < WORKER_TOOL_NAME_LIMIT) {
-				entry.tools.push(tool);
-				changed = true;
-			}
-
-			return changed ? { kind: "updated", entry } : null;
+			const fold = progressByAssignment.get(entry.assignmentId);
+			// Everything the block shows about the stream comes from the canonical
+			// projection, so an event that moved nothing visible repaints nothing.
+			if (fold === undefined || !fold.observe(payload.event)) return null;
+			applyProgress(entry, fold);
+			return { kind: "updated", entry };
 		},
 
 		completed(payload): WorkerStreamChange | null {
@@ -440,7 +388,7 @@ export function createWorkerStream(options: WorkerStreamOptions = {}): WorkerStr
 			byAssignment.clear();
 			attemptByAssignment.clear();
 			assignmentByRun.clear();
-			durableTextByRun.clear();
+			progressByAssignment.clear();
 		},
 	};
 }

package/src/tools/agent-tools.ts

@@ -22,6 +22,7 @@ import { type SkillActivation, skillActivationFromToolDetails } from "../core/sk
 import type { ToolName } from "../core/tool-names.js";
 import { ToolNames } from "../core/tool-names.js";
 import type { ResolvedRuntimeTarget } from "../domains/providers/index.js";
+import { type CallActionDescriptor, describeCallAction } from "../domains/safety/call-target.js";
 import type { SafetyDecision } from "../domains/safety/contract.js";
 import { formatModelRejection } from "../domains/safety/rejection-feedback.js";
 import { validateEngineToolArguments } from "../engine/ai.js";
@@ -45,6 +46,12 @@ export type ToolOutcome = "ok" | "error" | "blocked";
 
 export interface ToolStartEvent {
 	tool: string;
+	/**
+	 * The engine's id for this call, when the producer has one. New producers
+	 * put the same id on start and finish so concurrent calls of one tool remain
+	 * independently attributable. Optional for direct callers and old streams.
+	 */
+	toolCallId?: string;
 	posture: "operating";
 	/**
 	 * Wall-clock anchor for the instant the call began, for a human correlating
@@ -53,6 +60,14 @@ export interface ToolStartEvent {
 	 * event is measured on that process's monotonic clock instead.
 	 */
 	startedAt: number;
+	/**
+	 * What this call is doing, as a bounded redacted descriptor composed here
+	 * where the arguments are trusted. This is the only account of a worker's
+	 * arguments that may cross the NDJSON stdout seam; the arguments themselves
+	 * never do, so an operator surface reads a verb and an object it can show,
+	 * never an argument object it would have to sanitize itself.
+	 */
+	action?: CallActionDescriptor;
 }
 
 export interface ToolFinishEvent {
@@ -130,11 +145,21 @@ async function runValidatedToolCall(input: RunValidatedToolCallInput): Promise<W
 	// spans the call, so `durationMs` survives a clock correction mid-tool.
 	const startedAt = Date.now();
 	const startedAtClock = performance.now();
-	telemetry?.onStart?.({ tool: spec.name, posture: "operating", startedAt });
-	// Stamped onto every finish event so a consumer can join this authoritative
-	// outcome to the engine's `tool_execution_end` for the same call.
+	// Stamped onto both lifecycle events so a concurrent finish resolves only
+	// the start for its own engine call. Direct callers may legitimately omit it.
 	const callId = input.invokeOptions?.toolCallId;
 	const withCallId = callId === undefined ? {} : { toolCallId: callId };
+	// The one seam that holds validated arguments and publishes telemetry, so it
+	// is where the redacted descriptor is composed. Everything downstream of here
+	// sees the descriptor and never the arguments.
+	const action = describeCallAction(spec.name, args);
+	telemetry?.onStart?.({
+		tool: spec.name,
+		...withCallId,
+		posture: "operating",
+		startedAt,
+		...(action !== null ? { action } : {}),
+	});
 	const invokeOpts: ToolInvokeOptions = {};
 	if (input.invokeOptions) Object.assign(invokeOpts, input.invokeOptions);
 	if (signal) invokeOpts.signal = signal;

package/src/tools/ask-user.ts

@@ -5,6 +5,7 @@ import { Type } from "typebox";
 import { ToolNames } from "../core/tool-names.js";
 import { clioStateDir } from "../core/xdg.js";
 import { type AutonomyExposure, DEFAULT_AUTONOMY_EXPOSURE } from "../domains/safety/autonomy.js";
+import { classifyDecisionPresentation, decisionFactsForAnswer } from "../domains/safety/decision-presentation.js";
 import { StringEnum } from "../engine/ai.js";
 import type {
 	AskUserToolPolicy,
@@ -57,6 +58,7 @@ export interface AskUserResult {
 
 export interface AskUserCall {
 	action: AskUserAction;
+	exposure?: AutonomyExposure;
 	mode?: AskUserMode;
 	questions?: AskUserQuestion[];
 	decisions?: AskUserDecision[];
@@ -284,6 +286,7 @@ export function normalizeAskUserCall(args: Record<string, unknown>): { call?: As
 	return {
 		call: {
 			action: "ask",
+			exposure: exposure.exposure ?? DEFAULT_AUTONOMY_EXPOSURE,
 			...(mode.mode ? { mode: mode.mode } : {}),
 			questions: questions.questions,
 			...(summary ? { summary } : {}),
@@ -319,6 +322,7 @@ function createStandalonePolicy(options?: ToolInvokeOptions): AskUserToolPolicy
 		updatedAt: now,
 		...(options?.sessionId ? { sessionId: options.sessionId } : {}),
 		...(options?.turnId ? { turnId: options.turnId } : {}),
+		exposure: DEFAULT_AUTONOMY_EXPOSURE,
 		rounds: [],
 		decisions: [],
 		inFlight: false,
@@ -335,6 +339,13 @@ function hydratePolicy(policy: AskUserToolPolicy, options?: ToolInvokeOptions):
 	if (options?.turnId && !policy.turnId) policy.turnId = options.turnId;
 }
 
+/** Once an interview is outward, a later local round cannot lower its replay tier. */
+function mergePolicyExposure(policy: AskUserToolPolicy, exposure: AutonomyExposure): AutonomyExposure {
+	const merged = policy.exposure === "outward" || exposure === "outward" ? "outward" : "local";
+	policy.exposure = merged;
+	return merged;
+}
+
 function transcriptQuestions(questions: ReadonlyArray<AskUserQuestion>): AskUserTranscriptQuestion[] {
 	return questions.map((question) => ({
 		question: question.question,
@@ -455,6 +466,7 @@ async function persistAskUserTranscript(
 			...(policy.endedAt ? { endedAt: policy.endedAt } : {}),
 			...(policy.sessionId ? { sessionId: policy.sessionId } : {}),
 			...(policy.turnId ? { turnId: policy.turnId } : {}),
+			exposure: policy.exposure ?? DEFAULT_AUTONOMY_EXPOSURE,
 			...(policy.summary ? { summary: policy.summary } : {}),
 			decisions: policy.decisions,
 			rounds: policy.rounds,
@@ -478,6 +490,7 @@ function compactInterview(
 		rounds: policy.rounds.length,
 		max_rounds: policy.maxCalls,
 		transcript_path: policy.transcriptPath ?? null,
+		exposure: policy.exposure ?? DEFAULT_AUTONOMY_EXPOSURE,
 		latest_answers: latestAnswers,
 		decisions: policy.decisions,
 		...(policy.summary ? { summary: policy.summary } : {}),
@@ -591,6 +604,7 @@ export function createAskUserTool(deps: AskUserToolDeps = {}): ToolSpec {
 				return completeInterview(policy, "complete", options, call.summary, call.decisions ?? []);
 			}
 			const questions = call.questions ?? [];
+			const exposure = mergePolicyExposure(policy, call.exposure ?? DEFAULT_AUTONOMY_EXPOSURE);
 			if (call.max_rounds !== undefined) {
 				const nextLimit = policy.callCount === 0 ? call.max_rounds : Math.max(policy.maxCalls, call.max_rounds);
 				policy.maxCalls = Math.max(nextLimit, policy.callCount + 1);
@@ -632,7 +646,13 @@ export function createAskUserTool(deps: AskUserToolDeps = {}): ToolSpec {
 			if (call.summary) policy.summary = call.summary;
 			const handler = deps.askUser ?? defaultAskUserHandler;
 			try {
-				const result = normalizeAskUserResult(questions, await handler(questions, options));
+				const result = normalizeAskUserResult(
+					questions,
+					await handler(questions, {
+						...options,
+						decisionPresentation: classifyDecisionPresentation(decisionFactsForAnswer(exposure)),
+					}),
+				);
 				const answeredAt = new Date().toISOString();
 				policy.callCount += 1;
 				policy.askedQuestionKeys.add(key);

package/src/tools/bootstrap.ts

@@ -1,3 +1,4 @@
+import type { WorkerRosters } from "../core/defaults.js";
 import type { SafeEventBus } from "../core/event-bus.js";
 import type { AgentSpec } from "../domains/agents/spec.js";
 import type { DispatchContract } from "../domains/dispatch/contract.js";
@@ -22,6 +23,7 @@ export interface ToolBootstrapDeps extends CoreToolBootstrapDeps {
 	getAgentRoleFacts?: AgentRoleFactsResolver;
 	getAutonomy?: () => AutonomyLevel;
 	getCostCeilingUsd?: () => number;
+	getWorkerRosters?: () => WorkerRosters;
 	dispatchBackground?: DispatchBackgroundRegistry;
 }
 
@@ -44,6 +46,7 @@ export function registerAllTools(registry: ToolRegistry, deps: ToolBootstrapDeps
 			...(deps.getAgentRoleFacts ? { getAgentRoleFacts: deps.getAgentRoleFacts } : {}),
 			...(deps.getAutonomy ? { getAutonomy: deps.getAutonomy } : {}),
 			...(deps.getCostCeilingUsd ? { getCostCeilingUsd: deps.getCostCeilingUsd } : {}),
+			...(deps.getWorkerRosters ? { getWorkerRosters: deps.getWorkerRosters } : {}),
 			...(deps.dispatchBackground ? { background: deps.dispatchBackground } : {}),
 		};
 		registry.register({

package/src/tools/compete-worktrees.ts

@@ -33,8 +33,15 @@ import {
 	writeFileSync,
 } from "node:fs";
 import { hostname } from "node:os";
-import { isAbsolute, join, relative, resolve, sep } from "node:path";
+import { join, relative, resolve } from "node:path";
 import type { RunKind } from "../domains/dispatch/types.js";
+import {
+	commitWorktreePath,
+	isCanonicalWorktreePathInside,
+	mergeWorktreeBranch,
+	protectedPathsChangedByWorktreeBranch,
+	worktreeBranchDiffStat,
+} from "./task-worktree.js";
 
 export interface CandidateWorktree {
 	index: number;
@@ -300,20 +307,7 @@ function isCanonicalDirectoryAt(path: string): boolean {
  * be mistaken for a child of `/group-a` as it can with textual startsWith.
  */
 export function isCanonicalPathInside(parent: string, candidate: string): boolean {
-	let canonicalParent: string;
-	let canonicalCandidate: string;
-	try {
-		canonicalParent = realpathSync(parent);
-	} catch {
-		canonicalParent = resolve(parent);
-	}
-	try {
-		canonicalCandidate = realpathSync(candidate);
-	} catch {
-		canonicalCandidate = resolve(candidate);
-	}
-	const rel = relative(canonicalParent, canonicalCandidate);
-	return rel.length > 0 && rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel);
+	return isCanonicalWorktreePathInside(parent, candidate);
 }
 
 function manifestFromUnknown(value: unknown): CompeteGroupManifest | null {
@@ -557,29 +551,12 @@ export function createCandidateWorktree(
  * builder changed nothing (an empty candidate is a legitimate ranking fact).
  */
 export function commitCandidateWork(worktree: CandidateWorktree, message: string): boolean {
-	git(worktree.path, ["add", "-A"]);
-	const staged = git(worktree.path, ["status", "--porcelain"]);
-	if (staged.length === 0) return false;
-	git(worktree.path, [
-		"-c",
-		`user.name=${COMPETE_COMMIT_IDENTITY}`,
-		"-c",
-		`user.email=${COMPETE_COMMIT_IDENTITY}@local`,
-		"commit",
-		"-m",
-		message,
-		"--no-verify",
-	]);
-	return true;
+	return commitWorktreePath(worktree.path, COMPETE_COMMIT_IDENTITY, message);
 }
 
 /** One-line stat summary of what a candidate branch changed relative to HEAD. */
 export function candidateDiffStat(root: string, branch: string): string {
-	try {
-		return git(root, ["diff", "--shortstat", `HEAD...${branch}`]) || "no changes";
-	} catch {
-		return "diff unavailable";
-	}
+	return worktreeBranchDiffStat(root, branch);
 }
 
 /**
@@ -592,31 +569,7 @@ export function protectedPathsChangedByCompeteBranch(
 	branch: string,
 	protectedPaths: ReadonlyArray<string>,
 ): string[] {
-	const canonical = canonicalRoot(root);
-	const protectedInside = protectedPaths
-		.map((path) => resolve(path))
-		.filter((path) => {
-			const rel = relative(canonical, path);
-			return rel.length > 0 && rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel);
-		});
-	if (protectedInside.length === 0) return [];
-	const changed = git(canonical, ["diff", "--name-only", "-z", "--no-renames", `HEAD...${branch}`])
-		.split("\0")
-		.filter((path) => path.length > 0)
-		.map((path) => resolve(canonical, path));
-	const blocked = new Set<string>();
-	for (const candidate of changed) {
-		for (const protectedPath of protectedInside) {
-			const rel = relative(protectedPath, candidate);
-			if (
-				candidate === protectedPath ||
-				(rel.length > 0 && rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel))
-			) {
-				blocked.add(protectedPath);
-			}
-		}
-	}
-	return [...blocked].sort();
+	return protectedPathsChangedByWorktreeBranch(root, branch, protectedPaths);
 }
 
 function registeredWorktreePaths(root: string): string[] {
@@ -687,26 +640,7 @@ export function removeCandidateWorktree(
  * the merge and reports failure so the operator decides.
  */
 export function mergeWinnerBranch(root: string, branch: string): { ok: true } | { ok: false; reason: string } {
-	try {
-		git(root, [
-			"-c",
-			`user.name=${COMPETE_COMMIT_IDENTITY}`,
-			"-c",
-			`user.email=${COMPETE_COMMIT_IDENTITY}@local`,
-			"merge",
-			"--no-edit",
-			"--no-verify",
-			branch,
-		]);
-		return { ok: true };
-	} catch (err) {
-		try {
-			git(root, ["merge", "--abort"]);
-		} catch {
-			// No merge in progress; nothing to abort.
-		}
-		return { ok: false, reason: err instanceof Error ? (err.message.split("\n")[0] ?? "merge failed") : String(err) };
-	}
+	return mergeWorktreeBranch(root, branch, COMPETE_COMMIT_IDENTITY);
 }
 
 /**

package/src/tools/context/index.ts

@@ -168,7 +168,7 @@ function policyIsRecipeBound(policy: { requests: ReadonlyArray<{ source: string
 // load it (only the operator activates), so its move is suggest-and-wait.
 const NO_PENDING_SKILL_DENIAL =
 	"context: no pending skill request is active this turn; only the operator can activate a skill, so do not retry this load. " +
-	`If a listed skill matches the task, open your reply with the line \`${SKILL_SUGGESTION_ANCHOR}\` and wait for the operator to run it; otherwise continue without skills.`;
+	`If a listed skill matches the task, open your reply with the line \`${SKILL_SUGGESTION_ANCHOR}\` and continue the task without it; only the operator can run it. Otherwise continue without skills.`;
 
 function pendingSkillPolicyError(name: string, options: ToolInvokeOptions | undefined): string | null {
 	const policy = options?.pendingSkillPolicy;
@@ -287,7 +287,7 @@ function renderSkillsList(
 	// template where they skip conditional prose in the header.
 	lines.push(
 		"",
-		`If one skill above matches the current task, begin your reply with the line \`${SKILL_SUGGESTION_ANCHOR}\` (a comma-separated sequence, in order, when several compose) and wait for the operator to run it. If none match, do not mention skills.`,
+		`If one skill above matches the current task, begin your reply with the line \`${SKILL_SUGGESTION_ANCHOR}\` (a comma-separated sequence, in order, when several compose), then continue the task in the same turn without it; only the operator can run it. If none match, do not mention skills.`,
 	);
 	return lines.join("\n");
 }