dsh-github-copilot 0.4.0-alpha.18 → 0.4.0-alpha.20

package/lib/index.js

@@ -1,21 +1,757 @@
 import { C as currentSearchInitiator, D as GITHUB_COPILOT_CREDENTIAL_KEY, E as readCopilotCatalog, O as GITHUB_COPILOT_PREVIEW_PROVIDER_ID, S as currentChatRoute, T as isPluginPreviewProvider, _ as RESPONSES_WEB_SEARCH_TOOL_TYPE, a as COPILOT_HOSTED_SEARCH_PROVIDER_ID, b as candidatesForRoute, c as abortable$1, d as readBounded, f as applyRequestAuth, h as ANTHROPIC_WEB_SEARCH_TOOL_TYPE, i as describeSearchBackend, k as GITHUB_COPILOT_PROVIDER_ID, l as isAbortError, m as providerRequestHeaders, n as routeSessionSearch, o as GITHUB_COPILOT_HOSTED_SEARCH_PROVIDER_ID, p as normalizeRequestAuth, r as DescribedSearchFallbackError, s as createTraditionalSearchProvider, t as isCopilotSearchSelection, u as providerErrorMessage, v as SearchPlan, w as currentSearchSelection, x as sameCandidates, y as WEB_SEARCH_TOOL_TYPE } from "./search-routing-pFLux0W7.js";
 import AuthorizationService from "@deepseek-ai/dsh-authorization";
+import { createHash, randomUUID } from "node:crypto";
+import { Service } from "@deepseek-ai/cordis";
+import * as dshScope from "@deepseek-ai/dsh-scope";
+import { Remote, RemoteError, TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
+import z from "@deepseek-ai/schemastery";
+import { z as z$1 } from "zod";
 import * as dshLlm from "@deepseek-ai/dsh-llm";
 import { LlmError, attributionHeaders, contentHasImage, isAgentLoopRequest, resolveImageAttachmentAccess, resolveRetryPolicy } from "@deepseek-ai/dsh-llm";
 import { WebError } from "@deepseek-ai/dsh-web";
 import * as dshSettings from "@deepseek-ai/dsh-settings";
 import { getBuiltinModels } from "@earendil-works/pi-ai/providers/all";
 import { createModels, getSupportedThinkingLevels, hasApi, lazyStream } from "@earendil-works/pi-ai";
-import z from "@deepseek-ai/schemastery";
 import { credentialRef } from "@deepseek-ai/dsh-credentials";
-import { Remote, TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
-import { createHash, randomUUID } from "node:crypto";
 import { githubCopilotProvider } from "@earendil-works/pi-ai/providers/github-copilot";
 import { Config as Config$1, PiAiAdapter } from "@deepseek-ai/dsh-llm-pi-ai";
 import { buildCopilotDynamicHeaders, hasCopilotVisionInput } from "@earendil-works/pi-ai/api/github-copilot-headers";
+//#region lib/types/dual-model-host.js
+/** Optional plugin-owned planner/executor sessions; no Core/default-model mutation. */
+const DUAL_MODEL_NAMESPACE = "github-copilot-dual-model";
+const DUAL_MODEL_POLICY_EVENT = "github-copilot/dual-model-policy";
+const DUAL_MODEL_PROJECTION = "githubCopilotDualModelPolicy";
+const DUAL_MODEL_EXECUTE_TOOL = "copilot_execute";
+const DEFAULT_CONFIG = Object.freeze({
+	enabled: false,
+	plannerModel: "",
+	executorModel: ""
+});
+const configSchema = z.object({
+	enabled: z.boolean().default(false),
+	plannerModel: z.string().default(""),
+	executorModel: z.string().default("")
+});
+const ConfigJson = z$1.object({
+	enabled: z$1.boolean(),
+	plannerModel: z$1.string().max(512),
+	executorModel: z$1.string().max(512)
+}).strict();
+const RevisionJson = z$1.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
+const CreateJson = z$1.object({
+	requestId: z$1.string().uuid(),
+	workspaceId: z$1.string().min(1).max(512),
+	expectedRevision: RevisionJson
+}).strict();
+const SaveJson = z$1.object({
+	configuration: ConfigJson,
+	expectedRevision: RevisionJson
+}).strict();
+const CatalogEntryJson = z$1.object({
+	id: z$1.string().min(1).max(512),
+	name: z$1.string().min(1).max(1024)
+}).strict();
+const ExecuteJson = z$1.object({
+	description: z$1.string().min(1).max(160),
+	prompt: z$1.string().min(1).max(1e5)
+}).strict();
+const PolicyJson = z$1.object({
+	version: z$1.literal(1),
+	rootSessionId: z$1.string(),
+	requestId: z$1.string(),
+	workspaceId: z$1.string(),
+	settingsRevision: z$1.number().int().nonnegative(),
+	cwd: z$1.string(),
+	agentPreset: z$1.string(),
+	provider: z$1.literal(GITHUB_COPILOT_PREVIEW_PROVIDER_ID),
+	plannerModel: z$1.string().min(1),
+	executorModel: z$1.string().min(1),
+	executorTools: z$1.array(z$1.string()),
+	plannerTools: z$1.array(z$1.string())
+}).strict();
+const ChildJson = z$1.object({
+	version: z$1.literal(1),
+	mode: z$1.literal("continuable"),
+	provider: z$1.literal("spawn"),
+	agentProvider: z$1.string(),
+	agentModel: z$1.string()
+});
+const ProjectionJson = z$1.object({
+	id: z$1.string(),
+	parentId: z$1.string().nullable(),
+	origin: z$1.string().nullable(),
+	inherited: z$1.number(),
+	policy: PolicyJson.nullable(),
+	child: ChildJson.nullable(),
+	invalid: z$1.boolean()
+});
+/** A root policy is authoritative only in its own suffix, never in a fork seed. */
+const dualModelProjection = {
+	key: DUAL_MODEL_PROJECTION,
+	stateVersion: 1,
+	stateSchema: ProjectionJson,
+	init: (header, inherited = 0) => ({
+		id: header.id,
+		parentId: header.parentSession ?? null,
+		origin: header.origin ?? null,
+		inherited,
+		policy: null,
+		child: null,
+		invalid: false
+	}),
+	apply: (state, event) => {
+		if (event.seq < state.inherited) return state;
+		if (event.type === "github-copilot/dual-model-policy") {
+			const parsed = PolicyJson.safeParse(event.data);
+			if (state.policy !== null || !parsed.success || parsed.data.rootSessionId !== state.id || state.parentId !== null || event.ignorable !== true) return {
+				...state,
+				invalid: true
+			};
+			return {
+				...state,
+				policy: parsed.data
+			};
+		}
+		if (event.type === "subagent/descriptor" && state.origin === "subagent") {
+			const parsed = ChildJson.safeParse(event.data);
+			return {
+				...state,
+				child: parsed.success ? parsed.data : null
+			};
+		}
+		return state;
+	}
+};
+const ROOT_TOOLS = [
+	DUAL_MODEL_EXECUTE_TOOL,
+	"read",
+	"read_image",
+	"glob",
+	"grep",
+	"skill",
+	"ask_user_question",
+	"todo_write",
+	"send_message",
+	"list_agents",
+	"interrupt_agent"
+];
+const EXECUTOR_TOOLS = [
+	"read",
+	"read_image",
+	"glob",
+	"grep",
+	"skill",
+	"write",
+	"edit",
+	"pwsh",
+	"bash",
+	"present",
+	"todo_write",
+	"send_message",
+	"list_agents",
+	"interrupt_agent",
+	"job_list",
+	"job_output",
+	"job_kill"
+];
+const EXECUTOR_PERSONA = "You are the execution agent for a dedicated Copilot planner/executor session. Implement only the delegated task. Your provider and model are fixed by the session policy. Do not create other agents, workflows, dynamic plugins, or alternate model calls. Report the changed files, verification, limitations, and actual results to your direct parent with send_message. Do not claim tests or work you did not perform.";
+function roleText(policy, role) {
+	return role === "planner" ? `You are the planning and acceptance agent. Read the current code and evidence, plan, clarify, delegate implementation through ${DUAL_MODEL_EXECUTE_TOOL}, and independently review results. Do not implement changes or run commands directly. Your planning model is ${policy.plannerModel}; execution is fixed to ${policy.executorModel}. Use the original send_message/list_agents/interrupt_agent controls to continue and inspect your execution children. Provider: ${GITHUB_COPILOT_PREVIEW_PROVIDER_ID}.` : EXECUTOR_PERSONA;
+}
+function fail$1(reason, creation) {
+	throw new RemoteError("copilot/dual-model", reason, {
+		reason,
+		...creation === void 0 ? {} : { creation }
+	});
+}
+function creationOf(error) {
+	return ownRemoteFailure(error)?.creation ?? "uncertain";
+}
+function object$3(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function api$1(ctx, key, methods) {
+	const value = ctx.get(key);
+	return object$3(value) && methods.every((method) => typeof value[method] === "function") ? value : void 0;
+}
+function revision(value) {
+	return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+const ERROR_REASONS = /* @__PURE__ */ new Set([
+	"DUAL_MODEL_UNSUPPORTED",
+	"DUAL_MODEL_READ_ONLY",
+	"DUAL_MODEL_REVISION_CONFLICT",
+	"DUAL_MODEL_MODEL_UNAVAILABLE",
+	"DUAL_MODEL_WORKSPACE_UNAVAILABLE",
+	"DUAL_MODEL_DISABLED",
+	"DUAL_MODEL_INVALID_REQUEST",
+	"DUAL_MODEL_REQUEST_CONFLICT",
+	"DUAL_MODEL_SAVE_FAILED",
+	"DUAL_MODEL_CREATE_UNCERTAIN",
+	"DUAL_MODEL_POLICY_INVALID",
+	"DUAL_MODEL_SELECTION_LOCKED",
+	"DUAL_MODEL_DELEGATION_DENIED",
+	"DUAL_MODEL_EXECUTION_FAILED"
+]);
+/** Remote errors cross bundle/realm boundaries; constructor identity is not a protocol. */
+function ownRemoteFailure(error) {
+	try {
+		if (!object$3(error) || error.isDSHRemoteError !== true || error.code !== "copilot/dual-model" || !object$3(error.details)) return void 0;
+		const reason = error.details.reason;
+		if (typeof reason !== "string" || !ERROR_REASONS.has(reason)) return void 0;
+		const creation = error.details.creation;
+		return {
+			reason,
+			...creation === "not-created" || creation === "uncertain" ? { creation } : {}
+		};
+	} catch {
+		return;
+	}
+}
+function reasonOf(error, fallback) {
+	const own = ownRemoteFailure(error);
+	if (own) return own.reason;
+	try {
+		if (object$3(error) && error.code === "SETTINGS_CONFLICT") return "DUAL_MODEL_REVISION_CONFLICT";
+	} catch {}
+	return fallback;
+}
+function dualModelSessionId(requestId) {
+	return `copilot-dual-${createHash("sha256").update(requestId).digest("hex")}`;
+}
+function requestKey(request) {
+	return JSON.stringify([
+		request.requestId,
+		request.workspaceId,
+		request.expectedRevision
+	]);
+}
+function policyMatches(policy, request) {
+	return policy.requestId === request.requestId && policy.workspaceId === request.workspaceId && policy.settingsRevision === request.expectedRevision;
+}
+function dedicatedAddress(agent) {
+	const owned = /^copilot-dual-[0-9a-f]{64}$/;
+	return owned.test(agent.id) || agent.session.header.origin === "subagent" && owned.test(agent.session.header.parentSession ?? "");
+}
+/** Always mountable; missing optional APIs produce a safe unsupported view. */
+var GitHubCopilotDualModel = class extends Service {
+	owner;
+	lifetime = new AbortController();
+	creates = /* @__PURE__ */ new Map();
+	overlays = /* @__PURE__ */ new Map();
+	handles = /* @__PURE__ */ new Map();
+	settingsReady = false;
+	projectionReady = false;
+	registrationFailed = false;
+	constructor(ctx) {
+		super(ctx, "githubCopilotDualModel");
+		this.owner = { ctx };
+		ctx.inject(["settings"], (scope) => {
+			const settings = api$1(scope, "settings", [
+				"register",
+				"describe",
+				"replace"
+			]);
+			if (!settings) return;
+			try {
+				settings.register(DUAL_MODEL_NAMESPACE, configSchema);
+				this.settingsReady = true;
+			} catch {
+				this.registrationFailed = true;
+				return;
+			}
+			scope.effect(() => () => {
+				this.settingsReady = false;
+			});
+		});
+		ctx.inject(["sessionProjections"], (scope) => {
+			const projections = api$1(scope, "sessionProjections", ["register", "stateOf"]);
+			if (!projections) return;
+			try {
+				projections.register(dualModelProjection);
+				this.projectionReady = true;
+			} catch {
+				this.registrationFailed = true;
+				return;
+			}
+			scope.effect(() => () => {
+				this.projectionReady = false;
+			});
+		});
+		ctx.inject(["tools"], (scope) => {
+			api$1(scope, "tools", ["guard"])?.guard((exec) => exec.agent && dedicatedAddress(exec.agent) && !this.overlays.has(exec.agent) ? "DUAL_MODEL_UNSUPPORTED" : void 0);
+		});
+		ctx.on("agent/request", async ({ agent }, next) => {
+			const subject = agent;
+			if (dedicatedAddress(subject) && !this.overlays.has(subject)) {
+				this.restore(subject);
+				if (!this.overlays.has(subject)) fail$1("DUAL_MODEL_UNSUPPORTED");
+			}
+			return next();
+		}, { prepend: true });
+		ctx.on("system-prompt/assemble", async (_assembly, context, next) => {
+			const candidate = context.scope;
+			if (!candidate || !object$3(candidate.session) || !object$3(candidate.session.header) || !dedicatedAddress(candidate)) return next();
+			const rehydrating = !this.overlays.has(candidate);
+			if (rehydrating) this.restore(candidate);
+			const installed = this.overlays.get(candidate);
+			if (!installed) fail$1("DUAL_MODEL_UNSUPPORTED");
+			const result = await next(), { policy, role } = installed;
+			const allowed = new Set(role === "planner" ? policy.plannerTools : policy.executorTools);
+			const sectionName = "github-copilot:dual-model-role";
+			const schemas = rehydrating ? this.requireCapabilities().tools.schemas(candidate) : result.tools;
+			return {
+				...result,
+				sections: result.sections.some((section) => section.name === sectionName) ? result.sections : [...result.sections, {
+					name: sectionName,
+					text: roleText(policy, role)
+				}],
+				tools: schemas.filter((tool) => allowed.has(tool.name)),
+				variables: {
+					...result.variables,
+					provider: GITHUB_COPILOT_PREVIEW_PROVIDER_ID,
+					model: role === "planner" ? policy.plannerModel : policy.executorModel
+				}
+			};
+		}, { prepend: true });
+		ctx.on("agent/created", ({ agent }) => this.restore(agent));
+		ctx.on("agent/disposed", ({ agent }) => {
+			const subject = agent;
+			const overlay = this.overlays.get(subject);
+			this.overlays.delete(subject);
+			if (this.handles.get(agent.id)?.agent === subject) this.handles.delete(agent.id);
+			if (overlay) overlay.dispose().catch(() => {});
+		});
+		ctx.effect(() => async () => {
+			this.lifetime.abort();
+			await Promise.allSettled([...this.creates.values()].map((value) => value.promise));
+			const roots = [...this.overlays].filter(([, value]) => value.role === "planner").map(([agent]) => agent);
+			await api$1(ctx, "subagents", ["drainContinuableDescendants"])?.drainContinuableDescendants(roots).catch(() => {});
+			for (const [agent] of this.overlays) agent.cancel({ kind: "disposed" });
+			await Promise.allSettled([...this.overlays.keys()].map((agent) => agent.whenIdle()));
+			await Promise.allSettled([...this.handles.values()].map((handle) => handle.dispose()));
+			await Promise.allSettled([...this.overlays.values()].map((overlay) => overlay.dispose()));
+			this.handles.clear();
+			this.overlays.clear();
+		});
+		for (const agent of api$1(ctx, "agents", ["list"])?.list() ?? []) try {
+			this.restore(agent);
+		} catch {}
+	}
+	capabilities() {
+		if (typeof dshScope.createScope !== "function" || this.lifetime.signal.aborted || this.registrationFailed || !this.settingsReady || !this.projectionReady) return void 0;
+		const agents = api$1(this.owner.ctx, "agents", [
+			"list",
+			"get",
+			"create",
+			"resume"
+		]);
+		const workspaces = api$1(this.owner.ctx, "workspaceRegistry", ["get", "list"]);
+		const settings = api$1(this.owner.ctx, "settings", [
+			"register",
+			"describe",
+			"replace"
+		]);
+		const projections = api$1(this.owner.ctx, "sessionProjections", ["register", "stateOf"]);
+		const persistence = api$1(this.owner.ctx, "sessionPersistence", ["stat"]);
+		const sessions = api$1(this.owner.ctx, "sessions", ["flush"]);
+		const inspector = api$1(this.owner.ctx, "sessionController", ["inspect"]);
+		const presets = api$1(this.owner.ctx, "agentPresets", [
+			"resolve",
+			"mount",
+			"composedPreset",
+			"standingKeyFor"
+		]);
+		const llm = api$1(this.owner.ctx, "llm", ["resolveCallConfig"]);
+		const tools = api$1(this.owner.ctx, "tools", [
+			"register",
+			"restrict",
+			"guard",
+			"schemas",
+			"presentAs"
+		]);
+		const subagents = api$1(this.owner.ctx, "subagents", [
+			"getProvider",
+			"startContinuable",
+			"sendMessage",
+			"listChildren",
+			"drainContinuableDescendants"
+		]);
+		const preview = api$1(this.owner.ctx, "githubCopilotPreview", ["getView", "discover"]);
+		if (!agents || !workspaces || !settings || !projections || !persistence || !sessions || !inspector || !presets || !llm || !tools || !subagents || !preview) return void 0;
+		const provider = subagents.getProvider("spawn");
+		if (!provider || typeof provider.prepareContinuable !== "function" || !provider.capabilities.agentOptions || !provider.capabilities.persona || !provider.capabilities.toolFilter || !provider.capabilities.depthLimit) return void 0;
+		return {
+			agents,
+			workspaces,
+			settings,
+			projections,
+			persistence,
+			sessions,
+			inspector,
+			presets,
+			llm,
+			tools,
+			subagents,
+			preview
+		};
+	}
+	requireCapabilities() {
+		return this.capabilities() ?? fail$1("DUAL_MODEL_UNSUPPORTED");
+	}
+	configuration() {
+		const descriptor = api$1(this.owner.ctx, "settings", ["describe"])?.describe({ redactSecrets: true }).find((value) => value.ns === DUAL_MODEL_NAMESPACE);
+		if (!descriptor) return {
+			configuration: DEFAULT_CONFIG,
+			revision: null
+		};
+		const parsed = ConfigJson.safeParse(descriptor.value);
+		if (!parsed.success || !revision(descriptor.revision)) return fail$1("DUAL_MODEL_UNSUPPORTED");
+		return {
+			configuration: parsed.data,
+			revision: descriptor.revision
+		};
+	}
+	async view() {
+		const empty = {
+			supported: false,
+			diagnostic: "DUAL_MODEL_UNSUPPORTED",
+			writable: false,
+			revision: null,
+			configuration: DEFAULT_CONFIG,
+			models: [],
+			workspaces: []
+		};
+		try {
+			const configuration = this.configuration(), cap = this.capabilities();
+			if (!cap) return {
+				...empty,
+				...configuration
+			};
+			let models = [], diagnostic;
+			try {
+				const preview = await cap.preview.discover({
+					force: false,
+					signal: this.lifetime.signal
+				});
+				if (preview.available && preview.state === "ready") models = z$1.array(CatalogEntryJson).max(512).parse(preview.models.map(({ id, name }) => ({
+					id,
+					name
+				})));
+				else diagnostic = "DUAL_MODEL_MODEL_UNAVAILABLE";
+			} catch {
+				diagnostic = "DUAL_MODEL_MODEL_UNAVAILABLE";
+			}
+			return {
+				supported: true,
+				...diagnostic === void 0 ? {} : { diagnostic },
+				writable: cap.settings.writable === true,
+				...configuration,
+				models,
+				workspaces: z$1.array(CatalogEntryJson).max(1024).parse(cap.workspaces.list().map((workspace) => ({
+					id: workspace.id,
+					name: workspace.title
+				})))
+			};
+		} catch {
+			return empty;
+		}
+	}
+	async save(input) {
+		try {
+			return await this.saveOnce(input);
+		} catch (error) {
+			fail$1(reasonOf(error, "DUAL_MODEL_SAVE_FAILED"));
+		}
+	}
+	async saveOnce(input) {
+		const parsed = SaveJson.safeParse(input);
+		if (!parsed.success) fail$1("DUAL_MODEL_INVALID_REQUEST");
+		const cap = this.requireCapabilities(), { configuration, expectedRevision } = parsed.data;
+		if (cap.settings.writable !== true) fail$1("DUAL_MODEL_READ_ONLY");
+		if (this.configuration().revision !== expectedRevision) fail$1("DUAL_MODEL_REVISION_CONFLICT");
+		if (configuration.enabled) await this.assertModels(cap, [configuration.plannerModel, configuration.executorModel]);
+		try {
+			await cap.settings.replace(DUAL_MODEL_NAMESPACE, configuration, expectedRevision);
+		} catch (error) {
+			fail$1(reasonOf(error, "DUAL_MODEL_SAVE_FAILED"));
+		}
+		return this.view();
+	}
+	create(input) {
+		const parsed = CreateJson.safeParse(input);
+		if (!parsed.success) return Promise.reject(new RemoteError("copilot/dual-model", "DUAL_MODEL_INVALID_REQUEST", { reason: "DUAL_MODEL_INVALID_REQUEST" }));
+		const request = parsed.data, id = dualModelSessionId(request.requestId), key = requestKey(request);
+		const pending = this.creates.get(id);
+		if (pending) return pending.key === key ? pending.promise : Promise.reject(new RemoteError("copilot/dual-model", "DUAL_MODEL_REQUEST_CONFLICT", { reason: "DUAL_MODEL_REQUEST_CONFLICT" }));
+		const promise = this.createOnce(request, id).catch((error) => fail$1(reasonOf(error, "DUAL_MODEL_CREATE_UNCERTAIN"), creationOf(error)));
+		this.creates.set(id, {
+			key,
+			promise
+		});
+		promise.then(() => this.creates.delete(id), () => this.creates.delete(id));
+		return promise;
+	}
+	async createOnce(request, id) {
+		let creation = "uncertain";
+		try {
+			const cap = this.requireCapabilities();
+			if (await cap.persistence.stat(id) !== void 0 || cap.agents.get(id)) {
+				const inspection = await cap.inspector.inspect(id);
+				let state = dualModelProjection.init(inspection.meta, inspection.inheritedEventCount);
+				for (const event of inspection.events) state = dualModelProjection.apply(state, event);
+				if (state.invalid || !state.policy || !policyMatches(state.policy, request)) fail$1("DUAL_MODEL_REQUEST_CONFLICT");
+				const workspace = this.workspace(cap, request.workspaceId);
+				if (workspace.path !== state.policy.cwd) fail$1("DUAL_MODEL_REQUEST_CONFLICT");
+				await workspace.attachSession(id);
+				return { sessionId: id };
+			}
+			creation = "not-created";
+			const current = this.configuration();
+			if (current.revision !== request.expectedRevision) fail$1("DUAL_MODEL_REVISION_CONFLICT");
+			if (!current.configuration.enabled) fail$1("DUAL_MODEL_DISABLED");
+			const workspace = this.workspace(cap, request.workspaceId);
+			const captured = { ...current.configuration };
+			await this.assertModels(cap, [captured.plannerModel, captured.executorModel]);
+			const preset = await cap.presets.resolve();
+			const standingKey = await cap.presets.standingKeyFor(preset.id);
+			const inheritedNames = new Set(cap.tools.schemas(standingKey).map((tool) => tool.name));
+			const executorTools = EXECUTOR_TOOLS.filter((name) => inheritedNames.has(name));
+			if (!executorTools.includes("send_message")) fail$1("DUAL_MODEL_UNSUPPORTED");
+			if (this.configuration().revision !== request.expectedRevision) fail$1("DUAL_MODEL_REVISION_CONFLICT");
+			if (cap.workspaces.get(workspace.id) !== workspace) fail$1("DUAL_MODEL_WORKSPACE_UNAVAILABLE");
+			const policy = {
+				version: 1,
+				rootSessionId: id,
+				requestId: request.requestId,
+				workspaceId: workspace.id,
+				settingsRevision: request.expectedRevision,
+				cwd: workspace.path,
+				agentPreset: preset.id,
+				provider: GITHUB_COPILOT_PREVIEW_PROVIDER_ID,
+				plannerModel: captured.plannerModel,
+				executorModel: captured.executorModel,
+				plannerTools: [...ROOT_TOOLS],
+				executorTools: [...executorTools]
+			};
+			creation = "uncertain";
+			const handle = await cap.agents.create({
+				sessionId: id,
+				agentOptions: {
+					provider: GITHUB_COPILOT_PREVIEW_PROVIDER_ID,
+					model: policy.plannerModel
+				},
+				meta: {
+					cwd: policy.cwd,
+					agentPreset: preset.id,
+					isSeeded: false
+				},
+				inheritedEventCount: 0,
+				seed: [{
+					type: DUAL_MODEL_POLICY_EVENT,
+					seq: 0,
+					time: Date.now(),
+					ignorable: true,
+					data: policy
+				}, {
+					type: "model/selection",
+					seq: 1,
+					time: Date.now(),
+					data: {
+						provider: GITHUB_COPILOT_PREVIEW_PROVIDER_ID,
+						model: policy.plannerModel
+					}
+				}],
+				signal: this.lifetime.signal,
+				setup: async (agentCtx, agent) => {
+					await cap.presets.mount(agentCtx, preset.id);
+					this.install(agent, policy, "planner");
+				}
+			});
+			this.handles.set(id, handle);
+			if (!await cap.sessions.flush(handle.agent.session)) fail$1("DUAL_MODEL_CREATE_UNCERTAIN");
+			await workspace.attachSession(id);
+			return { sessionId: id };
+		} catch (error) {
+			fail$1(reasonOf(error, "DUAL_MODEL_CREATE_UNCERTAIN"), creation);
+		}
+	}
+	workspace(cap, id) {
+		const workspace = cap.workspaces.get(id);
+		if (!workspace || typeof workspace.path !== "string" || typeof workspace.attachSession !== "function") fail$1("DUAL_MODEL_WORKSPACE_UNAVAILABLE");
+		return workspace;
+	}
+	async assertModels(cap, models, signal = this.lifetime.signal) {
+		try {
+			signal.throwIfAborted();
+			const preview = await cap.preview.discover({
+				force: false,
+				signal
+			});
+			if (preview.provider !== "github-copilot-preview" || !preview.available || preview.state !== "ready") fail$1("DUAL_MODEL_MODEL_UNAVAILABLE");
+			for (const model of models) {
+				if (!model || !preview.models.some((item) => item.id === model)) fail$1("DUAL_MODEL_MODEL_UNAVAILABLE");
+				const resolved = await cap.llm.resolveCallConfig({
+					provider: GITHUB_COPILOT_PREVIEW_PROVIDER_ID,
+					model
+				}, signal);
+				if (resolved.provider !== "github-copilot-preview" || resolved.model !== model) fail$1("DUAL_MODEL_MODEL_UNAVAILABLE");
+			}
+			const now = cap.preview.getView();
+			if (!now.available || now.state !== "ready" || models.some((model) => !now.models.some((item) => item.id === model))) fail$1("DUAL_MODEL_MODEL_UNAVAILABLE");
+			signal.throwIfAborted();
+		} catch {
+			fail$1("DUAL_MODEL_MODEL_UNAVAILABLE");
+		}
+	}
+	projection(agent) {
+		const projections = api$1(this.owner.ctx, "sessionProjections", ["stateOf"]);
+		const parsed = ProjectionJson.safeParse(projections?.stateOf(agent.session, DUAL_MODEL_PROJECTION));
+		return parsed.success ? parsed.data : void 0;
+	}
+	restore(agent) {
+		if (this.overlays.has(agent)) return;
+		const state = this.projection(agent);
+		if (!state) {
+			if (dedicatedAddress(agent)) fail$1("DUAL_MODEL_UNSUPPORTED");
+			return;
+		}
+		if (state.invalid) fail$1("DUAL_MODEL_POLICY_INVALID");
+		if (state.policy) {
+			this.install(agent, state.policy, "planner");
+			return;
+		}
+		if (state.origin !== "subagent" || state.parentId === null) {
+			if (dedicatedAddress(agent)) fail$1("DUAL_MODEL_POLICY_INVALID");
+			return;
+		}
+		const parent = api$1(this.owner.ctx, "agents", ["get"])?.get(state.parentId);
+		if (!parent) {
+			if (dedicatedAddress(agent)) fail$1("DUAL_MODEL_UNSUPPORTED");
+			return;
+		}
+		if (this.overlays.get(parent)?.role === "executor") fail$1("DUAL_MODEL_DELEGATION_DENIED");
+		const parentPolicy = this.projection(parent)?.policy;
+		if (!parentPolicy) {
+			if (dedicatedAddress(agent)) fail$1("DUAL_MODEL_POLICY_INVALID");
+			return;
+		}
+		if (!state.child || state.child.agentProvider !== "github-copilot-preview" || state.child.agentModel !== parentPolicy.executorModel) fail$1("DUAL_MODEL_POLICY_INVALID");
+		this.install(agent, parentPolicy, "executor");
+	}
+	install(agent, policy, role) {
+		if (this.overlays.has(agent)) return;
+		this.requireCapabilities();
+		if (typeof agent.cancel !== "function" || typeof agent.whenIdle !== "function") fail$1("DUAL_MODEL_UNSUPPORTED");
+		const overlay = dshScope.createScope(agent.ctx, agent), scoped = overlay.ctx;
+		try {
+			const tools = api$1(scoped, "tools", [
+				"schemas",
+				"register",
+				"restrict",
+				"guard",
+				"presentAs"
+			]);
+			const prompt = api$1(scoped, "systemPrompt", ["section"]);
+			if (!tools || !prompt) fail$1("DUAL_MODEL_UNSUPPORTED");
+			const allowed = new Set(role === "planner" ? policy.plannerTools : policy.executorTools);
+			const available = tools.schemas(agent).map((item) => item.name);
+			tools.guard((exec) => allowed.has(exec.name) ? void 0 : "DUAL_MODEL_TOOL_DENIED");
+			tools.presentAs("native");
+			tools.restrict({ allow: available.filter((name) => allowed.has(name) && name !== "copilot_execute") });
+			const selectedModel = role === "planner" ? policy.plannerModel : policy.executorModel;
+			prompt.section({
+				name: "github-copilot:dual-model-role",
+				order: 1e3,
+				text: roleText(policy, role)
+			});
+			scoped.on("agent/request", async ({ signal }, next) => {
+				await this.assertModels(this.requireCapabilities(), [selectedModel], signal);
+				const resolved = await next();
+				if (resolved.provider !== "github-copilot-preview" || resolved.model !== selectedModel) fail$1("DUAL_MODEL_SELECTION_LOCKED");
+				return resolved;
+			}, { prepend: true });
+			if (role === "planner") tools.register({
+				name: DUAL_MODEL_EXECUTE_TOOL,
+				description: `Delegate implementation to a continuable executor fixed to ${GITHUB_COPILOT_PREVIEW_PROVIDER_ID}/${policy.executorModel}. Returns a durable child ID, not completion. Continue with send_message and inspect with list_agents. No model override or recursive delegation is allowed.`,
+				parameters: {
+					type: "object",
+					additionalProperties: false,
+					properties: {
+						description: { type: "string" },
+						prompt: { type: "string" }
+					},
+					required: ["description", "prompt"]
+				},
+				output: {
+					schema: {
+						type: "object",
+						additionalProperties: false,
+						properties: {
+							childId: { type: "string" },
+							provider: { type: "string" },
+							model: { type: "string" }
+						},
+						required: [
+							"childId",
+							"provider",
+							"model"
+						]
+					},
+					render: (_args, value) => [{
+						type: "text",
+						text: JSON.stringify(value)
+					}]
+				},
+				execute: async (input, exec) => {
+					try {
+						const parsed = ExecuteJson.safeParse(input);
+						if (!parsed.success || exec.agent !== agent) fail$1("DUAL_MODEL_INVALID_REQUEST");
+						const current = this.requireCapabilities();
+						await this.assertModels(current, [policy.executorModel], exec.signal);
+						return {
+							childId: (await current.subagents.startContinuable({
+								provider: "spawn",
+								label: parsed.data.description,
+								request: {
+									parent: agent,
+									prompt: [{
+										type: "text",
+										text: parsed.data.prompt
+									}],
+									agentOptions: {
+										provider: GITHUB_COPILOT_PREVIEW_PROVIDER_ID,
+										model: policy.executorModel
+									},
+									persona: EXECUTOR_PERSONA,
+									toolFilter: { allow: policy.executorTools },
+									maxDepth: 1
+								},
+								signal: exec.signal
+							})).childId,
+							provider: GITHUB_COPILOT_PREVIEW_PROVIDER_ID,
+							model: policy.executorModel
+						};
+					} catch (error) {
+						fail$1(reasonOf(error, "DUAL_MODEL_EXECUTION_FAILED"));
+					}
+				}
+			});
+			this.overlays.set(agent, {
+				dispose: overlay.dispose,
+				policy,
+				role
+			});
+		} catch (error) {
+			overlay.dispose().catch(() => {});
+			throw error;
+		}
+	}
+};
+//#endregion
 //#region package.json
 var name$1 = "dsh-github-copilot";
-var version = "0.4.0-alpha.18";
+var version = "0.4.0-alpha.20";
 //#endregion
 //#region lib/types/probe.js
 /**
@@ -1929,9 +2665,9 @@ async function createDeepSeekSearchFallback(ctx, owner, canContinue) {
 * @module dsh-github-copilot/compatibility
 */
 const DSH_COMPATIBILITY = {
-	release: "0.1.5-alpha.2",
+	release: "0.1.6-alpha.1",
 	developmentRelease: "0.1.2-rc.1",
-	peerRange: "0.1.1-rc.2 || 0.1.2-rc.1 || 0.1.3-alpha.1 || 0.1.5-alpha.1 || 0.1.5-alpha.2 || 0.1.5-rc.1 || 0.1.5-rc.2",
+	peerRange: "0.1.1-rc.2 || 0.1.2-rc.1 || 0.1.3-alpha.1 || 0.1.5-alpha.1 || 0.1.5-alpha.2 || 0.1.5-rc.1 || 0.1.5-rc.2 || 0.1.6-alpha.1",
 	supportedReleases: [
 		"0.1.1-rc.2",
 		"0.1.2-rc.1",
@@ -1939,7 +2675,8 @@ const DSH_COMPATIBILITY = {
 		"0.1.5-alpha.1",
 		"0.1.5-alpha.2",
 		"0.1.5-rc.1",
-		"0.1.5-rc.2"
+		"0.1.5-rc.2",
+		"0.1.6-alpha.1"
 	],
 	requiredApis: [
 		"agentDefaultModel.currentSelection",
@@ -4990,6 +5727,7 @@ function activate(ctx, config) {
 	});
 	ctx.plugin(preview_route_default, { accountModelSettings: () => current() });
 	ctx.plugin(GitHubCopilotAuthorizationController);
+	ctx.plugin(GitHubCopilotDualModel);
 	const resolveGitHubCopilotToken = createGitHubCopilotTokenResolver(ctx, async () => {
 		await ensureGitHubCopilotProviderProfile(ctx);
 	});