code-workspace-zhuiyi 1.0.0-beta.3 → 1.0.0-beta.4

package/README.md

@@ -36,6 +36,8 @@ codew init .code-workspace \
   --yes
 ```
 
+Use `--dev false` for an extension-container Workspace; this skips Workspace dependency installation, disables the system development extension, and omits the project onboarding prompt. Run `codew init .code-workspace --dev true --yes` to enable development mode again. The default for a new Workspace is `true`, and an existing Workspace keeps its saved value when the option is omitted.
+
 Use `--tools claude`, `--tools codex`, or `--tools none` to override the default tool selection. Monitoring is not enabled implicitly; install the `monitor` extension with `--extensions monitor` or through the interactive extension picker.
 
 Initialization writes only Workspace-owned state and integrations:

package/README.zh-CN.md

@@ -35,6 +35,8 @@ codew init . \
   --yes
 ```
 
+如果这个 Workspace 主要作为扩展容器使用，可以传 `--dev false`；该模式会跳过 Workspace 依赖安装、停用系统开发扩展并省略项目引导提示。需要恢复开发模式时执行 `codew init . --dev true --yes`。新 Workspace 默认值为 `true`；已有 Workspace 省略该参数时沿用已保存的值。
+
 可用 `--tools claude`、`--tools codex` 或 `--tools none` 覆盖默认工具选择。监控不会隐式启用；请通过 `--extensions monitor` 或交互式扩展选择安装 `monitor` 扩展。
 
 初始化只写入 Workspace 自有状态和集成：

package/artifacts/manifest.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 2,
-  "releaseVersion": "1.0.0-beta.3",
+  "releaseVersion": "1.0.0-beta.4",
   "requirements": {
     "node": ">=20.19.0"
   },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "code-workspace-zhuiyi",
-  "version": "1.0.0-beta.3",
+  "version": "1.0.0-beta.4",
   "description": "Local multi-project registry and safety layer for AI coding workspaces",
   "author": "icebearx-ai",
   "license": "MIT",

package/src/cli/commands/extension.js

@@ -25,6 +25,7 @@ const {
 const { resolveWorkspaceTools } = require("../../core/tools");
 const { createInteractiveUi, formatExtensionChoice } = require("../../init/ui");
 const { createRegistryExtensionPicker } = require("../../init/registry-picker");
+const { formatExtensionChanges } = require("../../init/extension-summary");
 const { confirm } = require("../confirmation");
 const { selectionResult, success } = require("../result");
 
@@ -43,18 +44,11 @@ function formatUninstallPlan(plan) {
 }
 
 function formatInstallPlan(plans, options = {}) {
-  const actionFor = options.actionFor || (() => "install");
-  const title = options.title || `Install ${plans.length} extension${plans.length === 1 ? "" : "s"}:`;
-  return [
-    title,
-    ...plans.flatMap((plan) => [
-      `  ${actionFor(plan) === "update" ? "Update" : "Install"} ${plan.id}@${plan.version} [${plan.source || "local"}] [Extension Spec ${plan.extensionSpecVersion}]`,
-      `    PACKAGE ${plan.packageSha256}`,
-      ...(plan.capabilities.networkHosts || []).map((host) => `    NETWORK https://${host}`),
-      ...plan.artifacts.map((artifact) => `    WRITE ${artifact.target} (${artifact.kind})`),
-      ...(plan.hooks || []).map((hook) => `    HOOK ${hook.id} (${hook.event}${hook.tools?.length ? ` · ${hook.tools.join(",")}` : ""}) -> ${hook.command}`),
-    ]),
-  ].join("\n");
+  return formatExtensionChanges(plans.map((plan) => ({ ...plan, source: plan.source || "local" })), [], {
+    title: options.title,
+    actionFor: options.actionFor,
+    action: options.action,
+  });
 }
 
 function formatRegistrySearchText(result) {
@@ -136,18 +130,35 @@ function lifecycleResultEntry(entry, action) {
 function lifecycleResultText(results, action) {
   const actionFor = typeof action === "function" ? action : () => action;
   const lines = results.map((entry) => entry.status === "installed"
-    ? `${actionFor(entry) === "upgrade" || actionFor(entry) === "update" ? "Updated" : "Installed"} ${entry.id}@${entry.version}.`
-    : entry.status === "skipped"
-      ? `Skipped ${entry.id}@${entry.version}: already current.`
-      : `Failed ${entry.id}${entry.version ? `@${entry.version}` : ""}: ${entry.message}`);
+    ? `${actionFor(entry) === "upgrade" || actionFor(entry) === "update" ? "Updated" : "Installed"} ${entry.name || entry.id}@${entry.version}.`
+    : entry.status === "uninstalled"
+      ? `Uninstalled ${entry.name || entry.id}${entry.version ? `@${entry.version}` : ""}.`
+      : entry.status === "skipped"
+      ? `Skipped ${entry.name || entry.id}${entry.version ? `@${entry.version}` : ""}: already current.`
+      : `Failed ${entry.name || entry.id}${entry.version ? `@${entry.version}` : ""}: ${entry.message}`);
   const installed = results.filter((entry) => entry.status === "installed").length;
+  const uninstalled = results.filter((entry) => entry.status === "uninstalled").length;
   const skipped = results.filter((entry) => entry.status === "skipped").length;
   const failed = results.filter((entry) => entry.status === "failed").length;
   const hasUpdate = results.some((entry) => actionFor(entry) === "upgrade" || actionFor(entry) === "update");
-  lines.push(`Extensions: ${installed} ${hasUpdate ? "applied" : "installed"}, ${skipped} skipped, ${failed} failed.`);
+  lines.push(`Extensions: ${installed} ${hasUpdate ? "applied" : "installed"}, ${uninstalled} uninstalled, ${skipped} skipped, ${failed} failed.`);
   return lines.join("\n");
 }
 
+function uninstallResultEntry(entry) {
+  return {
+    name: entry.id,
+    ok: entry.status !== "failed",
+    action: entry.status === "skipped" ? "skip" : "uninstall",
+    status: entry.status,
+    version: entry.version || null,
+    ...(entry.reason ? { reason: entry.reason } : {}),
+    ...(entry.removed ? { removed: entry.removed } : {}),
+    ...(entry.code ? { code: entry.code } : {}),
+    ...(entry.message ? { message: entry.message } : {}),
+  };
+}
+
 function validateInstallOptions(invocation) {
   if (invocation.options.version) {
     if (invocation.args.length !== 1) {
@@ -331,27 +342,54 @@ async function executeExtensionSearch(invocation) {
     }, "No extensions selected. No changes were made.");
   }
   const requested = normalizeExtensionNames(selected.map((entry) => entry.id));
-  const actionById = new Map(selected.map((entry) => [entry.id, entry.action === "update" ? "update" : "install"]));
+  const actionById = new Map(selected.map((entry) => [entry.id, entry.action || "install"]));
+  const installSelections = selected.filter((entry) => entry.action !== "uninstall" && entry.action !== "keep");
+  const uninstallSelections = selected.filter((entry) => entry.action === "uninstall");
+  const planningState = structuredClone(stateInspection.state);
+  for (const entry of uninstallSelections) delete planningState.extensions[entry.id];
   const tools = resolveWorkspaceTools({ state: loadState(invocation.root), manifestTools: loadInitManifest().tools }).tools;
-  const preparation = await prepareRegistryExtensionPlans({
-    ...dependencies,
-    requested,
-    tools,
-    state: stateInspection.state,
-    stateError: stateInspection.error,
-    extensionsRoot: dependencies.extensionsRoot,
-    extensionStoreRoot: dependencies.extensionStoreRoot || defaultExtensionStoreRoot(),
-    provider: dependencies.nexusProvider,
-  });
-  if (preparation.plans.length > 0) {
-    const planText = formatInstallPlan(preparation.plans, {
-      title: `Apply ${preparation.plans.length} extension${preparation.plans.length === 1 ? "" : "s"}:`,
+  const preparation = installSelections.length > 0
+    ? await prepareRegistryExtensionPlans({
+      ...dependencies,
+      requested: installSelections.map((entry) => entry.id),
+      tools,
+      state: planningState,
+      stateError: stateInspection.error,
+      extensionsRoot: dependencies.extensionsRoot,
+      extensionStoreRoot: dependencies.extensionStoreRoot || defaultExtensionStoreRoot(),
+      provider: dependencies.nexusProvider,
+    })
+    : { plans: [], failures: [], diagnostics: [] };
+  preparation.plans = preparation.plans.map((plan) => ({ ...plan, action: actionById.get(plan.id) || "install" }));
+  const uninstallPlans = [];
+  const uninstallPreparationFailures = [];
+  for (const entry of uninstallSelections) {
+    try {
+      uninstallPlans.push(planExtensionUninstall(invocation.root, entry.id));
+    } catch (error) {
+      uninstallPreparationFailures.push({ id: entry.id, version: null, status: "failed", code: error.code || "EXTENSION_UNINSTALL_FAILED", message: error.message, statePersisted: false, phase: "prepare" });
+    }
+  }
+  const effectiveUninstallPlans = uninstallPlans.filter((plan) => plan.action !== "skip");
+  if (preparation.plans.length > 0 || effectiveUninstallPlans.length > 0) {
+    const planText = formatExtensionChanges(preparation.plans, effectiveUninstallPlans, {
       actionFor: (plan) => actionById.get(plan.id) || "install",
     });
     if (!(await (dependencies.confirm || confirm)(`${planText}\nContinue?`, invocation.options))) {
       throw new WorkspaceError("CLI_CANCELLED", "Extension search selection cancelled.");
     }
   }
+  const uninstallResults = [];
+  for (const plan of effectiveUninstallPlans) {
+    try {
+      uninstallResults.push({ ...applyExtensionUninstall(plan, {
+        ...(dependencies || {}),
+        extensionStoreRoot: dependencies.extensionStoreRoot || defaultExtensionStoreRoot(),
+      }), action: "uninstall" });
+    } catch (error) {
+      uninstallResults.push({ id: plan.id, version: plan.version, status: "failed", action: "uninstall", code: error.code || "EXTENSION_UNINSTALL_FAILED", message: error.message });
+    }
+  }
   const batch = runExtensionBatch(invocation.root, preparation.plans, (extension) => ({
     schemaVersion: 1,
     extensionSpecVersion: extension.extensionSpecVersion,
@@ -359,8 +397,8 @@ async function executeExtensionSearch(invocation) {
     workspace: { name: workspace.name, uuid: workspace.uuid, language: workspace.language },
     tools,
   }), {
-    requested,
-    preFailures: preparation.failures,
+    requested: installSelections.map((entry) => entry.id),
+    preFailures: [...preparation.failures, ...uninstallPreparationFailures],
     useExtensionStore: true,
     extensionStoreRoot: dependencies.extensionStoreRoot || defaultExtensionStoreRoot(),
   });
@@ -381,12 +419,32 @@ async function executeExtensionSearch(invocation) {
       extension: entry.id,
       version: entry.version,
     }))),
+    ...uninstallResults.filter((entry) => entry.status === "failed").map((entry) => ({
+      code: entry.code || "EXTENSION_UNINSTALL_FAILED",
+      severity: "error",
+      message: entry.message || `Extension ${entry.id} failed to uninstall.`,
+      extension: entry.id,
+      version: entry.version,
+    })),
   ];
-  const results = decorateBatchResults(batch, preparation.plans, invocation.options);
+  const installedResults = decorateBatchResults(batch, preparation.plans, invocation.options);
+  const resultById = new Map([
+    ...installedResults.map((entry) => [entry.id, entry]),
+    ...uninstallResults.map((entry) => [entry.id, entry]),
+    ...uninstallPreparationFailures.map((entry) => [entry.id, entry]),
+  ]);
+  const rawResults = selected.map((selection) => {
+    if (selection.action === "keep") {
+      return { id: selection.id, version: stateInspection.state.extensions[selection.id]?.installed?.version || null, status: "skipped", reason: "already-installed", action: "skip" };
+    }
+    const entry = resultById.get(selection.id);
+    return entry || { id: selection.id, status: "failed", message: "Extension operation did not run." };
+  });
+  const results = rawResults.map((entry) => lifecycleResultEntry(entry, entry.action || actionById.get(entry.id) || "install"));
   ui.close?.("Extension selection applied.");
-  return selectionResult("extension.search", requested, results.map((entry) => lifecycleResultEntry(entry, actionById.get(entry.id) || "install")), {
+  return selectionResult("extension.search", requested, results, {
     diagnostics,
-    text: lifecycleResultText(results, (entry) => actionById.get(entry.id) || "install"),
+    text: lifecycleResultText(results, (entry) => entry.action || actionById.get(entry.id) || "install"),
   });
 }
 

package/src/cli/commands/init.js

@@ -1,13 +1,15 @@
 const path = require("node:path");
 
-const { loadState } = require("../../core/config");
+const { loadState, resolveWorkspaceDev } = require("../../core/config");
 const { WorkspaceError } = require("../../core/errors");
 const { acquireInitLock } = require("../../core/init-lock");
 const {
+  applyExtensionUninstall,
   discoverSystemExtensions,
   emptyExtensionState,
   inspectExtensionState,
   parseExtensionSelection,
+  planExtensionUninstall,
   prepareExtensionPlans,
   runExtensionBatch,
 } = require("../../core/extensions");
@@ -19,6 +21,7 @@ const { initializeWorkspace } = require("../../core/initializer");
 const { resolveWorkspaceTools } = require("../../core/tools");
 const { collectInitPlan } = require("../../init/wizard");
 const { createRegistryExtensionPicker, mapPickerPage } = require("../../init/registry-picker");
+const { formatExtensionChanges } = require("../../init/extension-summary");
 const { success } = require("../result");
 
 function stateWithPlans(state, plans) {
@@ -54,6 +57,17 @@ function migrationData(plan) {
   };
 }
 
+function parseDevOption(value) {
+  if (value === undefined) return undefined;
+  if (value === "true") return true;
+  if (value === "false") return false;
+  throw new WorkspaceError("CLI_INVALID_OPTION_VALUE", "--dev requires true or false", {
+    option: "dev",
+    value,
+    allowed: ["true", "false"],
+  });
+}
+
 async function executeInit(invocation) {
   const root = path.resolve(invocation.args[0] || ".");
   const releaseInitLock = await acquireInitLock(root);
@@ -66,6 +80,8 @@ async function executeInit(invocation) {
 
 async function executeInitUnlocked(invocation, root) {
   const { options } = invocation;
+  const requestedDev = parseDevOption(options.dev);
+  const dev = resolveWorkspaceDev(root, requestedDev);
   const dependencies = invocation.dependencies && Object.prototype.hasOwnProperty.call(invocation.dependencies, "defaultRegistryUrl")
     ? invocation.dependencies
     : { ...(invocation.dependencies || {}), defaultRegistryUrl: DEFAULT_NEXUS_REGISTRY };
@@ -97,7 +113,13 @@ async function executeInitUnlocked(invocation, root) {
   const extensionStateInspection = inspectExtensions ? inspectExtensionState(root) : { state: emptyExtensionState(), error: null };
   const extensionState = extensionStateInspection.state;
   const systemCatalogResult = inspectExtensions ? discoverSystemExtensions({ tolerant: true }) : { catalog: [], invalid: [] };
-  const systemRequestedExtensions = systemCatalogResult.catalog.filter((entry) => entry.latestSupported).map((entry) => entry.id);
+  const systemExtensionIds = systemCatalogResult.catalog.filter((entry) => entry.latestSupported).map((entry) => entry.id);
+  const systemRequestedExtensions = dev ? systemExtensionIds : [];
+  const systemRemovalPlans = dev || extensionStateInspection.error
+    ? []
+    : Object.entries(extensionState.extensions)
+      .filter(([id, entry]) => entry.installed?.system === true || systemExtensionIds.includes(id))
+      .map(([id]) => planExtensionUninstall(root, id, { systemManaged: true }));
   let systemPreparation = { plans: [], failures: [], diagnostics: [] };
   let planningState = extensionState;
   const prepareSystemForTools = (tools) => {
@@ -112,17 +134,27 @@ async function executeInitUnlocked(invocation, root) {
   if (!interactive) prepareSystemForTools(resolvedTools.tools);
   let interactiveOrdinaryPreparation = { plans: [], failures: [], diagnostics: [] };
   const prepareOrdinaryExtensions = async (selected, selectedTools) => {
+    const installSelections = selected.filter((entry) => entry.action !== "uninstall" && entry.action !== "keep");
+    const uninstallSelections = selected.filter((entry) => entry.action === "uninstall");
+    const uninstallPlans = uninstallSelections.map((entry) => planExtensionUninstall(root, entry.id));
+    const installState = structuredClone(planningState);
+    for (const entry of uninstallSelections) delete installState.extensions[entry.id];
     interactiveOrdinaryPreparation = await prepareRegistryExtensionPlans({
       ...dependencies,
-      requested: selected.map((entry) => entry.id),
+      requested: installSelections.map((entry) => entry.id),
       tools: selectedTools || resolvedTools.tools,
-      state: planningState,
+      state: installState,
       stateError: extensionStateInspection.error,
       extensionsRoot: dependencies.extensionsRoot,
       extensionStoreRoot: options.extensionStoreRoot || dependencies.extensionStoreRoot || defaultExtensionStoreRoot(),
       provider: dependencies.nexusProvider,
     });
-    return interactiveOrdinaryPreparation.plans;
+    interactiveOrdinaryPreparation.plans = interactiveOrdinaryPreparation.plans.map((plan) => ({
+      ...plan,
+      action: selected.find((entry) => entry.id === plan.id)?.action || "install",
+    }));
+    interactiveOrdinaryPreparation.uninstallPlans = uninstallPlans;
+    return interactiveOrdinaryPreparation;
   };
   let plan = null;
   if (interactive) {
@@ -138,7 +170,8 @@ async function executeInitUnlocked(invocation, root) {
         initialExtensions: explicitExtensions === null ? undefined : explicitExtensions,
         prepareSystemExtensions: prepareSystemForTools,
         prepareExtensions: prepareOrdinaryExtensions,
-        extensionPicker: createRegistryExtensionPicker({ dependencies, state: extensionState, systemIds: new Set(systemRequestedExtensions) }),
+        extensionPicker: createRegistryExtensionPicker({ dependencies, state: extensionState, systemIds: new Set(systemExtensionIds) }),
+        formatExtensionChanges,
       });
     } catch (error) {
       if (error.code === "INIT_CANCELLED") {
@@ -151,7 +184,12 @@ async function executeInitUnlocked(invocation, root) {
   const ordinaryRequestedExtensions = explicitExtensions !== null
     ? explicitExtensions
     : plan ? plan.extensions.filter((entry) => entry.system !== true).map((entry) => entry.id) : [];
-  const requestedExtensions = [...new Set([...ordinaryRequestedExtensions, ...systemRequestedExtensions])];
+  const ordinaryRemovalPlans = plan?.extensionRemovals || [];
+  const requestedExtensions = [...new Set([
+    ...ordinaryRequestedExtensions,
+    ...ordinaryRemovalPlans.map((entry) => typeof entry === "string" ? entry : entry.id),
+    ...systemRequestedExtensions,
+  ])];
   const extensionPreparation = { plans: [], failures: [], diagnostics: [] };
   if (interactive) {
     extensionPreparation.plans = [...systemPreparation.plans, ...interactiveOrdinaryPreparation.plans];
@@ -182,6 +220,7 @@ async function executeInitUnlocked(invocation, root) {
   const result = await initializeWorkspace(root, {
     run,
     tools,
+    dev,
     force: options.force === true,
     yes: plan ? true : options.yes === true,
     workspaceName: plan?.workspace.name || options["workspace-name"],
@@ -191,7 +230,46 @@ async function executeInitUnlocked(invocation, root) {
     initPlan: plan,
     onStage: null,
   });
-  const extensionResult = runExtensionBatch(root, extensionPlans, (extension) => ({
+  const systemRemovalResults = [];
+  const systemRemovalDiagnostics = [];
+  for (const removalPlan of systemRemovalPlans) {
+    try {
+      systemRemovalResults.push(applyExtensionUninstall(removalPlan, {
+        systemManaged: true,
+        extensionStoreRoot: options.extensionStoreRoot || dependencies.extensionStoreRoot || defaultExtensionStoreRoot(),
+      }));
+    } catch (error) {
+      systemRemovalResults.push({
+        id: removalPlan.id,
+        version: removalPlan.version,
+        status: "failed",
+        code: error.code || "SYSTEM_EXTENSION_DISABLE_FAILED",
+        message: error.message,
+      });
+      systemRemovalDiagnostics.push({
+        code: "SYSTEM_EXTENSION_DISABLE_FAILED",
+        severity: "warning",
+        message: `System extension ${removalPlan.id} could not be disabled: ${error.message}`,
+        extension: removalPlan.id,
+        causeCode: error.code || null,
+      });
+    }
+  }
+  const ordinaryRemovalResults = [];
+  const ordinaryRemovalDiagnostics = [];
+  for (const removalPlan of ordinaryRemovalPlans) {
+    const planToApply = typeof removalPlan === "string" ? planExtensionUninstall(root, removalPlan) : removalPlan;
+    try {
+      const removal = applyExtensionUninstall(planToApply, {
+        extensionStoreRoot: options.extensionStoreRoot || dependencies.extensionStoreRoot || defaultExtensionStoreRoot(),
+      });
+      ordinaryRemovalResults.push({ ...removal, action: removal.status === "skipped" ? "skip" : "uninstall" });
+    } catch (error) {
+      ordinaryRemovalResults.push({ id: planToApply.id, version: planToApply.version || null, status: "failed", action: "uninstall", code: error.code || "EXTENSION_UNINSTALL_FAILED", message: error.message });
+      ordinaryRemovalDiagnostics.push({ code: error.code || "EXTENSION_UNINSTALL_FAILED", severity: "warning", message: `Extension ${planToApply.id} failed to uninstall: ${error.message}`, extension: planToApply.id });
+    }
+  }
+  const extensionBatch = runExtensionBatch(root, extensionPlans, (extension) => ({
     schemaVersion: 1,
     extensionSpecVersion: extension.extensionSpecVersion,
     extension: { id: extension.id, version: extension.version },
@@ -202,12 +280,31 @@ async function executeInitUnlocked(invocation, root) {
     },
     tools,
   }), {
-    requested: requestedExtensions,
+    requested: [...new Set([...ordinaryRequestedExtensions, ...systemRequestedExtensions])],
     preFailures: extensionPreparation.failures,
     useExtensionStore: true,
     extensionStoreRoot: options.extensionStoreRoot || defaultExtensionStoreRoot(),
   });
+  const extensionResultEntries = [...ordinaryRemovalResults, ...extensionBatch.results];
+  const extensionResult = {
+    requested: requestedExtensions,
+    results: extensionResultEntries,
+    summary: {
+      installed: extensionResultEntries.filter((entry) => entry.status === "installed").length,
+      uninstalled: extensionResultEntries.filter((entry) => entry.status === "uninstalled").length,
+      skipped: extensionResultEntries.filter((entry) => entry.status === "skipped").length,
+      failed: extensionResultEntries.filter((entry) => entry.status === "failed").length,
+    },
+  };
   const extensionDiagnostics = [
+    ...(dev === false && extensionStateInspection.error ? [{
+      code: "SYSTEM_EXTENSION_DISABLE_SKIPPED",
+      severity: "warning",
+      message: `System extension cleanup was skipped because extension state could not be read: ${extensionStateInspection.error.message}`,
+      causeCode: extensionStateInspection.error.code || null,
+    }] : []),
+    ...systemRemovalDiagnostics,
+    ...ordinaryRemovalDiagnostics,
     ...extensionPreparation.diagnostics,
     ...extensionResult.results
     .filter((entry) => entry.status === "failed")
@@ -240,6 +337,7 @@ async function executeInitUnlocked(invocation, root) {
     managedFiles: result.managedFiles,
     localConfig: result.localConfig,
     workspace: result.workspaceConfig.workspace,
+    dev: result.workspaceConfig.workspace.dev,
     language: result.language,
     tools: toolSelection,
     migration: migrationData(result.migration),
@@ -247,6 +345,10 @@ async function executeInitUnlocked(invocation, root) {
     verification: result.verification,
     plan: result.initPlan,
     stages: result.stages.map((stage) => stage.name),
+    systemExtensions: {
+      enabled: dev,
+      results: systemRemovalResults,
+    },
     extensions: extensionResult,
   };
   const lines = [
@@ -254,9 +356,9 @@ async function executeInitUnlocked(invocation, root) {
     `Workspace: ${result.workspaceConfig.workspace.name} (${result.workspaceConfig.workspace.uuid})`,
     `Language: ${result.language}`,
     `Tools: ${tools.length ? tools.join(", ") : "none"} (${toolSelection.source})`,
-    `Extensions: ${extensionResult.summary.installed} installed, ${extensionResult.summary.skipped} skipped, ${extensionResult.summary.failed} failed`,
+    `Extensions: ${extensionResult.summary.installed} installed, ${extensionResult.summary.uninstalled || 0} uninstalled, ${extensionResult.summary.skipped} skipped, ${extensionResult.summary.failed} failed`,
   ];
-  if (result.localConfig.action === "write" || result.permissions.action === "skip") {
+  if (result.workspaceConfig.workspace.dev !== false && (result.localConfig.action === "write" || result.permissions.action === "skip")) {
     lines.push(tools.length > 0
       ? "Add local projects with the `codew-add-projects` skill."
       : "Add local projects with `code-workspace project inspect`, then register a complete project record.");
@@ -264,4 +366,4 @@ async function executeInitUnlocked(invocation, root) {
   return success("init", data, lines.join("\n"), extensionDiagnostics);
 }
 
-module.exports = { createRegistryExtensionPicker, executeInit, mapPickerPage, migrationData, stateWithPlans };
+module.exports = { createRegistryExtensionPicker, executeInit, mapPickerPage, migrationData, parseDevOption, stateWithPlans };

package/src/cli/registry.js

@@ -41,7 +41,7 @@ const COMMANDS = [
   { path: ["config", "set"], args: [{ name: "key", required: true }, { name: "value", required: true }], workspace: "none", config: [], interaction: "never", effects: "planned-write", options: {} },
   { path: ["config", "delete"], args: [{ name: "key", required: true }], workspace: "none", config: [], interaction: "never", effects: "planned-write", options: {} },
   { path: ["init"], args: [{ name: "path", required: false }], workspace: "target", config: [], interaction: "optional", effects: "planned-write", options: {
-    tools: { type: "string" }, extensions: { type: "string" }, "workspace-name": { type: "string" }, language: { type: "string" },
+    tools: { type: "string" }, extensions: { type: "string" }, "workspace-name": { type: "string" }, language: { type: "string" }, dev: { type: "string" },
     yes: { type: "boolean" }, force: { type: "boolean" },
   } },
   { path: ["update"], args: [], workspace: "required", config: [], interaction: "optional", effects: "planned-write", options: {

package/src/core/config.js

@@ -39,6 +39,22 @@ function statePath(root) {
   return path.join(root, LOCAL_DIRECTORY, STATE_FILE);
 }
 
+function resolveWorkspaceDev(root, explicit) {
+  if (explicit !== undefined) return explicit;
+  if (!fs.existsSync(configPath(root))) return true;
+  const document = readConfigDocument(root);
+  const dev = document.value.workspace?.dev;
+  if (dev === undefined) return true;
+  if (typeof dev !== "boolean") {
+    throw new WorkspaceError("WORKSPACE_DEV_INVALID", "workspace.dev must be a boolean", {
+      actual: dev,
+      supported: [true, false],
+      file: document.file,
+    });
+  }
+  return dev;
+}
+
 function findWorkspaceRoot(start = process.cwd()) {
   let current = path.resolve(start);
   while (true) {
@@ -91,7 +107,18 @@ function normalizeWorkspaceLanguage(value, options = {}) {
 function normalizeWorkspace(value, options = {}) {
   const identity = normalizeWorkspaceIdentity(value);
   if (!identity) return null;
-  return { ...identity, language: normalizeWorkspaceLanguage(value.language, options) };
+  const dev = value.dev;
+  if (dev !== undefined && typeof dev !== "boolean") {
+    throw new WorkspaceError("WORKSPACE_DEV_INVALID", "workspace.dev must be a boolean", {
+      actual: dev,
+      supported: [true, false],
+    });
+  }
+  return {
+    ...identity,
+    language: normalizeWorkspaceLanguage(value.language, options),
+    ...(dev === undefined ? {} : { dev }),
+  };
 }
 
 function normalizeProjects(value) {
@@ -508,6 +535,7 @@ module.exports = {
   renderProjectConfig,
   resolveProjectConfigPath,
   resolveProjectConfigReference,
+  resolveWorkspaceDev,
   requireWorkspaceRoot,
   saveConfig,
   saveProjectConfig,

package/src/core/extensions.js

@@ -1453,14 +1453,15 @@ function runExtensionBatch(root, plans, context, options = {}) {
   };
 }
 
-function planExtensionUninstall(root, id) {
+function planExtensionUninstall(root, id, options = {}) {
   const extensionId = validateExtensionName(id);
-  if (isSystemExtensionId(extensionId)) {
+  const systemManaged = options.systemManaged === true;
+  if (!systemManaged && isSystemExtensionId(extensionId)) {
     throw extensionError("EXTENSION_SYSTEM_MANAGED", `System extension cannot be manually uninstalled: ${extensionId}`, { extension: extensionId });
   }
   const state = loadExtensionState(root);
   const installed = state.extensions[extensionId]?.installed || null;
-  if (installed?.system === true) {
+  if (!systemManaged && installed?.system === true) {
     throw extensionError("EXTENSION_SYSTEM_MANAGED", `System extension cannot be manually uninstalled: ${extensionId}`, { extension: extensionId });
   }
   if (!installed) return Object.freeze({ root: path.resolve(root), id: extensionId, action: "skip", reason: "not-installed", targets: [] });
@@ -1473,6 +1474,7 @@ function planExtensionUninstall(root, id) {
   return Object.freeze({
     root: path.resolve(root),
     id: extensionId,
+    system: installed.system === true,
     action: "remove",
     version: installed.version,
     packageSha256: installed.packageSha256 || null,
@@ -1485,7 +1487,7 @@ function planExtensionUninstall(root, id) {
 }
 
 function applyExtensionUninstall(plan, options = {}) {
-  if (plan.system === true || isSystemExtensionId(plan.id)) {
+  if (options.systemManaged !== true && (plan.system === true || isSystemExtensionId(plan.id))) {
     throw extensionError("EXTENSION_SYSTEM_MANAGED", `System extension cannot be manually uninstalled: ${plan.id}`, { extension: plan.id });
   }
   if (plan.action === "skip") return { id: plan.id, status: "skipped", reason: plan.reason, removed: [] };

package/src/core/initializer.js

@@ -50,11 +50,16 @@ async function collectWorkspaceSetup(root, options = {}) {
   const file = configPath(root);
   if (fs.existsSync(file)) {
     const current = loadConfig(root, { defaultLanguage: language });
+    const workspace = {
+      ...current.workspace,
+      dev: options.dev ?? current.workspace.dev ?? true,
+    };
     return normalizeConfig({
       ...current,
-      workspace: current.workspace || {
+      workspace: current.workspace ? workspace : {
         name: options.workspaceName || DEFAULT_WORKSPACE_NAME,
         uuid: randomUUID(),
+        dev: options.dev ?? true,
       },
     });
   }
@@ -71,7 +76,7 @@ async function collectWorkspaceSetup(root, options = {}) {
   }
   return normalizeConfig({
     schemaVersion: 2,
-    workspace: { name: name || DEFAULT_WORKSPACE_NAME, uuid: options.workspaceUuid || randomUUID(), language },
+    workspace: { name: name || DEFAULT_WORKSPACE_NAME, uuid: options.workspaceUuid || randomUUID(), language, dev: options.dev ?? true },
     projects: [],
   });
 }
@@ -106,7 +111,9 @@ async function initializeWorkspaceStages(rootInput, options = {}) {
   }
 
   const dependencies = await stage("Install workspace dependencies", () =>
-    installWorkspaceDependencies(root, { run })
+    workspaceConfig.workspace.dev === false
+      ? { action: "skip", reason: "development mode disabled" }
+      : installWorkspaceDependencies(root, { run })
   );
   if (dependencies.action === "install") {
     options.transaction?.recordExternalEffect({

package/src/init/clack-extension-picker.js

@@ -50,8 +50,13 @@ function mergePageSelections(selected, page, values) {
   }
 }
 
-function selectedResult(selected) {
-  return [...selected.entries()].map(([id, action]) => ({ id, action }));
+function selectedResult(selected, installedIds = []) {
+  const result = [...selected.entries()].map(([id, action]) => ({ id, action }));
+  const selectedIds = new Set(selected.keys());
+  for (const id of installedIds) {
+    if (!selectedIds.has(id)) result.push({ id, action: "uninstall" });
+  }
+  return result;
 }
 
 function pageOptions(page) {
@@ -140,7 +145,9 @@ async function runClackExtensionPicker(options = {}) {
   }
 
   const selected = new Map();
-  for (const id of options.selectedIds || []) selected.set(String(id), "install");
+  const selectionActions = options.selectionActions || {};
+  for (const id of options.selectedIds || []) selected.set(String(id), selectionActions[id] || "install");
+  const installedIds = [...new Set((options.installedIds || []).map(String))];
   let query = String(options.query || "");
   let session = null;
   let page = null;
@@ -203,7 +210,7 @@ async function runClackExtensionPicker(options = {}) {
       }
       if (action === "done") {
         closeSession();
-        return { status: "submitted", selections: selectedResult(selected) };
+        return { status: "submitted", selections: selectedResult(selected, installedIds) };
       }
       if (action === "search") {
         promptForQuery = true;
@@ -255,7 +262,7 @@ async function runClackExtensionPicker(options = {}) {
         closeSession();
         return {
           status: "submitted",
-          selections: selectedResult(selected),
+          selections: selectedResult(selected, installedIds),
         };
       }
       if (action === "search") {
@@ -284,7 +291,7 @@ async function runClackExtensionPicker(options = {}) {
           closeSession();
           return {
             status: "submitted",
-            selections: selectedResult(selected),
+            selections: selectedResult(selected, installedIds),
           };
         }
         if (retryAction === "retry") {

package/src/init/extension-picker.js

@@ -23,8 +23,8 @@ function normalizePickerItem(value) {
   const status = PICKER_STATUSES.includes(item.status)
     ? item.status
     : item.available === false ? "unavailable" : "not-installed";
-  const disabled = item.disabled === true || status === "installed-current" || status === "unavailable";
-  const action = disabled ? "none" : status === "installed-outdated" ? "update" : "install";
+  const disabled = item.disabled === true || status === "unavailable" || (status === "installed-current" && item.allowUninstall !== true);
+  const action = disabled ? "none" : item.action || (status === "installed-outdated" ? "update" : status === "installed-current" ? "keep" : "install");
   return Object.freeze({
     ...item,
     id,
@@ -69,6 +69,7 @@ function createPickerState(options = {}) {
     error: null,
     selectedIds: Object.freeze([...(options.selectedIds || [])]),
     selectionActions: Object.freeze({ ...(options.selectionActions || {}) }),
+    installedIds: Object.freeze([...(options.installedIds || [])]),
     cancelled: false,
     submitted: false,
     statusMessage: "",
@@ -80,7 +81,12 @@ function withState(state, changes) {
 }
 
 function selectedResult(state) {
-  return state.selectedIds.map((id) => ({ id, action: state.selectionActions[id] || "install" }));
+  const selected = new Set(state.selectedIds);
+  const result = state.selectedIds.map((id) => ({ id, action: state.selectionActions[id] || "install" }));
+  for (const id of state.installedIds || []) {
+    if (!selected.has(id)) result.push({ id, action: "uninstall" });
+  }
+  return result;
 }
 
 function currentItem(state) {
@@ -284,7 +290,7 @@ async function runExtensionPicker(options = {}) {
     renderedLines = lines.length + 1;
   });
   const events = options.events || keypressEvents(options.input || process.stdin);
-  let state = createPickerState({ query: options.query || "", selectedIds: options.selectedIds, selectionActions: options.selectionActions });
+  let state = createPickerState({ query: options.query || "", selectedIds: options.selectedIds, selectionActions: options.selectionActions, installedIds: options.installedIds });
   let session = await resolvePageProvider(pageProvider, state.query);
 
   async function load(method, event = "load-start") {

package/src/init/extension-summary.js

@@ -0,0 +1,51 @@
+const { LOCAL_DIRECTORY } = require("../core/config");
+const { EXTENSION_STATE_FILE } = require("../core/extensions");
+
+function pluralizeExtension(count) {
+  return `extension${count === 1 ? "" : "s"}`;
+}
+
+function installAction(plan, actionFor) {
+  const action = actionFor(plan);
+  return action === "update" ? "Update" : "Install";
+}
+
+function formatExtensionChanges(installPlans = [], uninstallPlans = [], options = {}) {
+  const plans = Array.from(installPlans || []);
+  const removals = Array.from(uninstallPlans || []);
+  const total = plans.length + removals.filter((plan) => plan?.action !== "skip").length;
+  if (total === 0) return "No extension changes.";
+
+  const hasInstall = plans.length > 0;
+  const hasUninstall = removals.some((plan) => plan?.action !== "skip");
+  const title = options.title || (hasInstall && hasUninstall
+    ? `Apply ${total} extension changes:`
+    : hasUninstall
+      ? `Uninstall ${total} ${pluralizeExtension(total)}:`
+      : `${options.action === "update" ? "Update" : "Install"} ${total} ${pluralizeExtension(total)}:`);
+  const actionFor = options.actionFor || ((plan) => plan.action || options.action || "install");
+  const lines = [title];
+
+  for (const plan of plans) {
+    const details = [plan.source, plan.extensionSpecVersion ? `Extension Spec ${plan.extensionSpecVersion}` : null].filter(Boolean);
+    lines.push(`  ${installAction(plan, actionFor)} ${plan.id}@${plan.version}${details.length ? ` [${details.join("] [")}]` : ""}`);
+    lines.push(`    PACKAGE ${plan.packageSha256}`);
+    for (const host of plan.capabilities?.networkHosts || []) lines.push(`    NETWORK https://${host}`);
+    for (const artifact of plan.artifacts || []) lines.push(`    WRITE ${artifact.target} (${artifact.kind})`);
+    for (const hook of plan.hooks || []) {
+      lines.push(`    HOOK ${hook.id} (${hook.event}${hook.tools?.length ? ` · ${hook.tools.join(",")}` : ""}) -> ${hook.command}`);
+    }
+  }
+
+  for (const plan of removals) {
+    if (!plan || plan.action === "skip") continue;
+    const id = typeof plan === "string" ? plan : plan.id;
+    const version = typeof plan === "string" ? null : plan.version;
+    lines.push(`  Uninstall ${id}${version ? `@${version}` : ""}`);
+    for (const target of plan.targets || []) lines.push(`    REMOVE ${target}`);
+    lines.push(`    REMOVE ${LOCAL_DIRECTORY}/${EXTENSION_STATE_FILE} entry`);
+  }
+  return lines.join("\n");
+}
+
+module.exports = { formatExtensionChanges };

package/src/init/plan.js

@@ -1,10 +1,11 @@
-function createInitPlan({ root, workspace, tools, language, extensions = [] }) {
+function createInitPlan({ root, workspace, tools, language, extensions = [], extensionRemovals = [] }) {
   return {
     root,
     workspace,
     tools: tools.slice(),
     language,
     extensions: extensions.slice(),
+    extensionRemovals: extensionRemovals.slice(),
   };
 }
 

package/src/init/registry-picker.js

@@ -23,7 +23,9 @@ function mapPickerPage(page, state = emptyExtensionState(), systemIds = new Set(
         version: candidate?.version || null,
         packageSha256: candidate?.packageSha256 || null,
         status,
-        disabled: status === "installed-current" || status === "unavailable",
+        disabled: status === "unavailable",
+        allowUninstall: Boolean(installed),
+        action: status === "installed-outdated" ? "update" : status === "installed-current" ? "keep" : "install",
       };
     });
   return { ...page, items };
@@ -31,9 +33,15 @@ function mapPickerPage(page, state = emptyExtensionState(), systemIds = new Set(
 
 function createRegistryExtensionPicker({ dependencies = {}, state = emptyExtensionState(), systemIds = new Set() }) {
   const createSession = dependencies.createRegistryExtensionBrowseSession || createRegistryExtensionBrowseSession;
+  const installedIds = Object.entries(state.extensions || {})
+    .filter(([id, entry]) => entry?.installed && entry.installed.system !== true && !systemIds.has(id))
+    .map(([id]) => id);
+  const installedSelectionActions = Object.fromEntries(installedIds.map((id) => [id, "keep"]));
   return async ({ ui, query = "", selectedIds = [] }) => ui.extensionPicker({
     query,
-    selectedIds,
+    selectedIds: selectedIds.length > 0 ? selectedIds : installedIds,
+    selectionActions: installedSelectionActions,
+    installedIds,
     pageProvider: async (pageQuery) => {
       const session = await createSession({
         ...dependencies,

package/src/init/wizard.js

@@ -17,15 +17,25 @@ function normalizePickerSelections(value) {
   }).filter((entry) => entry.id);
 }
 
+function normalizePreparedExtensions(value, selected = []) {
+  const prepared = Array.isArray(value) ? { plans: value } : (value || {});
+  return {
+    plans: Array.from(prepared.plans || []),
+    uninstallPlans: Array.isArray(prepared.uninstallPlans)
+      ? Array.from(prepared.uninstallPlans)
+      : selected.filter((entry) => entry.action === "uninstall").map((entry) => entry.id),
+  };
+}
+
 async function collectExtensionPlans(options, ui, tools) {
   if (options.extensions !== undefined) {
     const selected = normalizePickerSelections(options.extensions);
-    if (typeof options.prepareExtensions === "function") return options.prepareExtensions(selected, tools);
+    if (typeof options.prepareExtensions === "function") return normalizePreparedExtensions(await options.prepareExtensions(selected, tools), selected);
     const catalog = options.extensionCatalog || [];
-    return resolveExtensionPlans(catalog, selected.map((entry) => entry.id), {
+    return { plans: resolveExtensionPlans(catalog, selected.filter((entry) => entry.action !== "uninstall" && entry.action !== "keep").map((entry) => entry.id), {
       tools,
       state: options.extensionState,
-    });
+    }), uninstallPlans: [] };
   }
 
   if (typeof options.extensionPicker === "function") {
@@ -35,21 +45,21 @@ async function collectExtensionPlans(options, ui, tools) {
         selectedIds: options.initialExtensions || [],
         query: options.extensionQuery || "",
       }));
-      if (typeof options.prepareExtensions === "function") return options.prepareExtensions(selected, tools);
-      return selected;
+      if (typeof options.prepareExtensions === "function") return normalizePreparedExtensions(await options.prepareExtensions(selected, tools), selected);
+      return { plans: selected.filter((entry) => entry.action !== "uninstall" && entry.action !== "keep"), uninstallPlans: selected.filter((entry) => entry.action === "uninstall").map((entry) => entry.id) };
     } catch (error) {
       ui.note("Extensions unavailable", [
         error.message || "The Nexus extension Registry could not be reached.",
         "Ordinary extensions will be skipped; core Workspace initialization can continue.",
       ]);
-      return [];
+      return { plans: [], uninstallPlans: [] };
     }
   }
 
   // Kept for direct callers that inject a catalog (production init no longer does).
   const extensionCatalog = options.extensionCatalog || [];
   const supportedExtensions = extensionCatalog.filter((entry) => entry.latestSupported);
-  if (supportedExtensions.length === 0) return [];
+  if (supportedExtensions.length === 0) return { plans: [], uninstallPlans: [] };
   const extensionNames = await ui.multiselect(
     "Extensions (experimental, select any)",
     supportedExtensions.map((entry) => ({
@@ -58,10 +68,10 @@ async function collectExtensionPlans(options, ui, tools) {
     })),
     options.initialExtensions !== undefined ? options.initialExtensions : []
   );
-  return resolveExtensionPlans(extensionCatalog, extensionNames, {
+  return { plans: resolveExtensionPlans(extensionCatalog, extensionNames, {
     tools,
     state: options.extensionState,
-  });
+  }), uninstallPlans: [] };
 }
 
 async function collectInitPlan(root, manifest, options = {}) {
@@ -101,18 +111,31 @@ async function collectInitPlan(root, manifest, options = {}) {
   const systemExtensions = typeof options.prepareSystemExtensions === "function"
     ? await options.prepareSystemExtensions(tools)
     : (options.systemExtensions || []);
+  const ordinary = await collectExtensionPlans(options, ui, tools);
   const extensions = [
     ...systemExtensions,
-    ...(await collectExtensionPlans(options, ui, tools)),
+    ...ordinary.plans,
   ];
   const workspace = existing?.workspace || { name, uuid: randomUUID() };
-  const plan = createInitPlan({ root, workspace, tools, language, extensions });
+  const extensionRemovals = ordinary.uninstallPlans || [];
+  const plan = createInitPlan({ root, workspace, tools, language, extensions, extensionRemovals });
+  const extensionChanges = [
+    ...extensions.map((entry) => `${entry.action === "update" ? "Update" : "Install"} ${entry.id}@${entry.version}`),
+    ...extensionRemovals.map((entry) => typeof entry === "string" ? `Uninstall ${entry}` : `Uninstall ${entry.id}@${entry.version}`),
+  ];
   ui.note("Ready to initialize", [
     `Workspace  ${workspace.name}`,
     `Language   ${language}`,
     `Tools      ${tools.length ? tools.join(", ") : "none"}`,
     `Extensions ${extensions.length ? extensions.map((entry) => `${entry.id}@${entry.version} [Spec ${entry.extensionSpecVersion}] (${entry.manifestSha256})`).join(", ") : "none"}`,
+    `Changes    ${extensionChanges.length ? extensionChanges.join(", ") : "none"}`,
   ]);
+  if (extensionChanges.length) {
+    const formatted = typeof options.formatExtensionChanges === "function"
+      ? options.formatExtensionChanges(extensions, extensionRemovals)
+      : extensionChanges.join("\n");
+    ui.note("Extension changes", formatted.split("\n"));
+  }
   if (existing?.projects?.length) {
     const permissionPlan = planPermissionChanges({
       root,