cordisx 0.1.0-beta.2 → 0.1.0-beta.21

package/dist/src/cli/run-support.js

@@ -1,37 +1,53 @@
+import { loadManagedSourceTrustNow } from '../launcher/managed-source-trust.js';
+import { resolveDevelopmentConfigIdentity } from '../launcher/development-source-identity.js';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
-import { randomBytes } from 'node:crypto';
 import os from 'node:os';
+import { randomBytes } from 'node:crypto';
 import { mkdtemp, rm } from 'node:fs/promises';
-import { ensureCordisXHomeDirectory, } from '../config/home-config.js';
-import { buildRendererBundle } from '../launcher/bundle.js';
+import { ensureCordisXHomeDirectory, ensureHomeConfig, } from '../config/home-config.js';
+export { assertProductionGraphLaunchOwnership } from '../launcher/host-generation-graph.js';
 import { watchAndInject } from '../launcher/cdp.js';
 import { localDevelopmentPluginIdentity } from '../launcher/development.js';
-import { createNativeViteEntityGenerationHandler, startNativeViteServer } from '../launcher/vite-development.js';
+import { createNativeSubmissionComposition, } from '../launcher/native-submission-composition.js';
+import { composeNativeVitePluginGenerationHandlers, createNativeViteEntityGenerationHandler, createNativeViteManagedServiceProjection, startNativeViteServer, } from '../launcher/vite-development.js';
 import { DirectPublisherGrantAuthority, DirectPublisherGrantStore, MacOSMachineIdentityProvider, StaticPublisherKeyRegistry, } from '../launcher/publisher-grants.js';
 import { createPublisherGrantBridgeHandler } from '../launcher/publisher-grant-rpc.js';
 import { findCordisXProjectConfig, loadConfig, resolveCordisXProjectConfig, } from '../launcher/config.js';
-import { assertLoopbackPortAvailable, findFreeLoopbackPort, launchCodex, prepareIsolatedCodexProfile, resolveCodexExecutable, terminateIsolatedCodex, } from '../launcher/process.js';
+import { acquireCodexProfileLaunchLease, assertLoopbackPortAvailable, findFreeLoopbackPort, launchCodex, prepareIsolatedCodexProfile, resolveCodexExecutable, terminateIsolatedCodex, } from '../launcher/process.js';
 import { settleInjectedHostCleanup } from './injected-host-cleanup.js';
+import { supportsOwnedMainInspector } from '../shortcuts/dock.js';
 import { ProviderFleet } from '../providers/fleet.js';
 import { resolveLocalCodexProviderConfig } from '../providers/config.js';
 import { CodexAgentHistoryHost } from '../launcher/agent-history.js';
-import { HostServiceConfigNarrowApi } from '../launcher/service-config.js';
-import { readServiceConfigState } from '../config/service-config.js';
-import { CLI_PROXY_PROVIDER_RUNTIME_CONFIG_CONTRACT, CLI_PROXY_PROVIDER_RUNTIME_SERVICE_ID, CLI_PROXY_PROVIDER_STARTUP_CONFIG_CONTRACT, CLI_PROXY_PROVIDER_STARTUP_CONFIG_INITIAL, CLI_PROXY_PROVIDER_STARTUP_SERVICE_ID, parseCliProxyProviderStartupConfig, resolveCliProxyProviderConfigs, } from '../plugins/cli-proxy-api/service-config.js';
+import { WorkUsageProfileHost } from '../launcher/work-usage-profile.js';
+import { createLauncherConfigBridgeHandler } from '../launcher/launcher-plugin-config.js';
+import { PluginActivationStore } from '../launcher/plugin-activation.js';
+import { openPluginManagementService } from '../management/service.js';
 import { CORDISX_PLUGIN_ACTIVATION_SCHEMA_V1, } from '../plugin-lifecycle-contracts.js';
+import { buildRendererComposition } from './renderer-composition.js';
+export { assertProductionGraphBootstrapSnapshot, buildRendererComposition, } from './renderer-composition.js';
 import { OwnerDocumentStore } from '../launcher/owner-document-store.js';
 import { EntityDirectoryAuthority } from '../launcher/entity-directory.js';
 import { createEntityBridgeHandler } from '../launcher/entity-rpc.js';
+import { loadStagedPluginPackage } from '../launcher/plugin-package.js';
 import { AgentLoopAuthority } from '../launcher/agent-loop-authority.js';
-import { CordisXSkillConflictError, deployBundledCordisXSkillToHome, } from '../launcher/builtin-skill.js';
+import { managedBackendRuntimeServiceAccess } from '../launcher/packages/managed-backend-service-access.js';
+import { ManagedServiceRuntime } from '../launcher/managed-service-runtime.js';
+import { ManagedServiceNodeHost } from '../launcher/managed-service-node-host.js';
+import { CordisXSkillConflictError, deployBundledCordisXSkillsToHome, deployBundledCordisXSkillToHome, } from '../launcher/builtin-skill.js';
 import { createOwnerDocumentBridgeHandler, OwnerDocumentLeaseRegistry, } from '../launcher/owner-document-rpc.js';
+import { shouldEnableNativeSubmission } from './native-submission-launch-policy.js';
 export const HELP = `Usage:
   cordisx [app] [profile] [--data shared|host-isolated] [options] [-- host-arguments...]
+  cordisx start|status|logs|stop|restart [app] [profile] [options]
   cordisx setup
   cordisx config
   cordisx doctor
+  cordisx feedback <collect|inspect|export> [options]
   cordisx dev [plugin-path | --config path] [options] [-- host-arguments...]
+  cordisx plugin <command> [options]
+  cordisx source <command> [options]
 
 Options:
   --attach                 Attach to an existing loopback CDP endpoint
@@ -41,7 +57,14 @@ Options:
   --debug-port <port>      Override the loopback CDP port
   --online-devtools        Allow the official online DevTools frontend
   --dry-run                Resolve and print the plan without starting the host
+  --recover-startup        Replace a legacy start lock after older CordisX starts have exited
+  --write-config           Enable plugin saves to an explicit dev --config file
+  --work-scope-guard <scope/epoch>  Require the original dev work ledger identity on admission
   dev without a path       Discover .cordisx/config.json (or cordisx.config.json) upwards
+  plugin --help            Show plugin management commands
+  source --help            Show source management commands
+  feedback --help          Show local, privacy-filtered feedback commands
+  --create-shortcut        Create/update a macOS launch entry after readiness
   -h, --help               Show this help`;
 export async function deployBuiltinSkillWithoutOverwritingUserChanges(deployment, stdout) {
     try {
@@ -56,6 +79,20 @@ export async function deployBuiltinSkillWithoutOverwritingUserChanges(deployment
         stdout(`[cordisx] built-in Skill preserved: ${error.message}`);
     }
 }
+export async function deployBuiltinSkillsWithoutOverwritingUserChanges(deployment, stdout) {
+    const result = await deployment;
+    for (const installed of result.deployments) {
+        if (installed.status !== 'unchanged') {
+            stdout(`[cordisx] built-in Skill ${installed.status}: ${installed.targetDir}`);
+        }
+    }
+    for (const conflict of result.conflicts) {
+        stdout(`[cordisx] built-in Skill preserved: ${conflict.message}`);
+    }
+}
+export function shouldSkipBuiltinSkillDeployment(environment) {
+    return environment.CORDISX_SKIP_BUILTIN_SKILL_DEPLOYMENT === '1';
+}
 export function waitForExit(child) {
     return new Promise((resolve, reject) => {
         child.once('error', reject);
@@ -67,6 +104,28 @@ export function waitForExit(child) {
         });
     });
 }
+/** Capture only the ephemeral loopback inspector address from our own Host stderr. */
+function captureMainInspectorUrl(child) {
+    const stream = child.stderr;
+    if (!stream)
+        return Promise.reject(new Error('Owned Host inspector stderr unavailable'));
+    const operation = new Promise((resolve, reject) => {
+        let buffer = '';
+        const timer = setTimeout(() => reject(new Error('Owned Host inspector did not start')), 8_000);
+        stream.on('data', chunk => {
+            buffer = (buffer + String(chunk)).slice(-8_192);
+            const match = /Debugger listening on (ws:\/\/127\.0\.0\.1:\d+\/[a-f0-9-]+)/u.exec(buffer);
+            if (match?.[1]) {
+                clearTimeout(timer);
+                resolve(match[1]);
+            }
+        });
+        stream.once('error', reject);
+        stream.once('end', () => reject(new Error('Owned Host main inspector exited')));
+    });
+    void operation.catch(() => undefined);
+    return operation;
+}
 export function waitForAbort(signal) {
     if (signal.aborted)
         return Promise.resolve();
@@ -93,124 +152,6 @@ export function providerConfigs(config, environment) {
     const local = resolveLocalCodexProviderConfig(config.codex, environment);
     return local === undefined ? config.providers : [...config.providers, local];
 }
-export function assertProductionGraphLaunchOwnership(attach, hasLoopbackGraph) {
-    if (attach && hasLoopbackGraph) {
-        throw new Error('production browser graphs require a launcher-owned native Host; --attach is unsupported');
-    }
-}
-/** Build the exact renderer composition that the launcher will inject through CDP. */
-export async function buildRendererComposition(config, stdout, options = {}) {
-    const providerBridgeToken = (config.codex.agentLoopBackend === 'local-cli'
-        || config.providers.some(provider => provider.enabled)
-        || config.plugins.some(plugin => plugin.enabled && plugin.id === 'cli-proxy-api'))
-        ? randomBytes(32).toString('hex')
-        : undefined;
-    const agentHistoryBridgeToken = randomBytes(32).toString('hex');
-    const configBridgeToken = options.writable === true ? randomBytes(32).toString('hex') : undefined;
-    const ownerDocumentSecret = randomBytes(32).toString('hex');
-    const serviceConfigBridgeToken = options.writable === true ? randomBytes(32).toString('hex') : undefined;
-    const permissionBridgeToken = options.permission?.persistent === true ? randomBytes(32).toString('hex') : undefined;
-    const iconThemePreferenceBridgeToken = options.writable === true && options.appId !== undefined
-        ? randomBytes(32).toString('hex')
-        : undefined;
-    const generation = options.generation ?? randomBytes(16).toString('hex');
-    const profileId = options.permission?.profileId ?? options.profileId ?? 'development';
-    const bundleOptions = {
-        ...(providerBridgeToken === undefined ? {} : { providerBridgeToken }),
-        agentHistoryBridgeToken,
-        ...(configBridgeToken === undefined ? {} : { configBridgeToken }),
-        ownerDocumentAuthority: { secret: ownerDocumentSecret, profileId, generation },
-        ...(serviceConfigBridgeToken === undefined ? {} : { serviceConfigBridgeToken }),
-        ...(options.appId === undefined ? {} : { appId: options.appId }),
-        ...(options.iconThemePreference === undefined ? {} : { iconThemePreference: options.iconThemePreference }),
-        ...(iconThemePreferenceBridgeToken === undefined ? {} : { iconThemePreferenceBridgeToken }),
-        ...(options.channelCredentialBridgeToken === undefined
-            ? {}
-            : { channelCredentialBridgeToken: options.channelCredentialBridgeToken }),
-        ...(options.channelActionsBridgeToken === undefined
-            ? {}
-            : { channelActionsBridgeToken: options.channelActionsBridgeToken }),
-        ...(options.permission === undefined
-            ? (options.profileId === undefined ? {} : { profileId: options.profileId })
-            : {
-                profileId: options.permission.profileId,
-                permission: {
-                    profileId: options.permission.profileId,
-                    policies: options.permission.policies,
-                    ...(permissionBridgeToken === undefined ? {} : { bridgeToken: permissionBridgeToken }),
-                },
-            }),
-        generation,
-        ...(options.pluginLifecycle === undefined ? {} : { pluginLifecycleBridgeToken: options.pluginLifecycle.token }),
-        ...(options.pluginBundles === undefined ? {} : { pluginBundleSnapshot: options.pluginBundles }),
-        ...((options.pluginActivation ?? options.pluginLifecycle?.activation) === undefined
-            ? {}
-            : { pluginActivation: options.pluginActivation ?? options.pluginLifecycle.activation }),
-        ...((options.initialRegistryEpoch ?? options.pluginLifecycle?.registryEpoch) === undefined
-            ? {}
-            : { initialRegistryEpoch: options.initialRegistryEpoch ?? options.pluginLifecycle.registryEpoch }),
-        ...(options.channelManager === undefined ? {} : { channelManager: options.channelManager }),
-    };
-    const buildBundle = options.developmentBuild ?? options.internalBuildRendererBundle ?? buildRendererBundle;
-    const source = await buildBundle(config, bundleOptions);
-    const newDocumentSource = options.certifiedPermissionChannelToken === undefined
-        ? undefined
-        : await buildBundle(config, {
-            ...bundleOptions,
-            certifiedPermissionChannelToken: options.certifiedPermissionChannelToken,
-        });
-    const enabled = config.plugins.filter(plugin => plugin.enabled).map(plugin => plugin.id);
-    const hasLoopbackGraph = config.plugins.some(plugin => plugin.enabled && plugin.runtimeGraph !== undefined);
-    stdout(`[cordisx] ${options.developmentBuild === undefined ? 'bundle' : 'Vite entry'} ready: ${source.length} bytes, plugins: ${enabled.join(', ') || '(none)'}`);
-    return {
-        source,
-        ...(newDocumentSource === undefined ? {} : { newDocumentSource }),
-        hasLoopbackGraph,
-        ...(providerBridgeToken === undefined ? {} : { providerBridgeToken }),
-        agentHistoryBridgeToken,
-        ...(configBridgeToken === undefined ? {} : { configBridgeToken }),
-        ownerDocumentSecret,
-        ...(serviceConfigBridgeToken === undefined ? {} : { serviceConfigBridgeToken }),
-        generation,
-        ...(permissionBridgeToken === undefined ? {} : { permissionBridgeToken }),
-        ...(iconThemePreferenceBridgeToken === undefined ? {} : { iconThemePreferenceBridgeToken }),
-        ...(options.pluginLifecycle === undefined ? {} : { pluginLifecycleBridgeToken: options.pluginLifecycle.token }),
-        rebuild: async (nextConfig, pluginActivation, initialRegistryEpoch, current) => {
-            const currentBundleOptions = current === undefined
-                ? bundleOptions
-                : (() => {
-                    const { channelManager: _channelManager, pluginBundleSnapshot: _pluginBundleSnapshot, ...stable } = bundleOptions;
-                    void _channelManager;
-                    void _pluginBundleSnapshot;
-                    return {
-                        ...stable,
-                        pluginBundleSnapshot: current.pluginBundles,
-                        ...(current.channelManager === undefined ? {} : { channelManager: current.channelManager }),
-                    };
-                })();
-            const rebuildOptions = {
-                ...currentBundleOptions,
-                ...(current === undefined || bundleOptions.permission === undefined
-                    ? {}
-                    : { permission: { ...bundleOptions.permission, policies: current.permissionPolicies } }),
-                ownerDocumentAuthority: { secret: ownerDocumentSecret, profileId, generation },
-                pluginActivation,
-                initialRegistryEpoch,
-            };
-            const rebuiltSource = await buildBundle(nextConfig, rebuildOptions);
-            const rebuiltNewDocumentSource = options.certifiedPermissionChannelToken === undefined
-                ? undefined
-                : await buildBundle(nextConfig, {
-                    ...rebuildOptions,
-                    certifiedPermissionChannelToken: options.certifiedPermissionChannelToken,
-                });
-            return {
-                source: rebuiltSource,
-                ...(rebuiltNewDocumentSource === undefined ? {} : { newDocumentSource: rebuiltNewDocumentSource }),
-            };
-        },
-    };
-}
 export function codexHome(environment) {
     const explicit = environment.CODEX_HOME;
     if (typeof explicit === 'string' && explicit.length > 0)
@@ -218,74 +159,59 @@ export function codexHome(environment) {
     const home = typeof environment.HOME === 'string' && environment.HOME.length > 0 ? environment.HOME : os.homedir();
     return path.join(home, '.codex');
 }
-export function agentHistoryHost(environment, configPath, profileName) {
-    return new CodexAgentHistoryHost({
+function historyLocation(environment, configPath, profileName) {
+    return {
         codexHome: codexHome(environment),
         cacheDir: path.join(path.dirname(configPath), 'cache', 'agent-history'),
         profileName,
+    };
+}
+export function agentHistoryHost(environment, configPath, profileName, workProfile) {
+    return new CodexAgentHistoryHost({
+        ...historyLocation(environment, configPath, profileName),
+        ...(workProfile === undefined ? {} : { workProfile }),
     });
 }
 export function pluginIdentities(config) {
     return config.plugins.map(plugin => ({ source: plugin.source ?? pathToFileURL(plugin.entry).href, id: plugin.id }));
 }
-export function configuredPluginTopology(config) {
-    return JSON.stringify(config.plugins.map(plugin => ({
-        id: plugin.id,
-        entry: plugin.entry,
-        source: plugin.source,
-        enabled: plugin.enabled,
-    })));
-}
-export function usesIsolatedPackageWorker(plugin) {
-    const manifest = plugin.manifest;
-    return manifest?.schemaVersion === 7
-        || ((manifest?.schemaVersion === 5 || manifest?.schemaVersion === 6)
-            && manifest.capabilities.some(capability => (capability.name === 'ui.host-dom.read' || capability.name === 'ui.host-dom.modify')));
-}
-export function cliProxyServiceConfigApis(input) {
-    const secretState = (reference) => {
-        if (reference === undefined || reference === '')
-            return 'missing';
-        const environmentName = /^host-secret:env\/([A-Z_][A-Z0-9_]*)$/u.exec(reference)?.[1];
-        if (environmentName !== undefined)
-            return input.environment[environmentName] === undefined ? 'missing' : 'ready';
-        return 'unavailable';
-    };
-    const startup = new HostServiceConfigNarrowApi({
-        contract: CLI_PROXY_PROVIDER_STARTUP_CONFIG_CONTRACT,
-        profileId: input.profileId,
-        generation: input.generation,
-        ownerToken: input.token,
-        configPath: input.configPath,
-        writable: true,
-        authorize: () => true,
-        secretState,
-    });
-    const runtime = new HostServiceConfigNarrowApi({
-        contract: CLI_PROXY_PROVIDER_RUNTIME_CONFIG_CONTRACT,
-        profileId: input.profileId,
-        generation: input.generation,
-        ownerToken: input.token,
-        configPath: input.configPath,
-        writable: true,
-        authorize: () => true,
-        secretState,
-        restartService: async (candidate) => {
-            const startupState = await readServiceConfigState({
-                profileId: input.profileId,
-                pluginId: 'cli-proxy-api',
-                serviceId: CLI_PROXY_PROVIDER_STARTUP_SERVICE_ID,
-                initialConfig: CLI_PROXY_PROVIDER_STARTUP_CONFIG_INITIAL,
-            }, input.configPath);
-            const providers = resolveCliProxyProviderConfigs(CLI_PROXY_PROVIDER_RUNTIME_CONFIG_CONTRACT.parseStored(candidate), parseCliProxyProviderStartupConfig(startupState.config), { rootDir: input.rootDir });
-            return await input.fleet.reconfigure(providers);
-        },
-    });
-    return [
-        { pluginId: 'cli-proxy-api', serviceId: CLI_PROXY_PROVIDER_RUNTIME_SERVICE_ID, api: runtime },
-        { pluginId: 'cli-proxy-api', serviceId: CLI_PROXY_PROVIDER_STARTUP_SERVICE_ID, api: startup },
-    ];
+async function createDevelopmentManagedServiceActivation(input) {
+    const homeConfig = await ensureHomeConfig({ configPath: input.homeConfigPath });
+    const codex = ownValue(homeConfig.apps, 'codex');
+    if (codex === undefined)
+        throw new Error('host app is not configured: codex');
+    const runtimeGeneration = randomBytes(16).toString('hex');
+    const store = new PluginActivationStore(input.homeDir, codex.defaultProfile, runtimeGeneration);
+    const active = await store.loadActive();
+    const nestedAccesses = await Promise.all(active.plugins.flatMap(item => item.enabled
+        ? [(async () => {
+                const staged = await loadStagedPluginPackage(input.homeDir, item.digest);
+                if (staged.manifest.id !== item.id || staged.manifest.version !== item.version
+                    || JSON.stringify(staged.manifest.dependencies) !== JSON.stringify(item.dependencies))
+                    throw new Error(`active plugin package metadata failed readback for ${item.id}`);
+                const manifest = staged.manifest.runtimeManifest;
+                if (manifest.schemaVersion !== 14)
+                    return [];
+                return await Promise.all(manifest.services.flatMap(service => service.kind === 'managed-backend'
+                    ? [managedBackendRuntimeServiceAccess(input.homeDir, {
+                            id: item.id,
+                            version: item.version,
+                            digest: item.digest,
+                            moduleGeneration: item.moduleGeneration,
+                        }, service.id, runtimeGeneration)]
+                    : []));
+            })()]
+        : []));
+    const host = new ManagedServiceNodeHost(new ManagedServiceRuntime({ homeDir: input.homeDir, environment: input.environment }), 'development', runtimeGeneration);
+    try {
+        return await host.replace(nestedAccesses.flat());
+    }
+    catch (error) {
+        await host.dispose().catch(() => undefined);
+        throw error;
+    }
 }
+export { cliProxyServiceConfigApis } from './provider-config-apis.js';
 export function recoveredActivation(plan, runtimeGeneration) {
     return {
         $schema: CORDISX_PLUGIN_ACTIVATION_SCHEMA_V1,
@@ -326,6 +252,7 @@ export async function runInjectedHost(input) {
     });
     let reportedReady = false;
     const watcher = watchAndInject({
+        ...(input.nativeSubmission === undefined ? {} : { nativeSubmission: input.nativeSubmission }),
         port: input.debugPort,
         source: input.source,
         ...(input.newDocumentSource === undefined ? {} : { newDocumentSource: input.newDocumentSource }),
@@ -346,6 +273,7 @@ export async function runInjectedHost(input) {
             ? {}
             : { iconThemePreferencePersistence: input.iconThemePreferencePersistence }),
         ...(input.pluginLifecycle === undefined ? {} : { pluginLifecycle: input.pluginLifecycle }),
+        ...(input.pluginManagement === undefined ? {} : { pluginManagement: input.pluginManagement }),
         ...(input.developmentRuntime === undefined ? {} : { developmentRuntime: input.developmentRuntime }),
         ...(input.viteDevelopment === true ? { viteDevelopment: true } : {}),
         hasLoopbackGraph: input.hasLoopbackGraph,
@@ -356,17 +284,19 @@ export async function runInjectedHost(input) {
             : { productionGraphBootstrap: input.productionGraphBootstrap }),
         ...(input.publisherGrant === undefined ? {} : { publisherGrant: input.publisherGrant }),
         ...(input.certifiedPermission === undefined ? {} : { certifiedPermission: input.certifiedPermission }),
-        onReady: () => {
+        ...(input.managedServiceUI === undefined ? {} : { managedServiceUI: input.managedServiceUI }),
+        onReady: async () => {
             if (reportedReady)
                 return;
             reportedReady = true;
+            await input.onReady?.();
             markReady();
             input.stdout('[cordisx] CDP renderer ready');
-            input.onReady?.();
         },
         onStatus: message => input.stdout(`[cordisx] ${message}`),
     });
     let launched;
+    let profileLease = input.profileLease;
     let primaryError;
     try {
         if (input.launcher.attach) {
@@ -375,8 +305,16 @@ export async function runInjectedHost(input) {
         }
         if (input.executable === undefined)
             throw new Error('host executable was not resolved');
+        if (input.profile !== undefined && profileLease === undefined) {
+            profileLease = await acquireCodexProfileLaunchLease(input.profile.userDataDir);
+        }
+        const mainInspector = input.dockInspector === true && await supportsOwnedMainInspector(input.executable);
         input.stdout(`[cordisx] launching ${input.executable} with CDP 127.0.0.1:${input.debugPort}`);
-        launched = launchCodex(input.executable, input.debugPort, input.hostArgs, input.profile, input.launcher.onlineDevtools, input.environment);
+        launched = launchCodex(input.executable, input.debugPort, input.hostArgs, input.profile, input.launcher.onlineDevtools, input.environment, mainInspector);
+        if (launched.pid === undefined)
+            throw new Error('launched Host exposed no PID');
+        const inspectorUrl = mainInspector ? captureMainInspectorUrl(launched) : undefined;
+        await input.onHostLaunched?.(launched.pid, inspectorUrl);
         await Promise.race([
             waitForHostExitAfterReadiness({
                 childExit: waitForExit(launched),
@@ -403,16 +341,35 @@ export async function runInjectedHost(input) {
                 ? {}
                 : { terminateHost: async () => await terminateIsolatedCodex(launchedHost, input.profile) }),
         });
+        const hostTermination = launchedHost === undefined ? undefined : cleanup.at(-1);
+        const leaseCleanup = hostTermination?.status === 'rejected'
+            ? []
+            : await Promise.allSettled([profileLease?.release() ?? Promise.resolve()]);
         process.removeListener('SIGINT', stop);
         process.removeListener('SIGTERM', stop);
+        if (primaryError !== undefined) {
+            for (const result of [...cleanup, ...leaseCleanup]) {
+                if (result.status === 'rejected') {
+                    input.stdout(`[cordisx] cleanup failed: ${String(result.reason)}`);
+                }
+            }
+        }
         if (primaryError === undefined) {
             const rejected = cleanup.find((result) => result.status === 'rejected');
             if (rejected !== undefined)
                 throw rejected.reason;
+            for (const result of leaseCleanup) {
+                if (result.status === 'rejected')
+                    throw result.reason;
+            }
         }
     }
 }
 export async function runDevelopment(invocation, cwd, stdout, environment, homeConfigPath, homeConfigOptions, runtime) {
+    if (invocation.options.writeConfig === true
+        && (invocation.configPath === undefined || invocation.pluginPath !== undefined)) {
+        throw new Error('--write-config requires cordisx dev --config <path>');
+    }
     const cordisxHomeDir = rootFromConfigPath(homeConfigPath);
     const entry = invocation.pluginPath === undefined ? undefined : path.resolve(cwd, invocation.pluginPath);
     const localIdentity = entry === undefined ? undefined : await localDevelopmentPluginIdentity(entry);
@@ -424,30 +381,58 @@ export async function runDevelopment(invocation, cwd, stdout, environment, homeC
     if (entry === undefined && location === undefined) {
         throw new Error(`CordisX project config not found from ${cwd}; create .cordisx/config.json or pass a plugin path/--config`);
     }
-    const config = entry === undefined
-        ? await loadConfig(location.configPath, { projectRoot: location.projectRoot })
+    const suppliedConfig = entry === undefined
+        ? await loadConfig(location.configPath, { projectRoot: location.projectRoot, profileId: 'development' })
         : {
             ...localDevelopmentHostConfig(cwd),
             plugins: [{ id: localIdentity.id, source: localIdentity.source, entry, enabled: true, config: {} }],
         };
-    if (!invocation.options.dryRun)
+    const config = await resolveDevelopmentConfigIdentity(suppliedConfig);
+    if (!invocation.options.dryRun && invocation.options.workScopeGuard === undefined) {
         await ensureCordisXHomeDirectory(homeConfigOptions);
+    }
+    const workProfile = {
+        homeDir: cordisxHomeDir,
+        profileId: 'development',
+        ...(invocation.options.workScopeGuard === undefined ? {} : {
+            bootstrapGuard: {
+                scopeId: invocation.options.workScopeGuard.split('/')[0],
+                epoch: invocation.options.workScopeGuard.split('/')[1],
+            },
+        }),
+    };
+    const historyPreflight = new WorkUsageProfileHost(workProfile, historyLocation(environment, homeConfigPath, `development:${config.rootDir}`));
+    try {
+        await historyPreflight.preflight();
+    }
+    finally {
+        historyPreflight.dispose();
+    }
+    if (!invocation.options.dryRun && invocation.options.workScopeGuard !== undefined) {
+        await ensureCordisXHomeDirectory(homeConfigOptions);
+    }
     const dryRunCacheRoot = invocation.options.dryRun
         ? await mkdtemp(path.join(os.tmpdir(), 'cordisx-vite-dry-run-'))
         : undefined;
     let vite;
+    let managedServiceActivation;
+    let managedServiceProjection;
+    let nativeSubmission;
+    let pluginManagementService;
     try {
         vite = await startNativeViteServer(config, {
             cacheRoot: dryRunCacheRoot ?? path.join(cordisxHomeDir, 'cache', 'native-vite'),
             prebundleHostDependencies: !invocation.options.dryRun,
         });
         const activeVite = vite;
-        const composition = await buildRendererComposition(config, stdout, {
-            profileId: 'development',
-            permission: { profileId: 'development', policies: [], persistent: false },
-            developmentBuild: (nextConfig, options = {}) => activeVite.buildBootstrap(nextConfig, options),
-        });
         if (invocation.options.dryRun) {
+            const composition = await buildRendererComposition(config, stdout, {
+                profileId: 'development',
+                writable: invocation.options.writeConfig === true,
+                serviceConfigWritable: false,
+                permission: { profileId: 'development', policies: [], persistent: false },
+                developmentBuild: (nextConfig, options = {}) => activeVite.buildBootstrap(nextConfig, options),
+            });
             stdout(JSON.stringify({
                 status: 'ready',
                 mode: 'development',
@@ -458,6 +443,7 @@ export async function runDevelopment(invocation, cwd, stdout, environment, homeC
                         configPath: location.configPath,
                         projectRoot: location.projectRoot,
                         configRoot: location.configRoot,
+                        configurationWrite: composition.configBridgeToken === undefined ? 'read-only' : 'enabled',
                         pluginIds: config.plugins.map(plugin => plugin.id),
                     }
                     : { origin: 'local-dev', pluginId: localIdentity.id, sourcePath: entry }),
@@ -467,13 +453,21 @@ export async function runDevelopment(invocation, cwd, stdout, environment, homeC
             }, null, 2));
             return;
         }
-        if (invocation.options.attach) {
+        const homeConfig = await ensureHomeConfig(homeConfigOptions);
+        if (shouldSkipBuiltinSkillDeployment(environment)) {
+            stdout('[cordisx] built-in Skill deployment skipped by the local acceptance runner');
+        }
+        else if (invocation.options.attach) {
             stdout('[cordisx] built-in Skill deployment skipped for --attach because the Host HOME is unknown');
         }
+        else if (runtime.internalBuiltinSkillSourceDir !== undefined
+            && runtime.internalBuiltinSkillsSourceRootDir === undefined) {
+            await deployBuiltinSkillWithoutOverwritingUserChanges(deployBundledCordisXSkillToHome(runtime.internalSharedHomeDir ?? environment.HOME ?? runtime.homedir ?? os.homedir(), { sourceDir: runtime.internalBuiltinSkillSourceDir }), stdout);
+        }
         else {
-            await deployBuiltinSkillWithoutOverwritingUserChanges(deployBundledCordisXSkillToHome(runtime.internalSharedHomeDir ?? environment.HOME ?? runtime.homedir ?? os.homedir(), runtime.internalBuiltinSkillSourceDir === undefined
+            await deployBuiltinSkillsWithoutOverwritingUserChanges(deployBundledCordisXSkillsToHome(runtime.internalSharedHomeDir ?? environment.HOME ?? runtime.homedir ?? os.homedir(), runtime.internalBuiltinSkillsSourceRootDir === undefined
                 ? {}
-                : { sourceDir: runtime.internalBuiltinSkillSourceDir }), stdout);
+                : { sourceRootDir: runtime.internalBuiltinSkillsSourceRootDir }), stdout);
         }
         const debugPort = invocation.options.debugPort ?? (invocation.options.attach || invocation.options.system ? config.codex.debugPort : await findFreeLoopbackPort());
         if (!invocation.options.attach && (invocation.options.debugPort !== undefined || invocation.options.system)) {
@@ -482,6 +476,84 @@ export async function runDevelopment(invocation, cwd, stdout, environment, homeC
         const executable = invocation.options.attach
             ? undefined
             : await resolveCodexExecutable(invocation.options.executable ?? config.codex.executable);
+        if (executable !== undefined
+            && shouldEnableNativeSubmission({
+                platform: runtime.internalNativeSubmissionPlatform ?? process.platform,
+                adapterId: 'codex',
+                preference: environment.CORDISX_EXPERIMENTAL_NATIVE_SUBMISSION,
+            })) {
+            try {
+                const createActivation = runtime.internalCreateDevelopmentManagedServiceActivation
+                    ?? createDevelopmentManagedServiceActivation;
+                managedServiceActivation = await createActivation({
+                    homeConfigPath,
+                    homeDir: cordisxHomeDir,
+                    environment,
+                });
+                const createNativeSubmission = runtime.internalCreateNativeSubmissionComposition
+                    ?? createNativeSubmissionComposition;
+                nativeSubmission = await createNativeSubmission(managedServiceActivation, executable, codexHome(environment));
+                managedServiceProjection = await createNativeViteManagedServiceProjection({
+                    activation: managedServiceActivation,
+                    profileId: 'development',
+                    runtimeGeneration: managedServiceActivation.hostGeneration,
+                });
+            }
+            catch (error) {
+                await nativeSubmission?.close().catch(() => undefined);
+                nativeSubmission = undefined;
+                await managedServiceProjection?.dispose().catch(() => undefined);
+                managedServiceProjection = undefined;
+                await managedServiceActivation?.dispose().catch(() => undefined);
+                managedServiceActivation = undefined;
+                stdout(`[cordisx] native Desktop model providers unavailable: ${String(error)}`);
+            }
+        }
+        const entityAuthority = new EntityDirectoryAuthority(cordisxHomeDir, 'development');
+        await activeVite.synchronizePluginGenerations(composeNativeVitePluginGenerationHandlers([
+            createNativeViteEntityGenerationHandler(entityAuthority, 'development'),
+            ...(managedServiceProjection === undefined ? [] : [managedServiceProjection.handler]),
+        ]));
+        const managementAppId = homeConfig.defaultApp;
+        const managementApp = ownValue(homeConfig.apps, managementAppId);
+        if (managementApp === undefined)
+            throw new Error(`host app is not configured: ${managementAppId}`);
+        const managementProfileId = managementApp.defaultProfile;
+        pluginManagementService = await openPluginManagementService({
+            configPath: homeConfigPath,
+            homeDir: cordisxHomeDir,
+            appId: managementAppId,
+            profileId: managementProfileId,
+        });
+        const pluginManagementToken = randomBytes(32).toString('hex');
+        const composition = await buildRendererComposition(config, stdout, {
+            profileId: 'development',
+            writable: invocation.options.writeConfig === true,
+            serviceConfigWritable: false,
+            permission: { profileId: 'development', policies: [], persistent: false },
+            ...(managedServiceActivation === undefined ? {} : { generation: managedServiceActivation.hostGeneration }),
+            ...(managedServiceProjection === undefined
+                ? {}
+                : { managedServiceUICapabilities: managedServiceProjection.capabilities() }),
+            pluginManagement: { token: pluginManagementToken, profileId: managementProfileId },
+            developmentBuild: (nextConfig, options = {}) => activeVite.buildBootstrap(nextConfig, options),
+        });
+        const pluginManagement = {
+            token: pluginManagementToken,
+            profileId: managementProfileId,
+            generation: composition.generation,
+            service: pluginManagementService,
+        };
+        const configBridge = composition.configBridgeToken === undefined
+            ? undefined
+            : createLauncherConfigBridgeHandler({
+                token: composition.configBridgeToken,
+                profileId: 'development',
+                generation: composition.generation,
+                configPath: location.configPath,
+                composition: config,
+                preserveComposition: true,
+            });
         const profile = invocation.options.attach || invocation.options.system
             ? undefined
             : await prepareIsolatedCodexProfile(config.rootDir, {
@@ -493,6 +565,10 @@ export async function runDevelopment(invocation, cwd, stdout, environment, homeC
             stable: identities.map(identity => ({ source: identity.source, pluginId: identity.id })),
         });
         const ownerDocumentHandler = createOwnerDocumentBridgeHandler({
+            onDiagnostic: event => stdout(`[cordisx] HTTP transport ${JSON.stringify(event)}`),
+            localWalletHomeDir: cordisxHomeDir,
+            managedSourcesNow: () => loadManagedSourceTrustNow(cordisxHomeDir, 'development'),
+            managedSources: async () => (await import('../launcher/managed-source-trust.js')).loadManagedSourceTrust(cordisxHomeDir, 'development'),
             plugins: config.plugins,
             secret: composition.ownerDocumentSecret,
             profileId: 'development',
@@ -500,8 +576,6 @@ export async function runDevelopment(invocation, cwd, stdout, environment, homeC
             store: new OwnerDocumentStore(cordisxHomeDir),
             principalAllowed: principal => documentLeases.allowed(principal),
         });
-        const entityAuthority = new EntityDirectoryAuthority(cordisxHomeDir, 'development');
-        await activeVite.synchronizePluginGenerations(createNativeViteEntityGenerationHandler(entityAuthority, 'development'));
         const ownerDocuments = Object.assign(ownerDocumentHandler, {
             entities: createEntityBridgeHandler({
                 secret: composition.ownerDocumentSecret,
@@ -517,7 +591,7 @@ export async function runDevelopment(invocation, cwd, stdout, environment, homeC
         let providerFleet;
         let resourcesHandedOff = false;
         try {
-            historyHost = agentHistoryHost(environment, homeConfigPath, `development:${config.rootDir}`);
+            historyHost = agentHistoryHost(environment, homeConfigPath, `development:${config.rootDir}`, workProfile);
             providerFleet = composition.providerBridgeToken === undefined
                 ? undefined
                 : await ProviderFleet.create(providerConfigs(config, environment), {
@@ -525,13 +599,20 @@ export async function runDevelopment(invocation, cwd, stdout, environment, homeC
                     agentLoopAuthority: await AgentLoopAuthority.open(cordisxHomeDir, 'development'),
                 });
             resourcesHandedOff = true;
-            await runInjectedHost({
+            const runHost = runtime.internalRunInjectedHost ?? runInjectedHost;
+            await runHost({
+                ...(nativeSubmission === undefined ? {} : { nativeSubmission: nativeSubmission.installation }),
+                ...(managedServiceProjection === undefined
+                    ? {}
+                    : { managedServiceUI: managedServiceProjection.managedServiceUI }),
                 source: composition.source,
                 viteDevelopment: true,
+                ...(configBridge === undefined ? {} : { configBridge }),
                 hasLoopbackGraph: false,
                 agentHistoryHost: historyHost,
                 agentHistoryBridgeToken: composition.agentHistoryBridgeToken,
                 ownerDocuments,
+                pluginManagement,
                 ...(providerFleet === undefined || composition.providerBridgeToken === undefined ? {} : {
                     providerFleet,
                     providerBridgeToken: composition.providerBridgeToken,
@@ -541,17 +622,26 @@ export async function runDevelopment(invocation, cwd, stdout, environment, homeC
                 hostArgs: invocation.hostArgs,
                 launcher: invocation.options,
                 ...(profile === undefined ? {} : { profile }),
-                ...(entry === undefined ? {} : {
-                    environment: {
-                        CORDISX_DEV_ENTRY: entry,
-                        CORDISX_DEV_MODE: 'explicit-entry',
-                    },
-                }),
+                ...((entry === undefined && nativeSubmission === undefined)
+                    ? {}
+                    : {
+                        environment: {
+                            ...(entry === undefined
+                                ? {}
+                                : {
+                                    CORDISX_DEV_ENTRY: entry,
+                                    CORDISX_DEV_MODE: 'explicit-entry',
+                                }),
+                            ...nativeSubmission?.environment,
+                        },
+                    }),
                 publisherGrant,
                 stdout,
             });
         }
         finally {
+            ownerDocuments.walletSpend?.dispose();
+            await ownerDocuments.http.dispose();
             await ownerDocuments.agentTools?.close();
             if (!resourcesHandedOff) {
                 historyHost?.dispose();
@@ -561,6 +651,10 @@ export async function runDevelopment(invocation, cwd, stdout, environment, homeC
     }
     finally {
         try {
+            await nativeSubmission?.close().catch(() => undefined);
+            await managedServiceProjection?.dispose().catch(() => undefined);
+            await managedServiceActivation?.dispose().catch(() => undefined);
+            pluginManagementService?.close();
             await vite?.close();
         }
         finally {