@sayknow-cli/coding-agent 0.2.7 → 0.3.0

package/src/commands/notify.ts

@@ -0,0 +1,61 @@
+/**
+ * Configure Telegram notifications.
+ */
+import { Args, Command, Flags } from "@sayknow-cli/utils/cli";
+import { type NotifyAction, type NotifyCommandArgs, runNotifyCommand } from "../cli/notify-cli";
+import { initTheme } from "../modes/theme/theme";
+
+const ACTIONS: NotifyAction[] = ["setup", "status", "daemon-internal"];
+
+export default class Notify extends Command {
+	static description = "Configure Telegram notifications";
+
+	static args = {
+		action: Args.string({
+			description: "Notify action",
+			required: false,
+			options: ACTIONS,
+		}),
+		extra: Args.string({
+			description: "Additional internal args",
+			required: false,
+			multiple: true,
+		}),
+	};
+
+	static flags = {
+		smoke: Flags.boolean({ description: "Run hidden daemon smoke" }),
+		token: Flags.string({ description: "Telegram bot token (non-interactive setup)" }),
+		"chat-id": Flags.string({ description: "Telegram chat id to pair (non-interactive setup)" }),
+		redact: Flags.boolean({ description: "Enable redaction of remote notification content" }),
+		"owner-id": Flags.string({ description: "Internal: daemon owner id" }),
+		"agent-dir": Flags.string({ description: "Internal: agent dir for the daemon" }),
+	};
+
+	async run(): Promise<void> {
+		const { args, flags } = await this.parse(Notify);
+		const action = (args.action ?? "status") as NotifyAction;
+		const extra = Array.isArray(args.extra) ? args.extra : args.extra ? [args.extra] : [];
+		const flagRec = flags as Record<string, unknown>;
+		const ownerId = flagRec["owner-id"] as string | undefined;
+		const agentDir = flagRec["agent-dir"] as string | undefined;
+		const rawArgs = [
+			...(flags.smoke ? ["--smoke"] : []),
+			...(ownerId ? ["--owner-id", ownerId] : []),
+			...(agentDir ? ["--agent-dir", agentDir] : []),
+			...extra,
+		];
+
+		const cmd: NotifyCommandArgs = {
+			action,
+			smoke: flags.smoke,
+			rawArgs,
+			token: flags.token as string | undefined,
+			chatId: (flags as Record<string, unknown>)["chat-id"] as string | undefined,
+			redact: Boolean(flags.redact),
+		};
+
+		await initTheme();
+		await runNotifyCommand(cmd);
+	}
+}

package/src/commands/setup.ts

@@ -5,7 +5,17 @@ import { Args, Command, Flags } from "@sayknow-cli/utils/cli";
 import { runSetupCommand, type SetupCommandArgs, type SetupComponent } from "../cli/setup-cli";
 import { initTheme } from "../modes/theme/theme";
 
-const COMPONENTS: SetupComponent[] = ["credentials", "defaults", "hermes", "hooks", "provider", "python", "stt"];
+const COMPONENTS: SetupComponent[] = [
+	"claude",
+	"codex",
+	"credentials",
+	"defaults",
+	"hermes",
+	"hooks",
+	"provider",
+	"python",
+	"stt",
+];
 
 export default class Setup extends Command {
 	static description = "Install SKC defaults or optional feature dependencies";

package/src/config/model-profile-activation.ts

@@ -17,6 +17,8 @@ type ModelProfileActivationSession = Pick<AgentSession, "model" | "thinkingLevel
 	setModelTemporary?: AgentSession["setModelTemporary"];
 	setActiveModelProfile?: (name: string | undefined) => void;
 	getActiveModelProfile?: () => string | undefined;
+	getSessionDefaultModelSelector?: () => string | undefined;
+	recordResumeDefaultModel?: (selector: string) => void;
 };
 
 export interface PrepareModelProfileActivationOptions {
@@ -43,10 +45,20 @@ export interface PreparedModelProfileActivation {
 	previousModel: Model<Api> | undefined;
 	previousThinkingLevel: ThinkingLevel | undefined;
 	previousAgentModelOverrides: Record<string, string>;
+	previousModelRoles: Record<string, string>;
 	defaultModel: Model<Api> | undefined;
 	defaultThinkingLevel: ThinkingLevel | undefined;
+	modelRoles: Record<string, string>;
 	agentModelOverrides: Record<string, string>;
 	previousActiveModelProfile: string | undefined;
+	/**
+	 * The session resume default ("provider/id") captured BEFORE activation —
+	 * the model resume would restore prior to this profile. Snapshotted
+	 * separately from `previousModel` (the live runtime model, which may be a
+	 * transient switch) so a failed-activation rollback restores the correct
+	 * resume default without promoting a transient model to it.
+	 */
+	previousSessionDefaultModel: string | undefined;
 }
 
 export function formatModelProfileCredentialError(profileName: string, providers: readonly string[]): string {
@@ -87,14 +99,24 @@ function rewriteSelectorProvider(
 }
 
 function rewriteBindingsProviders(
-	bindings: { defaultSelector?: string; agentModelOverrides: Record<string, string> },
+	bindings: {
+		defaultSelector?: string;
+		modelRoles: Record<string, string>;
+		agentModelOverrides: Record<string, string>;
+	},
 	authenticatedProviders: ReadonlySet<string>,
 	alternativeGroups: readonly (readonly string[])[],
-): { defaultSelector?: string; agentModelOverrides: Record<string, string> } {
+): { defaultSelector?: string; modelRoles: Record<string, string>; agentModelOverrides: Record<string, string> } {
 	return {
 		defaultSelector: bindings.defaultSelector
 			? rewriteSelectorProvider(bindings.defaultSelector, authenticatedProviders, alternativeGroups)
 			: undefined,
+		modelRoles: Object.fromEntries(
+			Object.entries(bindings.modelRoles).map(([role, sel]) => [
+				role,
+				rewriteSelectorProvider(sel, authenticatedProviders, alternativeGroups),
+			]),
+		),
 		agentModelOverrides: Object.fromEntries(
 			Object.entries(bindings.agentModelOverrides).map(([role, sel]) => [
 				role,
@@ -165,6 +187,18 @@ export async function prepareModelProfileActivation(
 		);
 	}
 
+	const modelRoles: Record<string, string> = {};
+	for (const [role, selector] of Object.entries(bindings.modelRoles) as [SkcModelAssignmentTargetId, string][]) {
+		const resolved = resolveModelRoleValue(selector, availableModels, {
+			settings: options.settings as Settings,
+			modelRegistry: options.modelRegistry,
+		});
+		if (!resolved.model) {
+			throw new Error(`Model profile "${options.profileName}" ${role} selector did not resolve: ${selector}`);
+		}
+		modelRoles[role] = formatClampedModelSelector(selector, resolved.model);
+	}
+
 	const agentModelOverrides: Record<string, string> = {};
 	for (const [role, selector] of Object.entries(bindings.agentModelOverrides) as [
 		SkcModelAssignmentTargetId,
@@ -187,10 +221,13 @@ export async function prepareModelProfileActivation(
 		previousModel: options.session.model,
 		previousThinkingLevel: options.session.thinkingLevel,
 		previousAgentModelOverrides: { ...options.settings.get("task.agentModelOverrides") },
+		previousModelRoles: { ...options.settings.get("modelRoles") },
 		defaultModel: resolvedDefault?.model,
 		defaultThinkingLevel: resolvedDefault?.thinkingLevel,
+		modelRoles,
 		agentModelOverrides,
 		previousActiveModelProfile: options.session.getActiveModelProfile?.(),
+		previousSessionDefaultModel: options.session.getSessionDefaultModelSelector?.(),
 	};
 }
 
@@ -201,17 +238,29 @@ export async function applyPreparedModelProfileActivation(
 	const previousModel = prepared.previousModel;
 	const previousThinkingLevel = prepared.previousThinkingLevel;
 	const previousAgentModelOverrides = prepared.previousAgentModelOverrides;
+	const previousModelRoles = prepared.previousModelRoles;
 	const previousPersistedDefault = prepared.settings.get("modelProfile.default");
 	const previousActiveModelProfile = prepared.previousActiveModelProfile;
+	const previousSessionDefaultModel = prepared.previousSessionDefaultModel;
 	let modelChanged = false;
 	let overridesChanged = false;
 	let defaultChanged = false;
+	let modelRolesChanged = false;
 
 	try {
 		if (prepared.defaultModel) {
-			await prepared.session.setModelTemporary(prepared.defaultModel, prepared.defaultThinkingLevel);
+			await prepared.session.setModelTemporary(prepared.defaultModel, prepared.defaultThinkingLevel, {
+				persistAsSessionDefault: true,
+			});
 			modelChanged = true;
 		}
+		if (Object.keys(prepared.modelRoles).length > 0) {
+			prepared.settings.override("modelRoles", {
+				...prepared.settings.get("modelRoles"),
+				...prepared.modelRoles,
+			});
+			modelRolesChanged = true;
+		}
 		if (Object.keys(prepared.agentModelOverrides).length > 0) {
 			prepared.settings.override("task.agentModelOverrides", {
 				...prepared.settings.get("task.agentModelOverrides"),
@@ -229,12 +278,32 @@ export async function applyPreparedModelProfileActivation(
 		if (defaultChanged) {
 			prepared.settings.set("modelProfile.default", previousPersistedDefault);
 		}
+		if (modelRolesChanged) {
+			prepared.settings.override("modelRoles", previousModelRoles);
+		}
 		if (overridesChanged) {
 			prepared.settings.override("task.agentModelOverrides", previousAgentModelOverrides);
 		}
 		prepared.session.setActiveModelProfile?.(previousActiveModelProfile);
-		if (modelChanged && previousModel) {
-			await prepared.session.setModelTemporary(previousModel, previousThinkingLevel);
+		if (modelChanged) {
+			// Runtime rolls back to the pre-activation live model. That model may
+			// itself be a transient retry/fallback/context-promotion/plan switch,
+			// so it is recorded as role:"temporary" (NOT the resume default) to
+			// preserve the issue #849 protection.
+			if (previousModel) {
+				await prepared.session.setModelTemporary(previousModel, previousThinkingLevel);
+			}
+			// The happy path already appended the profile main model as the resume
+			// default (role:"default"). Re-assert the pre-activation resume default
+			// so a failed activation does not poison future resume. Fall back to the
+			// live model only when there was no explicit pre-activation default
+			// (nothing to protect). Append-only — never touches the runtime model.
+			const restoreDefaultSelector =
+				previousSessionDefaultModel ??
+				(previousModel ? `${previousModel.provider}/${previousModel.id}` : undefined);
+			if (restoreDefaultSelector) {
+				prepared.session.recordResumeDefaultModel?.(restoreDefaultSelector);
+			}
 		}
 		throw error;
 	}

package/src/config/model-profiles.ts

@@ -23,7 +23,8 @@ export interface ModelProfileDefinition {
 
 export interface ResolvedProfileBinding {
 	defaultSelector?: string;
-	agentModelOverrides: Partial<Record<Exclude<ModelProfileRole, "default">, string>>;
+	modelRoles: Partial<Record<"vision", string>>;
+	agentModelOverrides: Partial<Record<Exclude<ModelProfileRole, "default" | "vision">, string>>;
 }
 
 function parseModelSelectorProvider(selector: string): string | undefined {
@@ -56,7 +57,7 @@ export function aggregateModelProfileRequiredProviders(
 const profile = (
 	name: string,
 	requiredProviders: string[],
-	modelMapping: Record<ModelProfileRole, string>,
+	modelMapping: Partial<Record<ModelProfileRole, string>>,
 	alternativeProviderGroups?: readonly (readonly string[])[],
 ): ModelProfileDefinition => ({
 	name,
@@ -382,13 +383,15 @@ export function mergeModelProfiles(userProfiles?: ModelsConfig["profiles"]): Map
 }
 
 export function resolveProfileBindings(definition: ModelProfileDefinition): ResolvedProfileBinding {
-	const { default: defaultSelector, executor, architect, planner, critic } = definition.modelMapping;
+	const { default: defaultSelector, vision, executor, architect, planner, critic } = definition.modelMapping;
+	const modelRoles: ResolvedProfileBinding["modelRoles"] = {};
+	if (vision !== undefined) modelRoles.vision = vision;
 	const agentModelOverrides: ResolvedProfileBinding["agentModelOverrides"] = {};
 	if (executor !== undefined) agentModelOverrides.executor = executor;
 	if (architect !== undefined) agentModelOverrides.architect = architect;
 	if (planner !== undefined) agentModelOverrides.planner = planner;
 	if (critic !== undefined) agentModelOverrides.critic = critic;
-	return { defaultSelector, agentModelOverrides };
+	return { defaultSelector, modelRoles, agentModelOverrides };
 }
 
 export function formatAvailableProfileNames(profiles: ReadonlyMap<string, ModelProfileDefinition>): string {

package/src/config/model-registry.ts

@@ -70,7 +70,7 @@ export function isAuthenticated(apiKey: string | undefined | null): apiKey is st
 	return Boolean(apiKey) && apiKey !== kNoAuth;
 }
 
-export type ModelRole = "default";
+export type ModelRole = "default" | "vision";
 
 export interface ModelRoleInfo {
 	tag?: string;
@@ -80,11 +80,12 @@ export interface ModelRoleInfo {
 
 export const MODEL_ROLES: Record<ModelRole, ModelRoleInfo> = {
 	default: { tag: "DEFAULT", name: "Default", color: "success" },
+	vision: { tag: "VISION", name: "Vision", color: "accent" },
 };
 
-export const MODEL_ROLE_IDS: ModelRole[] = ["default"];
+export const MODEL_ROLE_IDS: ModelRole[] = ["default", "vision"];
 
-export type SkcModelAssignmentTargetId = "default" | "executor" | "architect" | "planner" | "critic";
+export type SkcModelAssignmentTargetId = "default" | "vision" | "executor" | "architect" | "planner" | "critic";
 
 export interface SkcModelAssignmentTargetInfo extends ModelRoleInfo {
 	id: SkcModelAssignmentTargetId;
@@ -93,6 +94,7 @@ export interface SkcModelAssignmentTargetInfo extends ModelRoleInfo {
 
 export const SKC_MODEL_ASSIGNMENT_TARGET_IDS: SkcModelAssignmentTargetId[] = [
 	"default",
+	"vision",
 	"executor",
 	"architect",
 	"planner",
@@ -101,6 +103,7 @@ export const SKC_MODEL_ASSIGNMENT_TARGET_IDS: SkcModelAssignmentTargetId[] = [
 
 export const SKC_MODEL_ASSIGNMENT_TARGETS: Record<SkcModelAssignmentTargetId, SkcModelAssignmentTargetInfo> = {
 	default: { id: "default", tag: "DEFAULT", name: "Default", color: "success", settingsPath: "modelRoles" },
+	vision: { id: "vision", tag: "VISION", name: "Vision", color: "accent", settingsPath: "modelRoles" },
 	executor: {
 		id: "executor",
 		tag: "EXECUTOR",

package/src/config/models-config-schema.ts

@@ -81,7 +81,7 @@ const ModelBindingsSchema = z.object({
 	modelRoles: z.record(z.string(), z.string().min(1)).optional(),
 	agentModelOverrides: z.record(z.string(), z.string().min(1)).optional(),
 });
-export const ProfileRoleSchema = z.enum(["default", "executor", "architect", "planner", "critic"]);
+export const ProfileRoleSchema = z.enum(["default", "vision", "executor", "architect", "planner", "critic"]);
 
 function isValidProfileModelSelector(value: string): boolean {
 	if (value.includes(",")) return false;

package/src/config/settings-schema.ts

@@ -255,6 +255,22 @@ export const SETTINGS_SCHEMA = {
 	"auth.broker.url": { type: "string", default: undefined },
 	"auth.broker.token": { type: "string", default: undefined },
 
+	// Notifications (Telegram bundled reference client)
+	"notifications.enabled": { type: "boolean", default: false },
+	"notifications.telegram.botToken": { type: "string", default: undefined },
+	"notifications.telegram.chatId": { type: "string", default: undefined },
+	"notifications.redact": { type: "boolean", default: false },
+	"notifications.verbosity": {
+		type: "string",
+		default: "lean",
+		validate: (value: string) => value === "lean" || value === "verbose",
+	},
+	"notifications.daemon.idleTimeoutMs": {
+		type: "number",
+		default: 60000,
+		validate: (value: number) => Number.isFinite(value) && value > 0,
+	},
+
 	autoResume: {
 		type: "boolean",
 		default: false,
@@ -3209,6 +3225,18 @@ export interface ShellMinimizerSettings {
 	maxCaptureBytes: number;
 }
 
+export interface NotificationsSettings {
+	enabled: boolean;
+	telegram: {
+		botToken: string | undefined;
+		chatId: string | undefined;
+	};
+	redact: boolean;
+	daemon: {
+		idleTimeoutMs: number;
+	};
+}
+
 /** Map group prefix -> typed settings interface */
 export interface GroupTypeMap {
 	compaction: CompactionSettings;
@@ -3227,6 +3255,7 @@ export interface GroupTypeMap {
 	modelTags: ModelTagsSettings;
 	cycleOrder: string[];
 	shellMinimizer: ShellMinimizerSettings;
+	notifications: NotificationsSettings;
 }
 
 export type GroupPrefix = keyof GroupTypeMap;

package/src/coordinator/contract.ts

@@ -17,6 +17,9 @@ export const COORDINATOR_MCP_TOOL_NAMES = [
 	"skc_coordinator_read_turn",
 	"skc_coordinator_await_turn",
 	"skc_coordinator_report_status",
+	"skc_delegate_plan",
+	"skc_delegate_execute",
+	"skc_delegate_team",
 ] as const;
 
 export type CoordinatorToolName = (typeof COORDINATOR_MCP_TOOL_NAMES)[number];

package/src/coordinator-mcp/server.ts

@@ -184,7 +184,8 @@ type CoordinatorEventKind =
 	| "question.answered"
 	| "report.written"
 	| "tmux.delivery_succeeded"
-	| "tmux.delivery_failed";
+	| "tmux.delivery_failed"
+	| "delegation.started";
 
 interface CoordinatorEvent {
 	schema_version: 1;
@@ -411,9 +412,116 @@ function toolSchema(name: CoordinatorToolName): {
 			},
 		};
 	}
+	const delegateWorkflow = workflowForDelegateTool(name);
+	if (delegateWorkflow) {
+		return {
+			name,
+			description: delegateToolDescription(delegateWorkflow),
+			inputSchema: {
+				type: "object",
+				properties: {
+					cwd,
+					task: {
+						type: "string",
+						description: "Delegated task or objective to run through the selected SKC workflow.",
+					},
+					prompt: { type: "string", description: "Alias for task; accepted when task is absent." },
+					allow_mutation: allowMutation,
+					session_id: {
+						type: "string",
+						description:
+							"Optional existing SKC coordinator bridge session id to reuse; omitted starts a fresh session.",
+					},
+					queue: {
+						type: "boolean",
+						description: "When reusing a session with an active turn, queue instead of failing.",
+					},
+					force: {
+						type: "boolean",
+						description: "When reusing a session with an active turn, supersede it before sending.",
+					},
+					model: {
+						type: "string",
+						description: "Optional model hint passed in prompt metadata; no provider default is implied.",
+					},
+					await_completion: { type: "boolean", description: "If true, poll the turn until terminal or timeout." },
+					timeout_ms: {
+						type: "number",
+						description: "Bounded await timeout; same cap semantics as skc_coordinator_await_turn.",
+					},
+					poll_interval_ms: { type: "number", description: "Bounded await polling interval." },
+					lines: { type: "number", description: "Bounded advisory tail lines returned with await/read payloads." },
+				},
+				required: ["cwd", "allow_mutation"],
+			},
+		};
+	}
 	return { name, description: "List known scoped SKC coordinator bridge sessions.", inputSchema: common };
 }
 
+type DelegateWorkflow = "plan" | "execute" | "team";
+
+function workflowForDelegateTool(name: string): DelegateWorkflow | null {
+	switch (name) {
+		case "skc_delegate_plan":
+			return "plan";
+		case "skc_delegate_execute":
+			return "execute";
+		case "skc_delegate_team":
+			return "team";
+		default:
+			return null;
+	}
+}
+
+function workflowSkill(workflow: DelegateWorkflow): "ralplan" | "ultragoal" | "team" {
+	switch (workflow) {
+		case "plan":
+			return "ralplan";
+		case "execute":
+			return "ultragoal";
+		case "team":
+			return "team";
+	}
+}
+
+function delegateToolDescription(workflow: DelegateWorkflow): string {
+	switch (workflow) {
+		case "plan":
+			return "Delegate consensus planning to SKC: start a session and run /skill:ralplan to completion, returning durable turn status and artifact references.";
+		case "execute":
+			return "Delegate execution to SKC: start a session and run /skill:ultragoal to completion, returning durable turn status and artifact references.";
+		case "team":
+			return "Delegate parallel team execution to SKC: start a session and run /skill:team to completion, returning durable turn status and artifact references.";
+	}
+}
+
+function workflowPrompt(
+	workflow: DelegateWorkflow,
+	toolName: string,
+	canonicalCwd: string,
+	task: string,
+	options: { mutationRequested: boolean; model?: string | null },
+): string {
+	const skill = workflowSkill(workflow);
+	const model = options.model && options.model.trim().length > 0 ? options.model.trim() : "none";
+	const mutationIntent = options.mutationRequested ? "mutation requested" : "read-only";
+	return [
+		`/skill:${skill}`,
+		"",
+		`Delegated by coordinator MCP tool: ${toolName}`,
+		`Workflow: ${workflow}`,
+		`CWD: ${canonicalCwd}`,
+		`Mutation intent: ${mutationIntent}; coordinator startup policy remains authoritative.`,
+		`Optional model hint: ${model}`,
+		"",
+		"Task:",
+		task,
+		"",
+		"Return durable status and artifact references through SKC runtime/coordinator state. Do not expose host-facing tmux controls.",
+	].join("\n");
+}
+
 function normalizeSession(session: Record<string, unknown>): Record<string, unknown> {
 	return {
 		session_id: session.sessionId ?? session.session_id ?? session.name ?? "unknown",
@@ -424,6 +532,14 @@ function normalizeSession(session: Record<string, unknown>): Record<string, unkn
 	};
 }
 
+async function canonicalizePath(value: string): Promise<string> {
+	try {
+		return await fs.realpath(value);
+	} catch {
+		return path.resolve(value);
+	}
+}
+
 async function ensureDir(dir: string): Promise<void> {
 	await fs.mkdir(dir, { recursive: true });
 }
@@ -1587,6 +1703,159 @@ export function createCoordinatorMcpServer(options: CoordinatorMcpServerOptions
 					transport: { mcp: "long_poll", push_subscriptions: false },
 				};
 			}
+			const delegateWorkflow = workflowForDelegateTool(name);
+			if (delegateWorkflow) {
+				requireCoordinatorMutation(config, "sessions", args);
+				const canonicalCwd = await assertCoordinatorWorkdir(config, args.cwd);
+				const hasTask = typeof args.task === "string" && args.task.trim().length > 0;
+				const hasPrompt = typeof args.prompt === "string" && args.prompt.trim().length > 0;
+				const task = hasTask ? String(args.task) : hasPrompt ? String(args.prompt) : null;
+				if (!task) return { ok: false, reason: "task_required" };
+				const promptAliasIgnored = hasTask && hasPrompt;
+				const mutationRequested = args.allow_mutation === true;
+				const taggedPrompt = workflowPrompt(delegateWorkflow, name, canonicalCwd, task, {
+					mutationRequested,
+					model: typeof args.model === "string" ? args.model : null,
+				});
+
+				let session: Record<string, unknown>;
+				let reusedSession = false;
+				if (args.session_id != null) {
+					const sessionId = safeExternalId("session", args.session_id);
+					const existing = asRecord(await readJsonFile(sessionFile(sessionId)));
+					if (!existing) return { ok: false, reason: "unknown_session", session_id: sessionId };
+					const storedCwd = typeof existing.cwd === "string" ? existing.cwd : null;
+					const canonicalStored = storedCwd ? await canonicalizePath(storedCwd) : null;
+					const canonicalRequested = await canonicalizePath(canonicalCwd);
+					if (!canonicalStored || canonicalStored !== canonicalRequested) {
+						return { ok: false, reason: "session_cwd_mismatch", session_id: sessionId };
+					}
+					session = existing;
+					reusedSession = true;
+				} else {
+					const input = {
+						cwd: canonicalCwd,
+						prompt: undefined,
+						namespace: config.namespace,
+						worktree: true as const,
+					};
+					const started = services.startSession
+						? await services.startSession(input)
+						: await startTmuxSession(config, input, namespaceDir, commandRunner);
+					const startedRecord = asRecord(started);
+					if (!startedRecord) throw new Error("coordinator_session_command_required");
+					session = normalizeSession(startedRecord);
+					await writeJsonFile(sessionFile(session.session_id), session);
+					await appendCoordinatorEvent(namespaceDir, {
+						kind: "session.started",
+						sessionId: String(session.session_id),
+						summary: `Session ${String(session.session_id)} started by coordinator delegate`,
+						payloadRef: path.relative(namespaceDir, sessionFile(session.session_id)),
+						metadata: { delegate: true, workflow: delegateWorkflow },
+					});
+					const live = hasTmuxIdentity(session) ? await hasTmuxSession(session, commandRunner) : null;
+					await writeSessionState(namespaceDir, String(session.session_id), "ready_for_input", {
+						live,
+						reason: null,
+					});
+				}
+
+				const sessionId = String(session.session_id);
+				const activeTurn = reusedSession ? await readActiveTurn(namespaceDir, sessionId) : null;
+				if (activeTurn && args.force !== true && args.queue !== true) {
+					return {
+						ok: false,
+						reason: "active_turn_exists",
+						session_id: sessionId,
+						active_turn_id: activeTurn.turn_id,
+					};
+				}
+				if (activeTurn && args.force === true) {
+					const timestamp = new Date().toISOString();
+					const superseded = {
+						...activeTurn,
+						status: "superseded" as const,
+						updated_at: timestamp,
+						completed_at: timestamp,
+					};
+					await writeTurnRecord(namespaceDir, superseded);
+					await clearActiveTurn(namespaceDir, superseded);
+				}
+				const shouldQueue = args.queue === true && args.force !== true && !!activeTurn;
+				const turn = shouldQueue
+					? makeTurnRecord(config, sessionId, taggedPrompt, "queued")
+					: await activateTurn(session, makeTurnRecord(config, sessionId, taggedPrompt, "active"));
+				if (shouldQueue) await writeTurnRecord(namespaceDir, turn);
+				await appendCoordinatorEvent(namespaceDir, {
+					kind: "delegation.started",
+					sessionId,
+					turnId: turn.turn_id,
+					summary: `Delegated ${delegateWorkflow} via ${name} on session ${sessionId}`,
+					metadata: {
+						workflow: delegateWorkflow,
+						tool_name: name,
+						reused_session: reusedSession,
+						queued: shouldQueue,
+						allow_mutation: args.allow_mutation === true,
+					},
+				});
+				const sessionState = await readSessionState(namespaceDir, sessionId);
+				const base: Record<string, unknown> = {
+					ok: true,
+					workflow: delegateWorkflow,
+					tool_name: name,
+					session_id: sessionId,
+					turn_id: turn.turn_id,
+					active_turn_id: shouldQueue ? activeTurn?.turn_id : turn.turn_id,
+					status: turn.status,
+					queued: turn.delivery.queued,
+					delivered: turn.delivery.delivered,
+					delivery: turn.delivery,
+					session,
+					session_state: sessionState,
+					turn,
+					awaited: false,
+					artifacts: [],
+				};
+				if (promptAliasIgnored) base.prompt_alias_ignored = true;
+				if (args.await_completion === true && !shouldQueue) {
+					const timeoutMs = boundedTimeoutMs(args.timeout_ms);
+					const pollIntervalMs = boundedPollIntervalMs(args.poll_interval_ms);
+					const deadline = Date.now() + timeoutMs;
+					let payload = await readTurnPayload(turn.turn_id, sessionId, args.lines);
+					while (
+						payload.ok === true &&
+						!TERMINAL_TURN_STATUSES.has((payload.turn as TurnRecord).status) &&
+						Date.now() < deadline
+					) {
+						const remainingMs = deadline - Date.now();
+						await waitForTurnStateChange(
+							namespaceDir,
+							payload.turn as TurnRecord,
+							Math.min(pollIntervalMs, remainingMs),
+						);
+						payload = await readTurnPayload(turn.turn_id, sessionId, args.lines);
+					}
+					const awaitedTurn = (payload.ok === true ? payload.turn : turn) as TurnRecord;
+					base.awaited = true;
+					base.status = awaitedTurn.status;
+					base.turn = awaitedTurn;
+					base.final_response = (awaitedTurn as unknown as Record<string, unknown>).final_response ?? null;
+					base.evidence = (awaitedTurn as unknown as Record<string, unknown>).evidence ?? [];
+					if (payload.ok === true) {
+						base.session_state = payload.session_state;
+						base.advisory_status = payload.advisory_status;
+					}
+					// Mirror skc_coordinator_await_turn timeout semantics: a still-active
+					// turn at the deadline is a bounded timeout, not a completion.
+					if (!TERMINAL_TURN_STATUSES.has(awaitedTurn.status)) {
+						base.timed_out = true;
+						base.reason = "timeout";
+						base.ok = false;
+					}
+				}
+				return base;
+			}
 			if (name === "skc_coordinator_start_session") {
 				requireCoordinatorMutation(config, "sessions", args);
 				const cwd = await assertCoordinatorWorkdir(config, args.cwd);