@openspecui/server 6.2.0 → 7.0.0

package/dist/index.mjs

@@ -1,6 +1,6 @@
 import { a as resolveCt2ModelDownloadPlanFromRepositoryFiles } from "./src-Dh_UAz5C.mjs";
 import { t as resolveGgufModelDownloadPlanFromRepositoryFiles } from "./src-CZfiVL_-.mjs";
-import { BatchTranslateInputSchema, CliExecutor, CliProjectionCommandError, CliProjectionNoticeSchema, CodeEditorThemeSchema, ConfigManager, CustomSoundHashSchema, DASHBOARD_METRIC_KEYS, DashboardConfigSchema, DashboardGitSnapshotSchema, DashboardSummaryInvalidationSchema, DashboardSummaryProjectionStateSchema, DashboardTrendsProjectionSchema, DocumentTranslationConfigUpdateSchema, EnvironmentGlobalConfigValueSchema, EnvironmentGlobalFileProjectionDataSchema, EnvironmentGlobalFileProjectionStateSchema, EnvironmentGlobalProjectionDataSchema, EnvironmentGlobalProjectionStateSchema, GitConfigSchema, GlobalSettingsManager, LocalModelAssetStateSchema, LocalModelLifecycleFileStateSchema, LocalModelLifecycleGroupStateSchema, LocalModelProfileManifestSchema, MarkdownParser, NotificationPublishInputSchema, NotificationSettingsSchema, OPENSPECUI_DOCUMENT_HOOK_VERSION, OPENSPECUI_WORKFLOW_HOOK_VERSION, OPSX_ARTIFACT_INPUT_ACTIONS, OPSX_CHANGE_INPUT_ACTIONS, OPSX_COMMAND_CAPABLE_WORKFLOWS, OPSX_CORE_PROFILE_WORKFLOWS, OPSX_TEXT_INPUT_ACTIONS, OpenSpecAdapter, OpenSpecDataHomeObserver, OpenSpecUIGlobalSettingsUpdateSchema, OpenSpecWatcher, OpsxConfigSchema, OpsxKernel, OwnedSpecIdentitySchema, PlanningCliProjectionDataSchema, PlanningCliProjectionSelectorSchema, PlanningCliProjectionStateSchema, ProjectBindingUpdateSchema, ProjectWatcher, PtyClientMessageSchema, RUNTIME_INVALIDATION_FACETS, ReactiveContext, ReactiveObservationEnvironment, ReactiveState, RuntimeInvalidationIndex, RuntimeRootInvalidationRegistry, ServiceTranslationEngineIdSchema, SpecIdentitySchema, StoreDoctorResultSchema, StoreListResultSchema, StoreMutationLifecycleEventSchema, StoreMutationStartResponseSchema, TRANSLATION_ENGINE_MANIFESTS, TerminalConfigSchema, TerminalControlParser, TerminalRendererEngineSchema, TranslationCacheReadInputSchema, TranslationCacheWriteInputSchema, TranslationEngineIdSchema, TranslationEngineLifecycleStatusSchema, acquireWatcher, buildBackendHealthPayload, buildLocalDownloadPlanFromRepositoryFiles, buildRuntimePackageInstallCommand, checkLocalDirectionalModelLanguagePair, classifyStoreCliResult, clearCache, computeEnvUri, constantTimeEqual, createCleanCliEnv, createPhysicalReactiveDirectory, createToolInitStateProjection, createTranslationEngineLifecycleStatus, detectRuntimePackageManager, getAllTools, getAvailableTools, getConfiguredTools, getDefaultCliCommandString, getDetectedProjectTools, getExternalCodexCommandObservationRoot, getManagedLocalTranslationEngineManifest, getOpsxEntityRootRelativePath, getRootContextCliSelector, getTranslationEngineLifecycleMessage, getWatcherRuntimeStatus, inferFileMime, inferFilePreviewKind, inspectProjectBinding, isDirectionalManagedLocalTranslationEngineId, isManagedLocalTranslationEngineId, isTerminalMutationStatus, isTranslationEngineDependencyReady, isTranslationEngineRuntimeReady, normalizeBatchTranslationError, parseCliCommandResult, parseOpsxEntityMetadata, parseOpsxSchemaDetail, reactiveReadFile, reactiveStat, removePhysicalReactivePath, requireCanonicalOpenSpecEntityId, requireOpenSpecEntityRelativePath, resolveOpenSpecDataScope, resolveRootContext, resolveRuntimePackageInstallStrategy, resolveTerminalShellDefaults, runPhysicalReactivePathMutation, selectLocalDownloadGroup, shouldShowTranslationEngineInstallGate, sniffGlobalCli, subscribeWatcherRuntimeStatus, terminalNotificationEventToPublishInput, toCliProjectionCommandEvidence, toCliProjectionFailure, toCliProjectionNotice, toStoreFeatureResult, toggleMarkdownTask, updateProjectBindingContent, updateReactiveFileCache, writePhysicalReactiveFile } from "@openspecui/core";
+import { AI_TOOLS, ActiveRootMutationSchema, ActiveRootRevisionSchema, AgentDeliveryPolicyUpdateSchema, BatchTranslateInputSchema, CliExecutor, CliProjectionCommandError, CliProjectionNoticeSchema, CodeEditorThemeSchema, ConfigManager, CustomSoundHashSchema, DASHBOARD_METRIC_KEYS, DashboardConfigSchema, DashboardGitSnapshotSchema, DashboardSummaryInvalidationSchema, DashboardSummaryProjectionStateSchema, DashboardTrendsProjectionSchema, DocumentTranslationConfigUpdateSchema, EnvironmentDefaultStoreUpdateSchema, EnvironmentGlobalConfigValueSchema, EnvironmentGlobalFileProjectionDataSchema, EnvironmentGlobalFileProjectionStateSchema, EnvironmentGlobalProjectionDataSchema, EnvironmentGlobalProjectionStateSchema, GitConfigSchema, GlobalSettingsManager, LocalModelAssetStateSchema, LocalModelLifecycleFileStateSchema, LocalModelLifecycleGroupStateSchema, LocalModelProfileManifestSchema, MarkdownParser, NotificationPublishInputSchema, NotificationSettingsSchema, OPENSPECUI_DOCUMENT_HOOK_VERSION, OPENSPECUI_WORKFLOW_HOOK_VERSION, OPSX_ARTIFACT_INPUT_ACTIONS, OPSX_CHANGE_INPUT_ACTIONS, OPSX_COMMAND_CAPABLE_WORKFLOWS, OPSX_CORE_PROFILE_WORKFLOWS, OPSX_TEXT_INPUT_ACTIONS, OpenSpecAdapter, OpenSpecDataHomeObserver, OpenSpecUIGlobalSettingsUpdateSchema, OpenSpecWatcher, OpsxConfigSchema, OpsxKernel, OwnedSpecIdentitySchema, PINNED_AGENT_GENERATOR_VERSION, PlanningCliProjectionDataSchema, PlanningCliProjectionSelectorSchema, PlanningCliProjectionStateSchema, ProjectBindingUpdateSchema, ProjectWatcher, PtyClientMessageSchema, RUNTIME_INVALIDATION_FACETS, ReactiveContext, ReactiveObservationEnvironment, ReactiveState, RuntimeInvalidationIndex, RuntimeRootInvalidationRegistry, ServiceTranslationEngineIdSchema, SpecIdentitySchema, StoreDoctorResultSchema, StoreListResultSchema, StoreMutationLifecycleEventSchema, StoreMutationStartResponseSchema, TRANSLATION_ENGINE_MANIFESTS, TerminalConfigSchema, TerminalControlParser, TerminalRendererEngineSchema, TranslationCacheReadInputSchema, TranslationCacheWriteInputSchema, TranslationEngineIdSchema, TranslationEngineLifecycleStatusSchema, acquireWatcher, applyAgentDeliveryPolicy, buildBackendHealthPayload, buildLocalDownloadPlanFromRepositoryFiles, buildRuntimePackageInstallCommand, checkLocalDirectionalModelLanguagePair, classifyStoreCliResult, clearCache, compareAndWriteAtomicPhysicalReactiveFile, computeEnvUri, constantTimeEqual, createCleanCliEnv, createPhysicalReactiveDirectory, createToolInitStateProjection, createTranslationEngineLifecycleStatus, detectRuntimePackageManager, getAllTools, getAvailableTools, getConfiguredTools, getDefaultCliCommandString, getDetectedProjectTools, getExternalCodexCommandObservationRoot, getManagedLocalTranslationEngineManifest, getOpsxEntityRootRelativePath, getRootContextCliSelector, getToolInitStates, getTranslationEngineLifecycleMessage, getWatcherRuntimeStatus, inferFileMime, inferFilePreviewKind, inspectActiveRootOfficialConfig, inspectEnvironmentDefaultStore, inspectProjectBinding, isDirectionalManagedLocalTranslationEngineId, isManagedLocalTranslationEngineId, isTerminalMutationStatus, isTranslationEngineDependencyReady, isTranslationEngineRuntimeReady, loadOpenSpecAgentCommandContents, normalizeAgentDeliveryPolicy, normalizeBatchTranslationError, parseCliCommandResult, parseOpsxEntityMetadata, parseOpsxSchemaDetail, patchActiveRootOfficialFields, reactiveReadFile, reactiveStat, removePhysicalReactivePath, requireCanonicalOpenSpecEntityId, requireCanonicalOpenSpecSpecId, requireOpenSpecEntityRelativePath, resolveOpenSpecDataScope, resolveRootContext, resolveRuntimePackageInstallStrategy, resolveTerminalShellDefaults, runPhysicalReactivePathMutation, selectLocalDownloadGroup, shouldShowTranslationEngineInstallGate, sniffGlobalCli, subscribeWatcherRuntimeStatus, terminalNotificationEventToPublishInput, toCliProjectionCommandEvidence, toCliProjectionFailure, toCliProjectionNotice, toStoreFeatureResult, toggleMarkdownTask, updateProjectBindingContent, updateReactiveFileCache, validateActiveRootRawYaml, writePhysicalReactiveFile } from "@openspecui/core";
 import { basename, dirname, extname, isAbsolute, join, matchesGlob, relative, resolve, sep } from "node:path";
 import { access, copyFile, lstat, mkdir, open, readFile, readlink, realpath, rename, rm, stat, symlink, unlink, writeFile } from "node:fs/promises";
 import { fileURLToPath, pathToFileURL } from "node:url";
@@ -25,7 +25,7 @@ import { execFile, spawn } from "node:child_process";
 import { promisify } from "node:util";
 import { NotificationGroupKeySchema, NotificationPublishInputSchema as NotificationPublishInputSchema$1, getNotificationGroupKey } from "@openspecui/core/notifications";
 import { match } from "ts-pattern";
-import { buildSpecCatalog, specIdentityKey, specRoutePath } from "@openspecui/core/spec-catalog";
+import { buildSpecCatalog, specDocumentDisplayPath, specIdentityKey, specRoutePath } from "@openspecui/core/spec-catalog";
 import { DiagConsoleLogger, DiagLogLevel, SpanStatusCode, diag, trace } from "@opentelemetry/api";
 import { EventEmitter } from "node:events";
 import { ProjectSearchDocumentSchema, ProjectSearchHitSchema, ProjectSearchQuerySchema, parseProjectSearchHits } from "@openspecui/search";
@@ -2945,6 +2945,290 @@ function resolveDefaultServerHostIdentity() {
 	return `hostname:${value}`;
 }
 
+//#endregion
+//#region src/agent-delivery-projection-service.ts
+/**
+* Orthogonal intents (created 2026-08-01 Asia/Shanghai):
+* 1. Combine the complete OpenSpec 1.7 Agent registry with authoritative Environment delivery policy.
+* 2. Expose fresh one-shot physical projections through Core `getToolInitStates`.
+* 3. Retain reactive physical projections through Core `createToolInitStateProjection`.
+* 4. Rebind retained work when Environment policy changes and retire all work on dispose.
+*
+* Original request (2026-08-01): "新增 Agent delivery projection service 及 checked tests。"
+*/
+/** Raised when the CLI-owned Environment projection cannot provide an executable Agent policy. */
+var AgentDeliveryPolicyUnavailableError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "AgentDeliveryPolicyUnavailableError";
+	}
+};
+function cloneCommandContent(content) {
+	if (content.kind === "toml") return {
+		kind: content.kind,
+		fields: [...content.fields]
+	};
+	return {
+		kind: content.kind,
+		frontmatter: content.frontmatter.kind === "yaml" ? {
+			kind: content.frontmatter.kind,
+			fields: [...content.frontmatter.fields]
+		} : { kind: content.frontmatter.kind },
+		bodyLayout: content.bodyLayout
+	};
+}
+function cloneCommand(command) {
+	if (!command) return null;
+	return {
+		...command,
+		content: cloneCommandContent(command.content),
+		invocation: { ...command.invocation },
+		...command.legacyPathTemplates ? { legacyPathTemplates: [...command.legacyPathTemplates] } : {}
+	};
+}
+function cloneCleanup(cleanup) {
+	if (!cleanup) return void 0;
+	if (cleanup.kind === "project-patterns") return {
+		kind: cleanup.kind,
+		patterns: [...cleanup.patterns]
+	};
+	return {
+		kind: cleanup.kind,
+		projectPatterns: [...cleanup.projectPatterns],
+		managedFiles: Object.fromEntries(Object.entries(cleanup.managedFiles).map(([fileName, workflows]) => [fileName, [...workflows]])),
+		replacementLabel: cleanup.replacementLabel
+	};
+}
+function cloneRegistry() {
+	return AI_TOOLS.map((tool) => ({
+		name: tool.name,
+		value: tool.value,
+		available: tool.available,
+		skillsDir: tool.skillsDir,
+		capability: tool.capability,
+		command: cloneCommand(tool.command),
+		...tool.successLabel !== void 0 ? { successLabel: tool.successLabel } : {},
+		...tool.detectionPaths ? { detectionPaths: [...tool.detectionPaths] } : {},
+		...tool.setupNote !== void 0 ? { setupNote: tool.setupNote } : {},
+		...tool.aliases ? { aliases: [...tool.aliases] } : {},
+		...tool.cleanup ? { cleanup: cloneCleanup(tool.cleanup) } : {},
+		...tool.migrations ? { migrations: tool.migrations.map((migration) => ({ ...migration })) } : {}
+	}));
+}
+function resolvePolicy(environment) {
+	const { profileState } = environment;
+	if (!profileState.available) throw new AgentDeliveryPolicyUnavailableError(profileState.error ?? "Environment Agent delivery policy is unavailable.");
+	if (!profileState.profile) throw new AgentDeliveryPolicyUnavailableError("Environment Agent delivery profile is unavailable.");
+	if (!profileState.delivery) throw new AgentDeliveryPolicyUnavailableError("Environment Agent delivery mode is unavailable.");
+	return { ...normalizeAgentDeliveryPolicy(profileState) };
+}
+function policyFingerprint(policy) {
+	return JSON.stringify([
+		policy.profile,
+		policy.delivery,
+		policy.workflows
+	]);
+}
+async function resolveGeneratorEvidence(cliExecutor, cliCommandAuthority, workflows) {
+	const availability = await cliExecutor.checkAvailability();
+	return {
+		version: availability.available && availability.version ? availability.version : PINNED_AGENT_GENERATOR_VERSION,
+		commandContents: availability.available ? await loadOpenSpecAgentCommandContents(await cliCommandAuthority.getCliCommand(), workflows) : null
+	};
+}
+function createProjection(policy, states) {
+	return {
+		registry: cloneRegistry(),
+		policy: {
+			profile: policy.profile,
+			delivery: policy.delivery,
+			workflows: [...policy.workflows]
+		},
+		states: [...states]
+	};
+}
+var RetainedAgentDeliveryProjection = class {
+	authorityGeneration = 0;
+	environmentSubscription = null;
+	physicalController = null;
+	physicalGeneration = 0;
+	currentPolicyFingerprint = null;
+	disposed = false;
+	constructor(options, listener, preparePhysicalObservation, onDispose) {
+		this.options = options;
+		this.listener = listener;
+		this.preparePhysicalObservation = preparePhysicalObservation;
+		this.onDispose = onDispose;
+		this.environmentSubscription = options.environmentGlobalProjectionService.subscribe(() => {
+			this.rebindFromEnvironment();
+		});
+		this.rebindFromEnvironment();
+	}
+	replacePolicy(policy) {
+		if (this.disposed) return;
+		this.bindPolicy(policy, true);
+	}
+	unsubscribe() {
+		if (this.disposed) return;
+		this.disposed = true;
+		this.authorityGeneration += 1;
+		this.environmentSubscription?.unsubscribe();
+		this.environmentSubscription = null;
+		this.stopPhysicalProjection();
+		this.onDispose();
+	}
+	rebindFromEnvironment() {
+		const generation = ++this.authorityGeneration;
+		this.options.environmentGlobalProjectionService.getCurrent().then((environment) => {
+			if (this.disposed || generation !== this.authorityGeneration) return;
+			return this.preparePhysicalObservation().then(() => {
+				if (this.disposed || generation !== this.authorityGeneration) return;
+				return resolveGeneratorEvidence(this.options.cliExecutor, this.options.cliCommandAuthority, environment.profileState.workflows).then((generatorEvidence) => {
+					if (this.disposed || generation !== this.authorityGeneration) return;
+					this.startPhysicalProjection(resolvePolicy(environment), generatorEvidence, false);
+				});
+			});
+		}).catch((cause) => {
+			if (this.disposed || generation !== this.authorityGeneration) return;
+			this.stopPhysicalProjection();
+			this.listener({
+				type: "failed",
+				error: cause instanceof Error ? cause : new Error(String(cause))
+			});
+		});
+	}
+	bindPolicy(policy, force) {
+		const generation = ++this.authorityGeneration;
+		Promise.all([this.preparePhysicalObservation(), resolveGeneratorEvidence(this.options.cliExecutor, this.options.cliCommandAuthority, policy.workflows)]).then(([, generatorEvidence]) => {
+			if (this.disposed || generation !== this.authorityGeneration) return;
+			this.startPhysicalProjection(policy, generatorEvidence, force);
+		}).catch((cause) => {
+			if (this.disposed || generation !== this.authorityGeneration) return;
+			this.stopPhysicalProjection();
+			this.listener({
+				type: "failed",
+				error: cause instanceof Error ? cause : new Error(String(cause))
+			});
+		});
+	}
+	startPhysicalProjection(policy, generatorEvidence, force) {
+		const fingerprint = `${policyFingerprint(policy)}:${generatorEvidence.version}`;
+		if (!force && this.physicalController && fingerprint === this.currentPolicyFingerprint) return;
+		this.stopPhysicalProjection();
+		this.currentPolicyFingerprint = fingerprint;
+		const generation = ++this.physicalGeneration;
+		const controller = new AbortController();
+		this.physicalController = controller;
+		const context = new ReactiveContext();
+		const projectToolInitStates = createToolInitStateProjection(this.options.projectDir, {
+			...policy,
+			generatorVersion: generatorEvidence.version,
+			commandContents: generatorEvidence.commandContents
+		});
+		(async () => {
+			try {
+				for await (const states of context.stream(projectToolInitStates, controller.signal)) {
+					if (this.disposed || controller.signal.aborted || generation !== this.physicalGeneration) return;
+					this.listener({
+						type: "snapshot",
+						projection: createProjection(policy, states)
+					});
+				}
+			} catch (cause) {
+				if (this.disposed || controller.signal.aborted || generation !== this.physicalGeneration) return;
+				this.listener({
+					type: "failed",
+					error: cause instanceof Error ? cause : new Error(String(cause))
+				});
+			}
+		})();
+	}
+	stopPhysicalProjection() {
+		this.physicalGeneration += 1;
+		this.physicalController?.abort();
+		this.physicalController = null;
+		this.currentPolicyFingerprint = null;
+	}
+};
+/** Server-owned Agent registry and physical delivery projection boundary. */
+var AgentDeliveryProjectionService = class {
+	subscriptions = /* @__PURE__ */ new Set();
+	observationStartPromise = null;
+	observationReleases = [];
+	disposed = false;
+	constructor(options) {
+		this.options = options;
+	}
+	/** Read one fresh projection from the current Environment policy and physical files. */
+	async getCurrent() {
+		this.assertActive();
+		const environment = await this.options.environmentGlobalProjectionService.getCurrent();
+		this.assertActive();
+		const policy = resolvePolicy(environment);
+		const generatorEvidence = await resolveGeneratorEvidence(this.options.cliExecutor, this.options.cliCommandAuthority, policy.workflows);
+		const states = await getToolInitStates(this.options.projectDir, {
+			...policy,
+			generatorVersion: generatorEvidence.version,
+			commandContents: generatorEvidence.commandContents
+		});
+		this.assertActive();
+		return createProjection(policy, states);
+	}
+	/** Retain Environment policy and physical Agent artifact observation until unsubscribed. */
+	subscribe(listener) {
+		this.assertActive();
+		let subscription;
+		subscription = new RetainedAgentDeliveryProjection(this.options, listener, () => this.ensurePhysicalObservation(), () => {
+			this.subscriptions.delete(subscription);
+		});
+		this.subscriptions.add(subscription);
+		return subscription;
+	}
+	/** Refresh Environment authority, return a fresh Pull, and replace every retained projection. */
+	async refresh() {
+		this.assertActive();
+		this.options.environmentGlobalProjectionService.refresh();
+		const projection = await this.getCurrent();
+		for (const subscription of this.subscriptions) subscription.replacePolicy(projection.policy);
+		return projection;
+	}
+	/** Retire retained Environment and physical projection work. */
+	async dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		for (const subscription of this.subscriptions) subscription.unsubscribe();
+		this.subscriptions.clear();
+		await this.observationStartPromise?.catch(() => {});
+		const releases = this.observationReleases;
+		this.observationReleases = [];
+		await Promise.all(releases.map((release) => release()));
+	}
+	assertActive() {
+		if (this.disposed) throw new Error("Agent delivery projection service is disposed.");
+	}
+	ensurePhysicalObservation() {
+		this.assertActive();
+		if (this.observationStartPromise) return this.observationStartPromise;
+		const startPromise = (async () => {
+			const releases = [];
+			try {
+				releases.push(await this.options.observationEnvironment.acquireRoot(this.options.projectDir));
+				releases.push(await this.options.observationEnvironment.acquireRoot(getExternalCodexCommandObservationRoot()));
+				if (this.disposed) {
+					await Promise.all(releases.map((release) => release()));
+					return;
+				}
+				this.observationReleases = releases;
+			} catch (cause) {
+				await Promise.all(releases.map((release) => release()));
+				throw cause;
+			}
+		})();
+		this.observationStartPromise = startPromise;
+		return startPromise;
+	}
+};
+
 //#endregion
 //#region src/projection-work/phase-trace.ts
 /**
@@ -5757,16 +6041,17 @@ function parseOpsxConfigDrift(output) {
 //#endregion
 //#region src/planning-config-service.ts
 /**
-* Orthogonal intents (updated 2026-07-27 Asia/Shanghai):
-* 1. Read launch-project binding and active-root config from physically distinct roots.
+* Orthogonal intents (updated 2026-08-02 Asia/Shanghai):
+* 1. Read launch-project binding and reusable YAML source from its physical owner.
 * 2. Project environment-global config, profile, and drift through one CLI-owned reactive read.
-* 3. Mutate only the explicitly selected ownership facet and refresh reactive caches.
+* 3. Mutate Project Binding or Environment Global only and refresh reactive caches.
 * 4. Return launch-file write evidence without waiting for Planning-root service convergence.
-* 5. Keep editable Environment Global file bytes in a file-native owner separate from CLI Work.
+* 5. Keep configured Environment defaults separate from effective Root Context and file bytes.
 *
 * Original request (2026-07-15): "Config ownership separates launch-project binding, active-root config, and environment-global config."
 * Original request (2026-07-18): "Profile/Drift must refresh with external environment config changes."
 * Derived requirement (2026-07-19): "Project Binding mutation uses write-then-converge settlement."
+* Derived requirement (2026-08-02): "Active Root revision-aware mutation moves to its own physical service."
 */
 function projectEnvironmentProfileState(config, configError, driftEvidence) {
 	if (!config) return {
@@ -5798,7 +6083,8 @@ function projectEnvironmentProfileState(config, configError, driftEvidence) {
 		warningText: drift.warningText
 	};
 }
-async function readProjectConfigFile(options) {
+/** Read the preferred config.yaml/config.yml source under one physical project or Store root. */
+async function readPlanningYamlConfigFile(options) {
 	const yamlPath = join(options.rootPath, "openspec", "config.yaml");
 	const yaml = await reactiveReadFile(yamlPath);
 	if (yaml !== null) return {
@@ -5824,7 +6110,7 @@ async function readProjectConfigFile(options) {
 }
 /** Read project-owned Store and Reference declarations from the launch project. */
 async function readProjectBindingConfig(input) {
-	const file = await readProjectConfigFile({ rootPath: input.launchProjectDir });
+	const file = await readPlanningYamlConfigFile({ rootPath: input.launchProjectDir });
 	return {
 		kind: "project-binding",
 		owner: {
@@ -5836,22 +6122,6 @@ async function readProjectBindingConfig(input) {
 		rootPreview: input.rootPreview
 	};
 }
-/** Read configuration owned by the currently selected writable Planning root. */
-async function readActiveRootConfig(input) {
-	const planningRoot = input.rootContext.planningRoot;
-	if (!planningRoot) throw new Error("Planning root is unavailable.");
-	return {
-		kind: "active-root",
-		owner: {
-			kind: "planning-root",
-			path: planningRoot.path,
-			source: planningRoot.source,
-			storeId: input.rootContext.storeId,
-			externalToLaunchProject: planningRoot.path !== input.launchProjectDir
-		},
-		file: await readProjectConfigFile({ rootPath: planningRoot.path })
-	};
-}
 /** Resolve and read the CLI-selected environment-global configuration file. */
 async function readEnvironmentGlobalConfig(input) {
 	const [pathEvidence, configResult, driftEvidence] = await Promise.all([
@@ -5874,6 +6144,7 @@ async function readEnvironmentGlobalConfig(input) {
 		},
 		configPath,
 		config: configEvidence.data,
+		defaultStore: inspectEnvironmentDefaultStore(configEvidence.data),
 		profileState: projectEnvironmentProfileState(configEvidence.data, configEvidence.contractError ?? (configEvidence.success ? void 0 : configEvidence.stderr || "Failed to load profile config."), driftEvidence),
 		evidence: {
 			path: pathEvidence,
@@ -5906,14 +6177,14 @@ async function writeConfigFile(path, content) {
 }
 /** Update only project binding fields in the launch-project configuration. */
 async function writeProjectBindingConfig(input) {
-	const file = await readProjectConfigFile({ rootPath: input.launchProjectDir });
+	const file = await readPlanningYamlConfigFile({ rootPath: input.launchProjectDir });
 	if (!file.path) throw new Error("Launch-project config path is unavailable.");
 	await writePhysicalReactiveFile({
 		rootPath: input.launchProjectDir,
 		relativePath: join("openspec", file.format === "yml" ? "config.yml" : "config.yaml"),
 		content: updateProjectBindingContent(file.content, input.update)
 	});
-	const writtenFile = await readProjectConfigFile({ rootPath: input.launchProjectDir });
+	const writtenFile = await readPlanningYamlConfigFile({ rootPath: input.launchProjectDir });
 	return {
 		state: "write-complete",
 		owner: {
@@ -5925,12 +6196,6 @@ async function writeProjectBindingConfig(input) {
 		completedAt: Date.now()
 	};
 }
-/** Replace the active Planning-root configuration through its reactive file owner. */
-async function writeActiveRootConfig(input) {
-	const active = await readActiveRootConfig(input);
-	if (!active.file.path) throw new Error("Active-root config path is unavailable.");
-	await writeConfigFile(active.file.path, input.content);
-}
 /** Replace the CLI-selected environment-global configuration document. */
 async function writeEnvironmentGlobalConfig(input) {
 	const pathEvidence = await input.cliExecutor.execute(["config", "path"]);
@@ -5939,17 +6204,33 @@ async function writeEnvironmentGlobalConfig(input) {
 	if (!configPath) throw new Error("OpenSpec global config path is empty.");
 	await writeConfigFile(configPath, `${JSON.stringify(input.config, null, 2)}\n`);
 }
+/** Set or explicitly clear only the official machine `defaultStore` field through the CLI. */
+async function writeEnvironmentDefaultStore(input) {
+	const args = input.update.value ? [
+		"config",
+		"set",
+		"defaultStore",
+		input.update.value,
+		"--string"
+	] : [
+		"config",
+		"unset",
+		"defaultStore"
+	];
+	const result = await input.cliExecutor.execute(args);
+	if (!result.success) throw new Error(result.stderr || `OpenSpec ${args.slice(0, 3).join(" ")} failed.`);
+	return result;
+}
 
 //#endregion
 //#region src/environment-global-projection-service.ts
 /**
-* Orthogonal intents (created 2026-07-26 Asia/Shanghai):
-* 1. Own Environment Global CLI truth at the Server runtime-environment boundary.
+* Orthogonal intents (updated 2026-08-01 Asia/Shanghai):
+* 1. Own Environment Global CLI truth, including configured `defaultStore`, at runtime scope.
 * 2. Track the CLI-resolved config path as a dynamic reactive dependency.
 * 3. Expose immediate Pull, lifecycle-only Push, explicit refresh, and settled compatibility reads.
-* 4. Keep runtime-environment Work independent from Planning-root replacement.
-* 5. Own and retire the observed physical config-path lease for the active CLI result.
-* 6. Keep editable file bytes in a separate file-native Projection Work owner.
+* 4. Keep editable file bytes physically separate from CLI projection Work.
+* 5. Retire path leases and refresh Environment plus Root only after physical config replacement settles.
 *
 * Original request (2026-07-26): "展开全面的接口升级和内核升级和测试升级。"
 */
@@ -5968,9 +6249,15 @@ var EnvironmentGlobalProjectionService = class {
 	configPathGeneration = 0;
 	disposed = false;
 	fileBridgeSubscription = null;
+	configFileSettlementSubscription = null;
+	configFileSettlementGeneration = 0;
 	constructor(options) {
 		this.options = options;
 	}
+	/** Keep machine-config observation alive even when no Config page is mounted. */
+	start() {
+		this.ensureFileBridge();
+	}
 	/** Retire the dynamic config-path lease before the Server observation environment closes. */
 	async dispose() {
 		if (this.disposed) return;
@@ -5979,20 +6266,24 @@ var EnvironmentGlobalProjectionService = class {
 		this.configPathObservation = null;
 		this.fileBridgeSubscription?.unsubscribe();
 		this.fileBridgeSubscription = null;
+		this.configFileSettlementSubscription?.unsubscribe();
+		this.configFileSettlementSubscription = null;
 		await observation?.release();
 	}
 	read() {
 		return this.options.workOwner.registry.read(this.identity()) ?? this.loadingState();
 	}
 	refresh() {
-		this.options.workOwner.registry.invalidate(this.identity());
 		this.ensureFileBridge();
+		this.options.workOwner.registry.invalidate(this.identity());
 		return this.read();
 	}
 	subscribe(listener) {
+		this.ensureFileBridge();
 		return this.options.workOwner.registry.subscribeLifecycle(this.request(), listener);
 	}
 	getCurrent() {
+		this.ensureFileBridge();
 		return new Promise((resolve$1, reject) => {
 			let settled = false;
 			let subscription = null;
@@ -6078,7 +6369,7 @@ var EnvironmentGlobalProjectionService = class {
 				gitBindingToken: null
 			},
 			selector: "config+profile+drift",
-			inputFingerprint: "openspec-cli-1.6:config-path+list-json+list",
+			inputFingerprint: "openspec-cli-1.7:config-path+list-json+list+default-store",
 			protocolVersion: 1
 		};
 	}
@@ -6113,7 +6404,7 @@ var EnvironmentGlobalProjectionService = class {
 				gitBindingToken: null
 			},
 			selector: "config-file",
-			inputFingerprint: "openspec-cli-1.6:config-path+file-bytes",
+			inputFingerprint: "openspec-cli-1.7:config-path+file-bytes",
 			protocolVersion: 1
 		};
 	}
@@ -6157,6 +6448,12 @@ var EnvironmentGlobalProjectionService = class {
 			if (!cliState?.data || !fileState?.data || nextPath === currentPath) return;
 			this.options.workOwner.fileRegistry.invalidate(this.fileIdentity(), "dependency");
 		});
+		this.configFileSettlementSubscription = this.options.workOwner.fileRegistry.subscribeLifecycle(this.fileRequest(), (notice) => {
+			if (notice.invalidationCause !== "dependency" || notice.state !== "ready" || notice.workGeneration <= this.configFileSettlementGeneration) return;
+			this.configFileSettlementGeneration = notice.workGeneration;
+			this.options.workOwner.registry.invalidate(this.identity(), "dependency");
+			this.options.onConfigFileSettled?.();
+		});
 	}
 	loadingState() {
 		return {
@@ -8298,11 +8595,12 @@ async function readSpecDocument(source, identity) {
 //#endregion
 //#region src/planning-cli-projection-service.ts
 /**
-* Orthogonal intents (updated 2026-07-27 Asia/Shanghai):
-* 1. Own selector-exact OPSX and Spec Projection Work, including Reference-content invalidation, for one Planning-root record.
+* Orthogonal intents (updated 2026-08-02 Asia/Shanghai):
+* 1. Own selector-exact OPSX Status/Instructions and Spec Projection Work for one Planning-root record.
 * 2. Execute typed Kernel/CLI readers against one reactive Manager-owned Root Context value per Work generation.
 * 3. Expose immediate Pull, lifecycle-only Push, explicit refresh, and settled compatibility reads.
 * 4. Share one bounded typed registry across replaceable Planning-root records.
+* 5. Retire every config-dependent CLI Work generation before Active Root mutation settlement escapes its lease.
 *
 * Original request (2026-07-26): "展开全面的接口升级和内核升级和测试升级。"
 * Owner architecture clarification (2026-07-26): "将这些变更信息收集起来作为触发器，更新底层幂等计算的缓存结果。"
@@ -8345,6 +8643,14 @@ var PlanningCliProjectionService = class {
 		this.options.workOwner.registry.invalidate(this.identity(selector));
 		return this.read(selector);
 	}
+	/** Retire every current-root CLI Work item whose result depends on Active Root configuration. */
+	invalidateConfigDependentWork() {
+		const rootContext = this.currentRootContext();
+		const planningRoot = rootContext.planningRoot;
+		if (!planningRoot) return;
+		const generation = rootContext.generation ?? this.options.gitBindingToken;
+		this.options.workOwner.registry.invalidateMatching((identity) => identity.projectionKind === "planning-cli" && identity.planningRoot.identity === planningRoot.path && identity.owner.generation === generation && (identity.selector === "opsx-status" || identity.selector === "opsx-change-list" || identity.selector === "opsx-status-list" || identity.selector === "opsx-instructions" || identity.selector === "opsx-apply-instructions" || identity.selector === "opsx-archive-instructions" || identity.selector === "opsx-config-bundle" || identity.selector === "opsx-templates" || identity.selector === "opsx-template-contents"), "dependency");
+	}
 	subscribe(rawSelector, listener) {
 		const selector = this.selector(rawSelector);
 		return this.options.workOwner.registry.subscribeLifecycle(this.request(selector), listener);
@@ -8400,6 +8706,9 @@ var PlanningCliProjectionService = class {
 		})).with({ kind: "opsx-apply-instructions" }, (value) => ({
 			...value,
 			change: requireCanonicalOpenSpecEntityId(value.change, "changeId")
+		})).with({ kind: "opsx-archive-instructions" }, (value) => ({
+			...value,
+			change: requireCanonicalOpenSpecEntityId(value.change, "changeId")
 		})).otherwise((value) => value);
 	}
 	identity(selector) {
@@ -8439,7 +8748,7 @@ var PlanningCliProjectionService = class {
 		};
 	}
 	trackDependencies(selector) {
-		match(selector).with({ kind: "spec-catalog" }, { kind: "spec-document" }, () => {}).with({ kind: "opsx-status" }, { kind: "opsx-change-list" }, { kind: "opsx-status-list" }, () => this.options.invalidation.track("schemas")).with({ kind: "opsx-instructions" }, { kind: "opsx-apply-instructions" }, () => this.options.invalidation.track("schemas")).with({ kind: "opsx-config-bundle" }, { kind: "opsx-templates" }, { kind: "opsx-template-contents" }, () => this.options.invalidation.track("schemas")).exhaustive();
+		match(selector).with({ kind: "spec-catalog" }, { kind: "spec-document" }, () => {}).with({ kind: "opsx-status" }, { kind: "opsx-change-list" }, { kind: "opsx-status-list" }, () => this.options.invalidation.track("schemas")).with({ kind: "opsx-instructions" }, { kind: "opsx-apply-instructions" }, { kind: "opsx-archive-instructions" }, () => this.options.invalidation.track("schemas")).with({ kind: "opsx-config-bundle" }, { kind: "opsx-templates" }, { kind: "opsx-template-contents" }, () => this.options.invalidation.track("schemas")).exhaustive();
 	}
 	invalidateSpecObservation(change) {
 		if (change.kind === "doctor-root") return;
@@ -8449,7 +8758,7 @@ var PlanningCliProjectionService = class {
 		const planningRoot = rootContext.planningRoot;
 		if (!planningRoot) return;
 		const generation = rootContext.generation ?? this.options.gitBindingToken;
-		this.options.workOwner.registry.invalidateMatching((identity) => identity.projectionKind === "planning-cli" && identity.planningRoot.identity === planningRoot.path && identity.owner.generation === generation && (identity.selector === "spec-catalog" || identity.selector === "spec-document" || identity.selector === "opsx-instructions" || identity.selector === "opsx-apply-instructions"), "dependency");
+		this.options.workOwner.registry.invalidateMatching((identity) => identity.projectionKind === "planning-cli" && identity.planningRoot.identity === planningRoot.path && identity.owner.generation === generation && (identity.selector === "spec-catalog" || identity.selector === "spec-document" || identity.selector === "opsx-instructions" || identity.selector === "opsx-apply-instructions" || identity.selector === "opsx-archive-instructions"), "dependency");
 	}
 	currentRootContext() {
 		return this.options.rootContext instanceof PlanningCliRootContextState ? this.options.rootContext.get() : this.options.rootContext;
@@ -8475,6 +8784,10 @@ var PlanningCliProjectionService = class {
 		})).with({ kind: "opsx-apply-instructions" }, async ({ change, schema }) => ({
 			kind: "opsx-apply-instructions",
 			value: await this.options.kernel.readApplyInstructionsProjection(change, schema)
+		})).with({ kind: "opsx-archive-instructions" }, async ({ change, schema }) => ({
+			kind: "opsx-archive-instructions",
+			rootGeneration: rootContext.generation ?? this.options.gitBindingToken,
+			value: await this.options.kernel.readArchiveInstructionsProjection(change, schema)
 		})).with({ kind: "opsx-config-bundle" }, async () => ({
 			kind: "opsx-config-bundle",
 			...await this.options.kernel.readConfigBundleProjection()
@@ -9983,7 +10296,7 @@ async function collectSearchDocuments(adapter, documentService, resolveEntityRea
 			scope: "active-root",
 			title: spec.name,
 			href: specRoutePath(identity),
-			path: `owned:openspec/specs/${spec.id}/spec.md`,
+			path: specDocumentDisplayPath(identity),
 			content: typeof raw === "string" ? raw : raw.markdown,
 			updatedAt: spec.updatedAt
 		});
@@ -9994,7 +10307,7 @@ async function collectSearchDocuments(adapter, documentService, resolveEntityRea
 		scope: "referenced-specs",
 		title: spec.name,
 		href: specRoutePath(spec.identity),
-		path: `referenced:${spec.identity.storeId}:specs/${spec.identity.specId}`,
+		path: specDocumentDisplayPath(spec.identity),
 		content: `Requirement count: ${spec.requirementCount}`,
 		updatedAt: 0
 	});
@@ -10168,10 +10481,10 @@ var SearchService = class {
 //#endregion
 //#region src/workflow-invocation-service.ts
 /**
-* Orthogonal intents (updated 2026-07-20 Asia/Shanghai):
+* Orthogonal intents (updated 2026-08-01 Asia/Shanghai):
 * 1. Resolve OPSX compose/command/direct invocation modes.
 * 2. Bind every invocation to the CLI-selected Root Context and Store selector.
-* 3. Preserve command-specific Status/Instructions evidence through hooks and clients.
+* 3. Preserve command-specific Status, Apply, Artifact, and Archive Instructions evidence through hooks and clients.
 * 4. Generate Agent/CLI payloads without reconstructing planning paths.
 * 5. Return Manager-owned root generation and target evidence for stale-dispatch guards.
 *
@@ -10313,9 +10626,9 @@ function buildArchivePrompt(changeId, evidence, target) {
 		"",
 		...targetContextLines(target),
 		"",
-		"CLI-owned workflow-status evidence:",
+		"CLI-owned archive-instructions evidence:",
 		"```json",
-		normalized.length > 0 ? normalized : "(no status output)",
+		normalized.length > 0 ? normalized : "(no archive-instructions output)",
 		"```",
 		"",
 		"Please confirm archive readiness, highlight risks, and provide the exact next steps."
@@ -10468,12 +10781,16 @@ var WorkflowInvocationService = class {
 			};
 			case "update":
 			case "verify":
-			case "sync":
-			case "archive": return {
+			case "sync": return {
 				kind: "workflow-status",
 				options,
 				result: await this.options.contracts.workflowStatus(input.changeId, options)
 			};
+			case "archive": return {
+				kind: "archive-instructions",
+				options,
+				result: await this.options.contracts.archiveInstructions(input.changeId, options)
+			};
 			case "explore":
 			case "propose":
 			case "new":
@@ -12453,7 +12770,7 @@ var RootContextProjectionService = class {
 				gitBindingToken: null
 			},
 			selector: JSON.stringify({ dataScopePath: this.options.dataScopePath }),
-			inputFingerprint: "openspec-cli-1.6:doctor+context",
+			inputFingerprint: "openspec-cli-1.7:doctor+context+global-default",
 			protocolVersion: 1
 		};
 	}
@@ -12478,6 +12795,131 @@ var RootContextProjectionService = class {
 	}
 };
 
+//#endregion
+//#region src/active-root-config-service.ts
+/**
+* Orthogonal intents (updated 2026-08-02 Asia/Shanghai):
+* 1. Project exact Active Root owner, file, official fields, diagnostics, and revision.
+* 2. Serialize in-process mutations by physical config path and compare loaded ownership evidence.
+* 3. Apply Structured node patches or Raw whole-document syntax validation.
+* 4. Convert atomic physical compare/write outcomes into typed latest-source recovery results.
+*
+* Original request (2026-08-01): preserve raw YAML writes for team-defined keys outside the official standard.
+* Derived checkpoint (2026-08-02): parallel and external stale saves return conflicts with latest physical source.
+*/
+const mutationTails = /* @__PURE__ */ new Map();
+function createRevision(config) {
+	const source = JSON.stringify({
+		owner: config.owner,
+		file: {
+			path: config.file.path,
+			exists: config.file.exists,
+			content: config.file.content
+		}
+	});
+	return ActiveRootRevisionSchema.parse(`sha256:${createHash("sha256").update(source).digest("hex")}`);
+}
+async function serializeMutation(path, mutation) {
+	const execution = (mutationTails.get(path) ?? Promise.resolve()).catch(() => void 0).then(mutation);
+	const tail = execution.then(() => void 0, () => void 0);
+	mutationTails.set(path, tail);
+	try {
+		return await execution;
+	} finally {
+		if (mutationTails.get(path) === tail) mutationTails.delete(path);
+	}
+}
+/** Read the exact active Planning-root YAML source and derive its opaque loaded revision. */
+async function readActiveRootConfig(input) {
+	const planningRoot = input.rootContext.planningRoot;
+	if (!planningRoot) throw new Error("Planning root is unavailable.");
+	const file = await readPlanningYamlConfigFile({ rootPath: planningRoot.path });
+	const inspection = inspectActiveRootOfficialConfig(file.content);
+	const configWithoutRevision = {
+		kind: "active-root",
+		owner: {
+			kind: "planning-root",
+			path: planningRoot.path,
+			source: planningRoot.source,
+			storeId: input.rootContext.storeId,
+			externalToLaunchProject: planningRoot.path !== input.launchProjectDir
+		},
+		file,
+		...inspection
+	};
+	return {
+		...configWithoutRevision,
+		revision: createRevision(configWithoutRevision)
+	};
+}
+function conflictReason(latest, mutation) {
+	if (latest.owner.path !== mutation.ownerPath) return "owner-changed";
+	if (latest.file.path !== mutation.filePath) return "file-changed";
+	if (latest.revision !== mutation.revision) return "revision-changed";
+	return null;
+}
+function structuredSourceDiagnostics(latest) {
+	const sourceDiagnostics = latest.diagnostics.filter(({ code }) => code === "config-unparseable" || code === "config-not-mapping");
+	return sourceDiagnostics.length > 0 ? sourceDiagnostics : [{
+		code: "config-not-mapping",
+		severity: "error",
+		path: "$",
+		message: "The current Active Root source cannot be edited in Structured mode."
+	}];
+}
+/**
+* Apply one exact-revision Structured or Raw mutation through atomic physical compare-and-write.
+* Conflicts and invalid sources retain the latest authoritative projection for explicit recovery.
+*/
+async function mutateActiveRootConfig(input) {
+	const mutation = ActiveRootMutationSchema.parse(input.mutation);
+	return serializeMutation((await readActiveRootConfig(input)).file.path, async () => {
+		const latest = await readActiveRootConfig(input);
+		const reason = conflictReason(latest, mutation);
+		if (reason) return {
+			state: "conflict",
+			reason,
+			latest
+		};
+		let content;
+		if (mutation.mode === "raw") {
+			const validation = validateActiveRootRawYaml(mutation.content);
+			if (!validation.valid) return {
+				state: "invalid",
+				reason: "raw-syntax",
+				diagnostics: validation.diagnostics,
+				latest
+			};
+			content = mutation.content;
+		} else try {
+			content = patchActiveRootOfficialFields(latest.file.content, mutation.update);
+		} catch {
+			return {
+				state: "invalid",
+				reason: "structured-source",
+				diagnostics: structuredSourceDiagnostics(latest),
+				latest
+			};
+		}
+		const write$1 = await compareAndWriteAtomicPhysicalReactiveFile({
+			rootPath: latest.owner.path,
+			relativePath: relative(latest.owner.path, latest.file.path),
+			expectedContent: latest.file.content,
+			content
+		});
+		const settled = await readActiveRootConfig(input);
+		if (write$1.state === "conflict") return {
+			state: "conflict",
+			reason: "revision-changed",
+			latest: settled
+		};
+		return {
+			state: "applied",
+			config: settled
+		};
+	});
+}
+
 //#endregion
 //#region src/cli-mutation-invalidator.ts
 /** Settlement boundary shared by buffered and streaming CLI mutation execution. */
@@ -13322,6 +13764,7 @@ function getOpenSpecMutationFacets(args) {
 	if (args.includes("--help") || args.includes("-h")) return null;
 	const command = findCommand(args);
 	if (!command) return null;
+	if (command === "init") return PROJECT_SCHEMA_FACETS;
 	if (PROJECT_MUTATION_COMMANDS.has(command)) return PROJECT_CONTEXT_FACETS;
 	const subcommand = findSubcommand(args.slice(args.indexOf(command) + 1), command === "config" ? new Set(["--scope"]) : void 0);
 	if (command === "schema" && subcommand && SCHEMA_MUTATION_COMMANDS.has(subcommand)) return PROJECT_SCHEMA_FACETS;
@@ -13331,6 +13774,146 @@ function getOpenSpecMutationFacets(args) {
 	return null;
 }
 
+//#endregion
+//#region src/project-initialization-operation.ts
+function createDeferred() {
+	let resolve$1;
+	let reject;
+	return {
+		promise: new Promise((promiseResolve, promiseReject) => {
+			resolve$1 = promiseResolve;
+			reject = promiseReject;
+		}),
+		resolve: resolve$1,
+		reject
+	};
+}
+/** Server-local single-operation owner for Launch Project initialization. */
+var ProjectInitializationOperationOwner = class {
+	active = null;
+	records = /* @__PURE__ */ new Map();
+	start(input) {
+		const existing = this.records.get(input.requestId);
+		if (existing) {
+			for (const event of existing.events) input.onEvent(event);
+			if (this.active === existing) existing.listeners.add(input.onEvent);
+			return existing.handle;
+		}
+		if (this.active) throw new Error(`Project initialization ${this.active.requestId} is already running.`);
+		const terminal = createDeferred();
+		let successSettlementStarted = false;
+		let cancelRequested = false;
+		let rawHandle = null;
+		let record;
+		const emit = (event) => {
+			record.events.push(event);
+			for (const listener of record.listeners) listener(event);
+		};
+		const settleSuccess = (event) => {
+			if (successSettlementStarted) return;
+			successSettlementStarted = true;
+			input.settleSuccess().then(() => {
+				emit(event);
+				terminal.resolve({
+					reason: "exited",
+					exitCode: 0
+				});
+			}, (error) => {
+				emit({
+					type: "stderr",
+					data: error instanceof Error ? error.message : String(error)
+				});
+				emit({
+					type: "exit",
+					exitCode: 1
+				});
+				terminal.resolve({
+					reason: "exited",
+					exitCode: 1
+				});
+			});
+		};
+		const handle = {
+			settled: terminal.promise,
+			cancel: () => {
+				if (!cancelRequested) {
+					cancelRequested = true;
+					if (rawHandle) rawHandle.cancel().catch((error) => terminal.reject(error));
+					else terminal.resolve({
+						reason: "cancelled",
+						exitCode: null
+					});
+				}
+				return terminal.promise;
+			}
+		};
+		record = {
+			requestId: input.requestId,
+			handle,
+			events: [],
+			listeners: new Set([input.onEvent])
+		};
+		this.active = record;
+		this.retain(record);
+		try {
+			rawHandle = input.start((event) => {
+				if (event.type === "exit" && event.exitCode === 0) {
+					settleSuccess(event);
+					return;
+				}
+				emit(event);
+			});
+		} catch (error) {
+			terminal.reject(error);
+			throw error;
+		}
+		rawHandle.settled.then((settlement) => {
+			if (settlement.reason === "exited" && settlement.exitCode === 0) return;
+			terminal.resolve(settlement);
+		}, (error) => terminal.reject(error));
+		terminal.promise.finally(() => {
+			if (this.active === record) this.active = null;
+		}).catch(() => {});
+		return handle;
+	}
+	cancel(requestId) {
+		const existing = this.records.get(requestId);
+		if (existing) return existing.handle.cancel();
+		const settlement = {
+			reason: "cancelled",
+			exitCode: null
+		};
+		const handle = {
+			settled: Promise.resolve(settlement),
+			cancel: () => Promise.resolve(settlement)
+		};
+		this.retain({
+			requestId,
+			handle,
+			events: [{
+				type: "exit",
+				exitCode: null
+			}],
+			listeners: /* @__PURE__ */ new Set()
+		});
+		return Promise.resolve(settlement);
+	}
+	retain(record) {
+		this.records.set(record.requestId, record);
+		while (this.records.size > 256) {
+			const oldestRequestId = this.records.keys().next().value;
+			if (!oldestRequestId) return;
+			const oldest = this.records.get(oldestRequestId);
+			if (oldest === this.active) {
+				this.records.delete(oldestRequestId);
+				this.records.set(oldestRequestId, oldest);
+				continue;
+			}
+			this.records.delete(oldestRequestId);
+		}
+	}
+};
+
 //#endregion
 //#region src/reactive-kv.ts
 /**
@@ -14147,6 +14730,37 @@ function streamOpenSpecCliMutation(ctx, args, start, onEvent) {
 	if (!facets) return start(onEvent);
 	return new CliMutationInvalidator(ctx.runtimeInvalidation).stream(facets, start, onEvent);
 }
+const projectInitializationOwners = /* @__PURE__ */ new WeakMap();
+const projectInitializationInput = z.object({ requestId: z.string().min(1).max(128) });
+function projectInitializationOwner(ctx) {
+	const existing = projectInitializationOwners.get(ctx.cliExecutor);
+	if (existing) return existing;
+	const owner = new ProjectInitializationOperationOwner();
+	projectInitializationOwners.set(ctx.cliExecutor, owner);
+	return owner;
+}
+async function waitForLaunchProjectInitialization(ctx) {
+	const timeoutAt = Date.now() + 5e3;
+	while (Date.now() < timeoutAt) {
+		if ((await ctx.launchProjectAdapter.readLaunchProjectInitialization()).initialized) return;
+		await new Promise((resolve$1) => setTimeout(resolve$1, 25));
+	}
+	throw new Error("OpenSpec CLI exited successfully, but the Launch Project openspec/ directory did not settle.");
+}
+async function settleProjectInitializationReplacements(ctx) {
+	ctx.rootContextProjectionService.refresh();
+	await Promise.all([waitForLaunchProjectInitialization(ctx), ctx.rootContextProjectionService.getCurrent()]);
+	await Promise.all([
+		fetchProjectBindingConfig(ctx),
+		fetchActiveRootConfig(ctx),
+		runPlanningRootRead(ctx, async ({ planningCliProjectionService }) => {
+			const projection = await planningCliProjectionService.getCurrent({ kind: "opsx-config-bundle" });
+			if (projection.kind !== "opsx-config-bundle") throw new Error("Unexpected OPSX Config-bundle projection after project initialization.");
+			return projection.value;
+		}),
+		ctx.agentDeliveryProjectionService.refresh()
+	]);
+}
 /** Project-backend notification query, subscription, and mutation procedures. */
 const notificationsRouter = router({
 	list: publicProcedure.query(({ ctx }) => {
@@ -14667,7 +15281,7 @@ const specRouter = router({
 		identity: OwnedSpecIdentitySchema,
 		content: z.string()
 	})).mutation(async ({ ctx, input }) => {
-		const specId = requireCanonicalOpenSpecEntityId(input.identity.specId, "specId");
+		const specId = requireCanonicalOpenSpecSpecId(input.identity.specId);
 		await runPlanningRoot(ctx, ({ adapter }) => adapter.writeSpec(specId, input.content));
 		return { success: true };
 	}),
@@ -14756,10 +15370,34 @@ const changeRouter = router({
 /**
 * Init router - project initialization
 */
-const initRouter = router({ init: publicProcedure.mutation(async ({ ctx }) => {
-	await ctx.launchProjectAdapter.init();
-	return { success: true };
-}) });
+const initRouter = router({
+	get: publicProcedure.query(({ ctx }) => ctx.launchProjectAdapter.readLaunchProjectInitialization()),
+	subscribe: publicProcedure.subscription(({ ctx }) => {
+		return observable((emit) => {
+			const reactiveContext = new ReactiveContext();
+			const controller = new AbortController();
+			(async () => {
+				try {
+					for await (const state of reactiveContext.stream(() => ctx.launchProjectAdapter.readLaunchProjectInitialization(), controller.signal)) emit.next(state);
+				} catch (error) {
+					if (!controller.signal.aborted) emit.error(error instanceof Error ? error : new Error(String(error)));
+				}
+			})();
+			return () => controller.abort();
+		});
+	}),
+	initStream: publicProcedure.input(projectInitializationInput).subscription(({ ctx, input }) => {
+		return createCliStreamObservable((onEvent) => {
+			return projectInitializationOwner(ctx).start({
+				requestId: input.requestId,
+				onEvent,
+				start: (operationEvent) => streamOpenSpecCliMutation(ctx, ["init"], (mutationEvent) => ctx.cliExecutor.initProjectStream(ctx.projectDir, mutationEvent), operationEvent),
+				settleSuccess: () => settleProjectInitializationReplacements(ctx)
+			});
+		});
+	}),
+	cancel: publicProcedure.input(projectInitializationInput).mutation(({ ctx, input }) => projectInitializationOwner(ctx).cancel(input.requestId))
+});
 /**
 * Archive router - archived changes
 */
@@ -14943,13 +15581,6 @@ const configRouter = router({
 		});
 	})
 });
-function buildPlanningRootUpdateArgs(rootContext, options = {}) {
-	const planningRoot = rootContext.planningRoot;
-	if (!planningRoot) throw new Error("Planning root is unavailable.");
-	const args = ["update", planningRoot.path];
-	if (options.force) args.push("--force");
-	return args;
-}
 /**
 * CLI router - execute external openspec CLI commands
 */
@@ -14966,46 +15597,21 @@ const cliRouter = router({
 		], emitEvent), onEvent, () => ctx.configManager.invalidateResolvedCliRunner()));
 	}),
 	getAvailableTools: publicProcedure.query(() => {
-		return getAvailableTools().map((tool) => ({
-			name: tool.name,
-			value: tool.value,
-			available: tool.available,
-			successLabel: tool.successLabel
-		}));
+		return getAvailableTools();
 	}),
 	getAllTools: publicProcedure.query(() => {
-		return getAllTools().map((tool) => ({
-			name: tool.name,
-			value: tool.value,
-			available: tool.available,
-			successLabel: tool.successLabel
-		}));
+		return getAllTools();
 	}),
 	subscribeDetectedProjectTools: publicProcedure.subscription(({ ctx }) => {
-		return createReactiveSubscription(async () => {
-			return (await getDetectedProjectTools(ctx.projectDir)).map((tool) => ({
-				name: tool.name,
-				value: tool.value,
-				available: tool.available,
-				successLabel: tool.successLabel
-			}));
-		});
+		return createReactiveSubscription(() => getDetectedProjectTools(ctx.projectDir));
 	}),
-	subscribeToolInitStates: publicProcedure.input(z.object({
-		delivery: z.enum([
-			"both",
-			"skills",
-			"commands"
-		]),
-		workflows: z.array(z.string()).default([])
-	})).subscription(({ ctx, input }) => {
-		const projectToolInitStates = createToolInitStateProjection(ctx.projectDir, {
-			delivery: input.delivery,
-			workflows: input.workflows
-		});
-		return createReactiveSubscription(async () => {
-			await ctx.toolCommandObservation.start();
-			return projectToolInitStates();
+	subscribeToolInitStates: publicProcedure.subscription(({ ctx }) => {
+		return observable((emit) => {
+			const subscription = ctx.agentDeliveryProjectionService.subscribe((event) => {
+				if (event.type === "snapshot") emit.next([...event.projection.states]);
+				else emit.error(event.error);
+			});
+			return () => subscription.unsubscribe();
 		});
 	}),
 	getConfiguredTools: publicProcedure.query(async ({ ctx }) => {
@@ -15014,21 +15620,6 @@ const cliRouter = router({
 	subscribeConfiguredTools: publicProcedure.subscription(({ ctx }) => {
 		return createReactiveSubscription(() => getConfiguredTools(ctx.projectDir));
 	}),
-	init: publicProcedure.input(z.object({
-		tools: z.union([
-			z.array(z.string()),
-			z.literal("all"),
-			z.literal("none")
-		]).optional(),
-		profile: z.enum(["core", "custom"]).optional(),
-		force: z.boolean().optional()
-	}).optional()).mutation(async ({ ctx, input }) => {
-		return runOpenSpecCliMutation(ctx, ["init"], () => ctx.cliExecutor.init({
-			tools: input?.tools,
-			profile: input?.profile,
-			force: input?.force
-		}));
-	}),
 	validate: publicProcedure.input(z.discriminatedUnion("kind", [z.object({
 		kind: z.literal("item"),
 		id: z.string().min(1),
@@ -15074,41 +15665,19 @@ const cliRouter = router({
 			}, onEvent);
 		});
 	}),
-	update: publicProcedure.input(z.object({ force: z.boolean().optional() }).optional()).mutation(async ({ ctx, input }) => {
-		return runPlanningRoot(ctx, ({ rootContext }) => {
-			const args = buildPlanningRootUpdateArgs(rootContext, input);
-			return runOpenSpecCliMutation(ctx, args, () => ctx.cliExecutor.execute(args));
-		});
-	}),
-	updateStream: publicProcedure.input(z.object({ force: z.boolean().optional() }).optional()).subscription(({ ctx, input }) => {
-		return createPlanningRootCliStreamObservable(ctx, ({ rootContext }, onEvent) => {
-			const args = buildPlanningRootUpdateArgs(rootContext, input);
-			return streamOpenSpecCliMutation(ctx, args, (mutationEvent) => ctx.cliExecutor.executeStream(args, mutationEvent), onEvent);
-		});
-	}),
-	initStream: publicProcedure.input(z.object({
-		tools: z.union([
-			z.array(z.string()),
-			z.literal("all"),
-			z.literal("none")
-		]).optional(),
-		profile: z.enum(["core", "custom"]).optional(),
-		force: z.boolean().optional()
-	}).optional()).subscription(({ ctx, input }) => {
-		return createCliStreamObservable((onEvent) => streamOpenSpecCliMutation(ctx, ["init"], (mutationEvent) => ctx.cliExecutor.initStream({
-			tools: input?.tools,
-			profile: input?.profile,
-			force: input?.force
-		}, mutationEvent), onEvent));
-	}),
 	archiveStrictStream: publicProcedure.input(z.object({
 		changeId: z.string(),
+		expectedRootGeneration: z.string().min(1),
 		skipSpecs: z.boolean().optional(),
 		noValidate: z.boolean().optional()
 	})).subscription(({ ctx, input }) => {
 		return createCliStreamObservable((onEvent) => {
 			const changeId = requireCanonicalOpenSpecEntityId(input.changeId, "changeId");
-			return startPlanningRootCliStream(ctx, ({ rootContext }, leasedEvent) => {
+			return startPlanningRootCliStream(ctx, ({ rootContext, gitBindingToken }, leasedEvent) => {
+				if (input.expectedRootGeneration !== gitBindingToken) throw new TRPCError({
+					code: "CONFLICT",
+					message: "Planning root changed before archive started. Refresh Archive inputs and try again."
+				});
 				const selector = getRootContextCliSelector(rootContext);
 				return startStrictArchiveStream({
 					skipValidation: input.noValidate === true,
@@ -15129,6 +15698,49 @@ const cliRouter = router({
 		});
 	})
 });
+/** Config-owned Agent registry, policy, physical inventory, and CLI mutation boundary. */
+const agentIntegrationToolIdSchema = z.string().min(1).refine((toolId) => getAvailableTools().some((tool) => tool.value === toolId), "Agent tool must be an available OpenSpec 1.7 registry id.");
+const agentIntegrationsRouter = router({
+	get: publicProcedure.query(({ ctx }) => ctx.agentDeliveryProjectionService.getCurrent()),
+	refresh: publicProcedure.query(({ ctx }) => ctx.agentDeliveryProjectionService.refresh()),
+	subscribe: publicProcedure.subscription(({ ctx }) => {
+		return observable((emit) => {
+			const subscription = ctx.agentDeliveryProjectionService.subscribe((event) => {
+				if (event.type === "snapshot") emit.next(event.projection);
+				else emit.error(event.error);
+			});
+			return () => subscription.unsubscribe();
+		});
+	}),
+	updatePolicy: publicProcedure.input(AgentDeliveryPolicyUpdateSchema).mutation(async ({ ctx, input }) => {
+		const config = applyAgentDeliveryPolicy((await ctx.environmentGlobalProjectionService.getCurrent()).config, input);
+		await runOpenSpecCliMutation(ctx, ["config", "set"], () => writeEnvironmentGlobalConfig({
+			cliExecutor: ctx.cliExecutor,
+			config
+		}));
+		ctx.environmentGlobalProjectionService.refreshFile();
+		return ctx.agentDeliveryProjectionService.refresh();
+	}),
+	initStream: publicProcedure.input(z.object({
+		tools: z.union([z.array(agentIntegrationToolIdSchema).min(1), z.literal("all")]),
+		force: z.boolean().optional()
+	})).subscription(({ ctx, input }) => {
+		return createCliStreamObservable(async (onEvent) => {
+			const projection = await ctx.agentDeliveryProjectionService.getCurrent();
+			return streamOpenSpecCliMutation(ctx, ["init"], (mutationEvent) => ctx.cliExecutor.initStream({
+				tools: input.tools,
+				profile: projection.policy.profile,
+				force: input.force
+			}, mutationEvent), onEvent);
+		});
+	}),
+	updateStream: publicProcedure.subscription(({ ctx }) => {
+		return createCliStreamObservable((onEvent) => streamOpenSpecCliMutation(ctx, ["update"], (mutationEvent) => ctx.cliExecutor.executeStream(["update"], mutationEvent), onEvent));
+	}),
+	repairStream: publicProcedure.subscription(({ ctx }) => {
+		return createCliStreamObservable((onEvent) => streamOpenSpecCliMutation(ctx, ["update", "--force"], (mutationEvent) => ctx.cliExecutor.executeStream(["update", "--force"], mutationEvent), onEvent));
+	})
+});
 /**
 * OPSX router - CLI-driven workflow data
 */
@@ -15187,6 +15799,18 @@ const opsxRouter = router({
 		if (data.kind !== "opsx-apply-instructions") throw new Error("Unexpected OPSX Apply-instructions projection.");
 		return data.value;
 	}),
+	archiveInstructions: publicProcedure.input(z.object({
+		change: z.string().optional(),
+		schema: z.string().optional()
+	})).query(async ({ ctx, input }) => {
+		const data = await runPlanningRootRead(ctx, ({ planningCliProjectionService }) => planningCliProjectionService.getCurrent({
+			kind: "opsx-archive-instructions",
+			change: requireChangeId(input.change),
+			schema: input.schema
+		}));
+		if (data.kind !== "opsx-archive-instructions") throw new Error("Unexpected OPSX Archive-instructions projection.");
+		return data.value;
+	}),
 	configBundle: publicProcedure.query(async ({ ctx }) => {
 		const data = await runPlanningRootRead(ctx, ({ planningCliProjectionService }) => planningCliProjectionService.getCurrent({ kind: "opsx-config-bundle" }));
 		if (data.kind !== "opsx-config-bundle") throw new Error("Unexpected OPSX Config-bundle projection.");
@@ -15886,17 +16510,29 @@ const planningConfigRouter = router({
 	subscribeProjectBinding: publicProcedure.subscription(({ ctx }) => createReactiveSubscription(() => fetchProjectBindingConfig(ctx, true))),
 	updateProjectBinding: publicProcedure.input(ProjectBindingUpdateSchema).mutation(({ ctx, input }) => updateProjectBindingConfig(ctx, input)),
 	activeRoot: publicProcedure.query(({ ctx }) => fetchActiveRootConfig(ctx)),
-	subscribeActiveRoot: publicProcedure.subscription(({ ctx }) => createPlanningRootSubscription(ctx, ({ rootContext }) => readActiveRootConfig({
+	subscribeActiveRoot: publicProcedure.subscription(({ ctx }) => createPlanningRootProjectionSubscription(ctx, ({ rootContext }) => readActiveRootConfig({
 		launchProjectDir: ctx.projectDir,
 		rootContext
 	}))),
-	writeActiveRoot: publicProcedure.input(z.object({ content: z.string() })).mutation(async ({ ctx, input }) => {
-		await runPlanningRoot(ctx, ({ rootContext }) => writeActiveRootConfig({
-			launchProjectDir: ctx.projectDir,
-			rootContext,
-			content: input.content
-		}));
-		return { success: true };
+	writeActiveRoot: publicProcedure.input(ActiveRootMutationSchema).mutation(async ({ ctx, input }) => {
+		const result = await runPlanningRoot(ctx, async ({ rootContext, planningCliProjectionService }) => {
+			const mutationResult = await mutateActiveRootConfig({
+				launchProjectDir: ctx.projectDir,
+				rootContext,
+				mutation: input
+			});
+			if (mutationResult.state === "applied") planningCliProjectionService.invalidateConfigDependentWork();
+			return mutationResult;
+		});
+		if (result.state === "applied") {
+			ctx.runtimeInvalidation.invalidate([
+				"project",
+				"context",
+				"schemas"
+			]);
+			ctx.rootContextProjectionService.refresh();
+		}
+		return result;
 	}),
 	environmentGlobal: publicProcedure.query(({ ctx }) => ctx.environmentGlobalProjectionService.getCurrentConfig()),
 	readEnvironmentGlobalProjection: publicProcedure.query(({ ctx }) => EnvironmentGlobalProjectionStateSchema.parse(ctx.environmentGlobalProjectionService.read())),
@@ -15905,14 +16541,6 @@ const planningConfigRouter = router({
 		const subscription = ctx.environmentGlobalProjectionService.subscribe((notice) => emit.next(CliProjectionNoticeSchema.parse(notice)));
 		return () => subscription.unsubscribe();
 	})),
-	applyCoreProfile: publicProcedure.mutation(async ({ ctx }) => {
-		const args = [
-			"config",
-			"profile",
-			"core"
-		];
-		return runOpenSpecCliMutation(ctx, args, () => ctx.cliExecutor.execute(args));
-	}),
 	readEnvironmentGlobalFileProjection: publicProcedure.query(({ ctx }) => EnvironmentGlobalFileProjectionStateSchema.parse(ctx.environmentGlobalProjectionService.readFile())),
 	refreshEnvironmentGlobalFileProjection: publicProcedure.query(({ ctx }) => EnvironmentGlobalFileProjectionStateSchema.parse(ctx.environmentGlobalProjectionService.refreshFile())),
 	subscribeEnvironmentGlobalFileProjection: publicProcedure.subscription(({ ctx }) => observable((emit) => {
@@ -15924,7 +16552,32 @@ const planningConfigRouter = router({
 			cliExecutor: ctx.cliExecutor,
 			config: input.config
 		}));
-		return { success: true };
+		return {
+			success: true,
+			environment: EnvironmentGlobalProjectionStateSchema.parse(ctx.environmentGlobalProjectionService.refresh()),
+			file: EnvironmentGlobalFileProjectionStateSchema.parse(ctx.environmentGlobalProjectionService.refreshFile()),
+			rootContext: HostedRootContextProjectionStateSchema.parse(ctx.rootContextProjectionService.refresh())
+		};
+	}),
+	writeEnvironmentDefaultStore: publicProcedure.input(EnvironmentDefaultStoreUpdateSchema).mutation(async ({ ctx, input }) => {
+		const evidence = await writeEnvironmentDefaultStore({
+			cliExecutor: ctx.cliExecutor,
+			update: input
+		});
+		return {
+			kind: "environment-default-store-update",
+			configured: input.value ? {
+				state: "configured",
+				id: input.value
+			} : {
+				state: "absent",
+				id: null
+			},
+			evidence,
+			environment: EnvironmentGlobalProjectionStateSchema.parse(ctx.environmentGlobalProjectionService.refresh()),
+			file: EnvironmentGlobalFileProjectionStateSchema.parse(ctx.environmentGlobalProjectionService.refreshFile()),
+			rootContext: HostedRootContextProjectionStateSchema.parse(ctx.rootContextProjectionService.refresh())
+		};
 	})
 });
 /** CLI-owned planning Root Context shared by every project-workspace surface. */
@@ -15941,6 +16594,7 @@ const rootContextRouter = router({
 * Main app router
 */
 const appRouter = router({
+	agentIntegrations: agentIntegrationsRouter,
 	dashboard: dashboardRouter,
 	git: gitRouter,
 	spec: specRouter,
@@ -16803,44 +17457,6 @@ var StoreProjectionService = class {
 	}
 };
 
-//#endregion
-//#region src/tool-command-observation-service.ts
-/** Server-owned lifecycle for non-project tool command artifact observation. */
-var ToolCommandObservationService = class {
-	startPromise = null;
-	releaseRoot = null;
-	disposed = false;
-	constructor(environment, root) {
-		this.environment = environment;
-		this.root = root;
-	}
-	/** Acquire the Codex command directory, using missing-root watcher ownership when necessary. */
-	start() {
-		if (this.disposed) return Promise.reject(/* @__PURE__ */ new Error("Cannot start tool command observation after teardown."));
-		if (this.startPromise) return this.startPromise;
-		const startPromise = this.environment.acquireRoot(this.root).then(async (releaseRoot) => {
-			if (this.disposed) {
-				await releaseRoot();
-				return;
-			}
-			this.releaseRoot = releaseRoot;
-		}).finally(() => {
-			if (this.startPromise === startPromise && this.releaseRoot === null) this.startPromise = null;
-		});
-		this.startPromise = startPromise;
-		return startPromise;
-	}
-	/** Release external command observation, including a startup that is still settling. */
-	async dispose() {
-		if (this.disposed) return;
-		this.disposed = true;
-		await this.startPromise?.catch(() => {});
-		const releaseRoot = this.releaseRoot;
-		this.releaseRoot = null;
-		await releaseRoot?.();
-	}
-};
-
 //#endregion
 //#region src/tracing.ts
 /**
@@ -18252,7 +18868,7 @@ function getManagedLocalRuntimeSpec(engineId) {
 	return {
 		packageNames: ["ctranslate2"],
 		allowBuildPackages: ["ctranslate2"],
-		fallbackRange: "^0.1.0",
+		fallbackRange: "^1.0.0",
 		detectMissing(tree) {
 			return hasRuntimePackageDependencyPath(tree, ["ctranslate2"]) ? [] : ["ctranslate2"];
 		}
@@ -18794,18 +19410,12 @@ if (!isMainThread) {
 //#endregion
 //#region src/server.ts
 /**
-* Orthogonal intents (updated 2026-07-31 Asia/Shanghai):
-* 1. Bootstrap the HTTP/tRPC server and launch-project runtime services.
-* 2. Delegate OpenSpec filesystem ownership to the CLI-selected planning-root manager.
-* 3. Host Server-local terminal/Root Context notifications, sound, preview-resource, and translation HTTP boundaries.
-* 4. Host tRPC and PTY WebSocket transports with deterministic teardown.
-*    PTY planning-root creation and workflow input verify opaque Root generation provenance.
-* 5. Own the runtime observation environment and external Codex command lease while deferring expensive
-*    root-scoped projections until a foreground consumer requests them; keep Store-list registry/mutation
-*    evidence distinct from selector-exact Store-root observation.
-* 6. Initialize backend OpenTelemetry tracing (--otel diagnostic only) and expose the resolved Tracer
-*    through Context so procedure/planning-root instrumentation stays branch-free.
-* 7. Admit dynamic loopback App origins while keeping remote browser origins explicitly allowlisted.
+* Orthogonal intents (updated 2026-08-01 Asia/Shanghai):
+* 1. Bootstrap HTTP/tRPC, WebSocket, PTY, and launch-project runtime services.
+* 2. Delegate planning-root, Store, Environment Global, Agent, and Root Context projection ownership.
+* 3. Host notifications, sound, preview-resource, translation, and telemetry boundaries.
+* 4. Admit dynamic loopback App origins and perform deterministic runtime teardown.
+* 5. Bridge settled machine-global config changes into Root Context replacement.
 *
 * Original request (2026-07-15): "你先负责后端（内核）的开发。"
 * Original request (2026-07-17): "Every Planning-root execution surface uses the same operation lifetime owner."
@@ -18821,6 +19431,8 @@ if (!isMainThread) {
 * Original request (2026-07-26): "展开全面的接口升级和内核升级和测试升级。"
 * Built-runtime defect (2026-07-30): Direct Web shutdown must await HTTP closure and retire non-cooperative WebSocket and buffered CLI children after one signal.
 * Original request (2026-07-31): Trace every Planning-root write lock with timing, source, and stack evidence.
+* Original request (2026-08-01): adapt OpenSpec 1.7 machine `defaultStore` fallback.
+* Original request (2026-08-01): move Agent delivery projection ownership into the Server runtime.
 *
 * @module server
 */
@@ -18887,19 +19499,12 @@ function createServer(config) {
 		storeObservation,
 		observationEnvironment
 	});
-	const toolCommandObservation = new ToolCommandObservationService(observationEnvironment, getExternalCodexCommandObservationRoot());
 	const codeGitBinding = new LaunchGitRepositoryBindingOwner();
 	const projectionWorkRuntime = createServerProjectionWorkRuntime();
 	const dashboardProjectionWorkOwner = createDashboardProjectionWorkOwner(projectionWorkRuntime);
 	const changesProjectionWorkOwner = createChangesProjectionWorkOwner(projectionWorkRuntime);
 	const storeProjectionWorkOwner = createStoreProjectionWorkOwner(projectionWorkRuntime);
 	const planningCliProjectionWorkOwner = createPlanningCliProjectionWorkOwner(projectionWorkRuntime);
-	const environmentGlobalProjectionService = new EnvironmentGlobalProjectionService({
-		dataScope,
-		cliExecutor,
-		observationEnvironment,
-		workOwner: createEnvironmentGlobalProjectionWorkOwner(projectionWorkRuntime)
-	});
 	const storeProjectionService = new StoreProjectionService({
 		dataScopePath: dataScope.path,
 		cliExecutor,
@@ -18935,6 +19540,21 @@ function createServer(config) {
 		planningRootServices,
 		workOwner: createRootContextProjectionWorkOwner(projectionWorkRuntime)
 	});
+	const environmentGlobalProjectionService = new EnvironmentGlobalProjectionService({
+		dataScope,
+		cliExecutor,
+		observationEnvironment,
+		workOwner: createEnvironmentGlobalProjectionWorkOwner(projectionWorkRuntime),
+		onConfigFileSettled: () => rootContextProjectionService.refresh()
+	});
+	environmentGlobalProjectionService.start();
+	const agentDeliveryProjectionService = new AgentDeliveryProjectionService({
+		projectDir: config.projectDir,
+		environmentGlobalProjectionService,
+		observationEnvironment,
+		cliExecutor,
+		cliCommandAuthority: configManager
+	});
 	const gitRepositoryBindings = new GitRepositoryBindingService({
 		launchProjectDir: config.projectDir,
 		planningRootServices,
@@ -19128,8 +19748,8 @@ function createServer(config) {
 				storeContentProjectionService,
 				rootContextProjectionService,
 				environmentGlobalProjectionService,
+				agentDeliveryProjectionService,
 				storeMutationService,
-				toolCommandObservation,
 				configManager,
 				cliExecutor,
 				projectRecoveryService,
@@ -19170,8 +19790,8 @@ function createServer(config) {
 			storeContentProjectionService,
 			rootContextProjectionService,
 			environmentGlobalProjectionService,
+			agentDeliveryProjectionService,
 			storeMutationService,
-			toolCommandObservation,
 			configManager,
 			cliExecutor,
 			projectRecoveryService,
@@ -19206,8 +19826,8 @@ function createServer(config) {
 		storeContentProjectionService,
 		rootContextProjectionService,
 		environmentGlobalProjectionService,
+		agentDeliveryProjectionService,
 		storeObservationFallback,
-		toolCommandObservation,
 		adapter,
 		configManager,
 		cliExecutor,
@@ -19323,13 +19943,13 @@ async function createWebSocketServer(server, httpServer, config) {
 				await settleCleanupPhase(failures, [() => server.rootContextNotificationBridge.dispose()]);
 				await settleCleanupPhase(failures, [() => server.storeProjectionService.dispose()]);
 				await settleCleanupPhase(failures, [() => server.storeContentProjectionService.dispose()]);
+				await settleCleanupPhase(failures, [() => server.agentDeliveryProjectionService.dispose()]);
 				await settleCleanupPhase(failures, [() => server.environmentGlobalProjectionService.dispose()]);
 				await settleCleanupPhase(failures, [() => server.cliExecutor.dispose()]);
 				await settleCleanupPhase(failures, [() => server.planningRootServices.dispose()]);
 				await settleCleanupPhase(failures, [() => server.projectionWorkRuntime.clear()]);
 				await settleCleanupPhase(failures, [() => server.storeObservation.dispose()]);
 				await settleCleanupPhase(failures, [() => server.dataHomeObserver.dispose()]);
-				await settleCleanupPhase(failures, [() => server.toolCommandObservation.dispose()]);
 				await settleCleanupPhase(failures, [() => server.projectInvalidation.dispose()]);
 				await settleCleanupPhase(failures, [() => server.observationEnvironment.dispose()]);
 				await settleCleanupPhase(failures, [() => server.projectRecoveryService.dispose(), () => server.translationCacheService.close()]);