@fresh-editor/fresh-editor 0.3.0 → 0.3.1

package/plugins/devcontainer.ts

@@ -33,6 +33,7 @@ interface DevContainerConfig {
   appPort?: number | string | (number | string)[];
   containerEnv?: Record<string, string>;
   remoteEnv?: Record<string, string>;
+  userEnvProbe?: "none" | "loginShell" | "loginInteractiveShell" | "interactiveShell";
   containerUser?: string;
   remoteUser?: string;
   mounts?: (string | MountConfig)[];
@@ -87,6 +88,29 @@ let infoPanelSplitId: number | null = null;
 let infoPanelOpen = false;
 let cachedContent = "";
 
+/// Single shared panel slot for every devcontainer-owned panel
+/// (Show Info / Show Container Logs / Show Build Logs / Show
+/// Forwarded Ports / lifecycle command output / build-log
+/// streaming / failed-attach error). Without this, each `Show *`
+/// invocation used to call `createVirtualBufferInSplit` directly,
+/// which always creates a new horizontal split — so by the third
+/// invocation the right column was several stacked panes ~5 rows
+/// each, the layout became uninhabitable, and several downstream
+/// L-rows in the usability bug table collapsed into "the layout
+/// strategy is wrong."
+///
+/// Policy (matches the user's spec for fix #6 on retest):
+///   - If `panelSplitId` is set AND that split still exists in
+///     `editor.listSplits()`, REUSE it: focus + swap content.
+///   - Otherwise, use the currently focused split — *don't*
+///     spawn a new one. The first Show command therefore
+///     replaces whatever is in the focused split (the user's
+///     editor pane is gone if they didn't manually split first;
+///     this is the explicit tradeoff the user picked over the
+///     unbounded-stacking alternative).
+let panelSplitId: number | null = null;
+const panelBufferIds = new Set<number>();
+
 // The in-flight `devcontainer up` handle (set before we await, cleared
 // on exit). `devcontainer_cancel_attach` forwards `.kill()` to this.
 // null when no attach is running.
@@ -136,33 +160,47 @@ const colors = {
 // Config Discovery
 // =============================================================================
 
+/// Last parse failure observed by `findConfig` — surfaced via
+/// `setStatus` and an action popup at init / on file save so the
+/// user notices broken JSON instead of silently losing every
+/// `Dev Container:` command.
+let lastParseError: { path: string; message: string } | null = null;
+
+function tryParse(path: string, content: string): boolean {
+  try {
+    config = editor.parseJsonc(content) as DevContainerConfig;
+    configPath = path;
+    lastParseError = null;
+    return true;
+  } catch (e) {
+    const message = e instanceof Error ? e.message : String(e);
+    lastParseError = { path, message };
+    // Set `configPath` to the broken file so the recovery
+    // command set's `Open Config` can route the user there.
+    // `config` stays null so callers that depend on parsed
+    // fields (rebuild, attach) don't crash.
+    configPath = path;
+    editor.debug(`devcontainer: failed to parse ${path}: ${message}`);
+    return false;
+  }
+}
+
 function findConfig(): boolean {
   const cwd = editor.getCwd();
+  lastParseError = null;
 
   // Priority 1: .devcontainer/devcontainer.json
   const primary = editor.pathJoin(cwd, ".devcontainer", "devcontainer.json");
   const primaryContent = editor.readFile(primary);
   if (primaryContent !== null) {
-    try {
-      config = editor.parseJsonc(primaryContent) as DevContainerConfig;
-      configPath = primary;
-      return true;
-    } catch {
-      editor.debug("devcontainer: failed to parse " + primary);
-    }
+    if (tryParse(primary, primaryContent)) return true;
   }
 
   // Priority 2: .devcontainer.json
   const secondary = editor.pathJoin(cwd, ".devcontainer.json");
   const secondaryContent = editor.readFile(secondary);
   if (secondaryContent !== null) {
-    try {
-      config = editor.parseJsonc(secondaryContent) as DevContainerConfig;
-      configPath = secondary;
-      return true;
-    } catch {
-      editor.debug("devcontainer: failed to parse " + secondary);
-    }
+    if (tryParse(secondary, secondaryContent)) return true;
   }
 
   // Priority 3: .devcontainer/<subfolder>/devcontainer.json
@@ -174,13 +212,7 @@ function findConfig(): boolean {
         const subConfig = editor.pathJoin(dcDir, entry.name, "devcontainer.json");
         const subContent = editor.readFile(subConfig);
         if (subContent !== null) {
-          try {
-            config = editor.parseJsonc(subContent) as DevContainerConfig;
-            configPath = subConfig;
-            return true;
-          } catch {
-            editor.debug("devcontainer: failed to parse " + subConfig);
-          }
+          if (tryParse(subConfig, subContent)) return true;
         }
       }
     }
@@ -189,6 +221,21 @@ function findConfig(): boolean {
   return false;
 }
 
+/// Surface the last parse error (if any) to the user via the status
+/// bar. Idempotent — safe to call repeatedly. Bug #2 (silent JSON
+/// syntax errors): without this, a broken `devcontainer.json`
+/// causes `findConfig` to return false, no commands register,
+/// and the user has no clue why the feature stopped working.
+function showParseErrorIfAny(): void {
+  if (!lastParseError) return;
+  editor.setStatus(
+    editor.t("status.parse_failed", {
+      path: lastParseError.path,
+      message: lastParseError.message,
+    }),
+  );
+}
+
 // =============================================================================
 // Formatting Helpers
 // =============================================================================
@@ -581,27 +628,21 @@ async function devcontainer_show_info(): Promise<void> {
     return;
   }
 
-  if (infoPanelOpen && infoPanelBufferId !== null) {
-    // Already open - refresh content
-    updateInfoPanel();
-    return;
-  }
-
+  // Re-routed through the shared panel slot (Bug #6 retest):
+  // dropping the previous flag-based dedupe because it kept the
+  // info-panel buffer "open" in module state even when the user
+  // had already closed it with `q`, leaving the next invocation
+  // either refreshing a dead buffer or stacking a new split.
+  // The slot helper handles existence-checking against the live
+  // split list each call.
   infoFocus = { type: "button", index: 0 };
   const entries = buildInfoEntries();
   cachedContent = entriesToContent(entries);
 
-  const result = await editor.createVirtualBufferInSplit({
+  const result = await openVirtualInPanelSlot({
     name: "*Dev Container*",
     mode: "devcontainer-info",
-    readOnly: true,
-    showLineNumbers: false,
-    showCursors: true,
-    editingDisabled: true,
-    lineWrap: true,
-    ratio: 0.4,
-    direction: "horizontal",
-    entries: entries,
+    entries,
   });
 
   if (result !== null) {
@@ -677,57 +718,358 @@ function devcontainer_run_lifecycle(): void {
 }
 registerHandler("devcontainer_run_lifecycle", devcontainer_run_lifecycle);
 
-async function devcontainer_on_lifecycle_confirmed(data: {
-  prompt_type: string;
-  value: string;
-}): Promise<void> {
-  if (data.prompt_type !== "devcontainer-lifecycle") return;
 
-  const cmdName = data.value;
-  if (!config || !cmdName) return;
 
-  const cmd = (config as Record<string, unknown>)[cmdName] as LifecycleCommand | undefined;
-  if (!cmd) return;
+/// Critical bug from interactive walkthrough: lifecycle command
+/// stdout/stderr were captured in `result.stdout` / `result.stderr`
+/// and then discarded — the user only saw a status line like
+/// `postCreateCommand failed (exit 1)` with zero way to see the
+/// real error. Now we surface the full output via the shared
+/// panel slot.
+///
+/// Always render (even on success) so users can see what the
+/// command actually did. Status line keeps the at-a-glance
+/// summary; the panel carries the detail.
+async function surfaceLifecycleResult(
+  cmdName: string,
+  label: string | null,
+  cmdline: string,
+  result: { stdout: string; stderr: string; exit_code: number },
+): Promise<void> {
+  // Status line: the at-a-glance signal. Detail lands in the
+  // panel slot below.
+  if (result.exit_code === 0) {
+    editor.setStatus(editor.t("status.completed", { name: cmdName }));
+  } else if (label !== null) {
+    editor.setStatus(
+      editor.t("status.failed_sub", {
+        name: cmdName,
+        label,
+        code: String(result.exit_code),
+      }),
+    );
+  } else {
+    editor.setStatus(
+      editor.t("status.failed", {
+        name: cmdName,
+        code: String(result.exit_code),
+      }),
+    );
+  }
 
-  if (typeof cmd === "string") {
-    editor.setStatus(editor.t("status.running", { name: cmdName }));
-    const result = await editor.spawnProcess("sh", ["-c", cmd], editor.getCwd());
-    if (result.exit_code === 0) {
-      editor.setStatus(editor.t("status.completed", { name: cmdName }));
-    } else {
-      editor.setStatus(editor.t("status.failed", { name: cmdName, code: String(result.exit_code) }));
+  const headerLine = label !== null
+    ? `--- ${cmdName} (${label}) — exit ${result.exit_code} ---\n`
+    : `--- ${cmdName} — exit ${result.exit_code} ---\n`;
+  const cmdLineText = `$ ${cmdline}\n`;
+  const stdoutBlock = result.stdout.length > 0 ? result.stdout : "";
+  const stderrBlock = result.stderr.length > 0
+    ? (result.stdout.length > 0 ? "\n--- stderr ---\n" : "") + result.stderr
+    : "";
+  const body = stdoutBlock + stderrBlock;
+  const text = headerLine + cmdLineText
+    + (body.length > 0 ? body : "(no output)\n");
+
+  await openVirtualInPanelSlot({
+    name: "*Dev Container Lifecycle*",
+    mode: "devcontainer-info",
+    entries: [{ text, properties: { type: "log" } }],
+  });
+}
+
+/// Per-workspace storage for `remoteWorkspaceFolder` captured at
+/// attach time. The plugin module re-loads after `setAuthority`'s
+/// restart, losing in-memory state, so we persist via plugin
+/// global state. Read back via `lifecycleCwd()` when running
+/// lifecycle commands.
+function remoteWorkspaceKey(): string {
+  return "remote-workspace:" + editor.getCwd();
+}
+
+function writeRemoteWorkspace(value: string | null): void {
+  editor.setGlobalState(remoteWorkspaceKey(), value);
+}
+
+function readRemoteWorkspace(): string | null {
+  const raw = editor.getGlobalState(remoteWorkspaceKey()) as unknown;
+  return typeof raw === "string" && raw.length > 0 ? raw : null;
+}
+
+/// Pick the cwd to pass to lifecycle-command `spawnProcess` calls.
+/// When attached to a Container authority, returns the recorded
+/// `remoteWorkspaceFolder` so `docker exec -w` lands inside the
+/// container. Otherwise returns undefined so the runtime fills
+/// in the editor's host working_dir (the local-authority path).
+function lifecycleCwd(): string | undefined {
+  if (editor.getAuthorityLabel().startsWith("Container:")) {
+    return readRemoteWorkspace() ?? undefined;
+  }
+  return undefined;
+}
+
+/// Per-workspace cache of the `userEnvProbe` result. Spec says
+/// the tool runs the probe shell once at attach and applies the
+/// captured env to every subsequent remote process. We persist
+/// across the post-attach restart via plugin global state so the
+/// reloaded plugin instance reuses the same snapshot.
+function userEnvProbeKey(): string {
+  return "user-env-probe:" + editor.getCwd();
+}
+
+function readCachedProbedEnv(): Record<string, string> | null {
+  const raw = editor.getGlobalState(userEnvProbeKey()) as unknown;
+  if (raw && typeof raw === "object" && !Array.isArray(raw)) {
+    const out: Record<string, string> = {};
+    for (const [k, v] of Object.entries(raw as Record<string, unknown>)) {
+      if (typeof v === "string") out[k] = v;
     }
-  } else if (Array.isArray(cmd)) {
-    const [bin, ...args] = cmd;
-    editor.setStatus(editor.t("status.running", { name: cmdName }));
-    const result = await editor.spawnProcess(bin, args, editor.getCwd());
-    if (result.exit_code === 0) {
-      editor.setStatus(editor.t("status.completed", { name: cmdName }));
-    } else {
-      editor.setStatus(editor.t("status.failed", { name: cmdName, code: String(result.exit_code) }));
+    return out;
+  }
+  return null;
+}
+
+function writeCachedProbedEnv(env: Record<string, string>): void {
+  editor.setGlobalState(userEnvProbeKey(), env as unknown);
+}
+
+/// Run the `userEnvProbe` shell (per spec) and capture its env.
+/// Caches the result so subsequent calls are free. Returns `{}`
+/// when probe is unset / "none" / failed.
+async function getOrComputeProbedEnv(): Promise<Record<string, string>> {
+  const cached = readCachedProbedEnv();
+  if (cached !== null) return cached;
+
+  const probe = config?.userEnvProbe;
+  if (!probe || probe === "none") {
+    writeCachedProbedEnv({});
+    return {};
+  }
+
+  // Map enum → bash flags. `loginShell` = `bash -lc`,
+  // `interactiveShell` = `bash -ic`, etc. The probe runs `env`
+  // and we parse stdout into KEY=VALUE pairs.
+  const flagMap: Record<string, string[]> = {
+    loginShell: ["-l"],
+    loginInteractiveShell: ["-l", "-i"],
+    interactiveShell: ["-i"],
+  };
+  const flags = flagMap[probe] ?? [];
+  const cwd = lifecycleCwd() ?? "";
+  // The probe shell needs `remoteEnv` applied too so users can put
+  // BASH_ENV / ENV / NODE_OPTIONS / etc. there and have the probe
+  // pick them up. Without this, bash's non-interactive-login
+  // semantics (`BASH_ENV` sourcing) wouldn't see the user's
+  // configured rc file.
+  const baseEnv: Record<string, string> = config?.remoteEnv ?? {};
+  const [bin, probeArgs] = wrapWithEnv(baseEnv, "bash", [...flags, "-c", "env"]);
+  const result = await editor.spawnProcess(bin, probeArgs, cwd);
+  if (result.exit_code !== 0) {
+    editor.debug(
+      `devcontainer: userEnvProbe (${probe}) failed: ${result.stderr.trim()}`,
+    );
+    writeCachedProbedEnv({});
+    return {};
+  }
+  const env: Record<string, string> = {};
+  for (const line of result.stdout.split("\n")) {
+    const eq = line.indexOf("=");
+    if (eq > 0) {
+      env[line.slice(0, eq)] = line.slice(eq + 1);
     }
-  } else {
-    // Object form: run each named sub-command sequentially
-    for (const [label, subcmd] of Object.entries(cmd)) {
-      editor.setStatus(editor.t("status.running_sub", { name: cmdName, label }));
-      let bin: string;
-      let args: string[];
+  }
+  writeCachedProbedEnv(env);
+  return env;
+}
+
+/// Build the merged env passed to lifecycle commands per spec:
+///   userEnvProbe-captured ∪ remoteEnv (remoteEnv overrides probe).
+/// Skipped when not attached to a Container — remoteEnv is a
+/// container-side concept, the local case relies on whatever env
+/// the editor itself has.
+async function effectiveLifecycleEnv(): Promise<Record<string, string>> {
+  if (!editor.getAuthorityLabel().startsWith("Container:")) return {};
+  const probed = await getOrComputeProbedEnv();
+  const out: Record<string, string> = { ...probed };
+  if (config?.remoteEnv) {
+    for (const [k, v] of Object.entries(config.remoteEnv)) {
+      out[k] = v;
+    }
+  }
+  return out;
+}
+
+/// Probe the just-launched container's user-shell env so the docker
+/// authority's spawner can apply it to every `docker exec` (including
+/// the LSP `command_exists` probe and the LSP server spawn itself).
+///
+/// Why pre-restart, not post-restart: `setAuthority` rebuilds the
+/// editor in place; the next plugin instance can't influence the
+/// already-installed authority's spawner without a second restart.
+/// We have one shot, here, while we still hold the host-side spawner
+/// and know which container we're talking to.
+///
+/// Why bash login-interactive: per the dev-container spec, the
+/// default `userEnvProbe` is `loginInteractiveShell`. `bash -lic env`
+/// matches what an attached terminal would see — including PATH
+/// additions from `~/.profile`, `~/.bashrc`, and friends. Custom
+/// `userEnvProbe` settings (`loginShell`, `interactiveShell`, `none`)
+/// are honoured.
+///
+/// Failures (no bash, probe times out, exit non-zero) degrade
+/// gracefully: we return `[]` and the user gets the bare
+/// container-default PATH back — same behaviour as before this fix,
+/// no regression.
+async function captureContainerLoginEnv(
+  result: DevcontainerUpResult,
+): Promise<Array<[string, string]>> {
+  if (!result.containerId) return [];
+  const probe = config?.userEnvProbe ?? "loginInteractiveShell";
+  if (probe === "none") return [];
+
+  const flagMap: Record<string, string[]> = {
+    loginShell: ["-l"],
+    loginInteractiveShell: ["-l", "-i"],
+    interactiveShell: ["-i"],
+  };
+  const flags = flagMap[probe];
+  if (!flags) return [];
+
+  // Compose `docker exec -i [-u USER] [-w WORKSPACE] <id> bash ...`
+  // by hand: at this point the authority hasn't been installed yet,
+  // so `editor.spawnProcess` would route to the host. Use
+  // `spawnHostProcess` and address the container directly via the
+  // host docker CLI.
+  const dockerArgs: string[] = ["exec", "-i"];
+  if (result.remoteUser) {
+    dockerArgs.push("-u", result.remoteUser);
+  }
+  if (result.remoteWorkspaceFolder) {
+    dockerArgs.push("-w", result.remoteWorkspaceFolder);
+  }
+  dockerArgs.push(result.containerId, "bash", ...flags, "-c", "env");
+
+  const probeResult = await editor.spawnHostProcess("docker", dockerArgs);
+  if (probeResult.exit_code !== 0) {
+    editor.debug(
+      `devcontainer: container userEnvProbe (${probe}) failed exit=${probeResult.exit_code}: ${probeResult.stderr.trim()}`,
+    );
+    return [];
+  }
+
+  // Filter to a small allowlist of high-value entries. Forwarding the
+  // entire `env` dump risks shadowing useful container defaults
+  // (`HOSTNAME`, `_`, …) and balloons the `docker exec` arg list.
+  // `PATH` is the one that drives the LSP fix; the others are common
+  // setup the user's shell exports and a non-shell exec wouldn't.
+  const wanted = new Set(["PATH", "HOME", "LANG", "LC_ALL", "SHELL", "USER", "LOGNAME"]);
+  const out: Array<[string, string]> = [];
+  for (const line of probeResult.stdout.split("\n")) {
+    const eq = line.indexOf("=");
+    if (eq <= 0) continue;
+    const key = line.slice(0, eq);
+    if (!wanted.has(key)) continue;
+    out.push([key, line.slice(eq + 1)]);
+  }
+  return out;
+}
+
+/// Wrap `[bin, args]` with an `env K1=V1 K2=V2 bin args...`
+/// invocation when `env` is non-empty. Returns the original pair
+/// when env is empty (no wrapper needed).
+///
+/// Note: GNU `env` doesn't recognize `--` as an options
+/// terminator (it dies with `env: '--': No such file or directory`).
+/// `env` parses K=V pairs greedily until it hits a non-K=V word,
+/// which it treats as the command. As long as `bin` doesn't
+/// contain `=`, this is unambiguous.
+function wrapWithEnv(
+  env: Record<string, string>,
+  bin: string,
+  args: string[],
+): [string, string[]] {
+  const keys = Object.keys(env);
+  if (keys.length === 0) return [bin, args];
+  const envArgs = keys.map((k) => `${k}=${env[k]}`);
+  return ["env", [...envArgs, bin, ...args]];
+}
+
+/// Spec: object-form lifecycle commands run their entries in
+/// parallel; the stage waits for all to complete; the stage
+/// succeeds iff every entry exited 0. Implementation:
+/// `Promise.all` over an array of per-entry promises, each
+/// reporting its exit code. We aggregate failures into a single
+/// status message at the end.
+async function runLifecycleObjectForm(
+  cmdName: string,
+  cmd: Record<string, string | string[]>,
+): Promise<void> {
+  const entries = Object.entries(cmd);
+  if (entries.length === 0) {
+    editor.setStatus(editor.t("status.completed", { name: cmdName }));
+    return;
+  }
+  editor.setStatus(editor.t("status.running", { name: cmdName }));
+
+  const cwd = lifecycleCwd() ?? "";
+  const env = await effectiveLifecycleEnv();
+  const results = await Promise.all(
+    entries.map(async ([label, subcmd]) => {
+      let origBin: string;
+      let origArgs: string[];
+      let cmdline: string;
       if (Array.isArray(subcmd)) {
-        [bin, ...args] = subcmd;
+        [origBin, ...origArgs] = subcmd;
+        cmdline = [origBin, ...origArgs].join(" ");
       } else {
-        bin = "sh";
-        args = ["-c", subcmd as string];
-      }
-      const result = await editor.spawnProcess(bin, args, editor.getCwd());
-      if (result.exit_code !== 0) {
-        editor.setStatus(editor.t("status.failed_sub", { name: cmdName, label, code: String(result.exit_code) }));
-        return;
+        origBin = "sh";
+        origArgs = ["-c", subcmd as string];
+        cmdline = subcmd as string;
       }
-    }
+      const [bin, args] = wrapWithEnv(env, origBin, origArgs);
+      const r = await editor.spawnProcess(bin, args, cwd);
+      return { label, cmdline, result: r };
+    }),
+  );
+
+  // Render every entry's output into the panel slot in one
+  // batched message — N separate calls would flicker the panel
+  // across N intermediate states. Failed entries first so the
+  // user sees the failures even if stdout is enormous.
+  const sorted = [...results].sort(
+    (a, b) => Number(a.result.exit_code === 0) - Number(b.result.exit_code === 0),
+  );
+  const sections = sorted.map(({ label, cmdline, result: r }) => {
+    const header = `--- ${cmdName} (${label}) — exit ${r.exit_code} ---\n`;
+    const cmdLine = `$ ${cmdline}\n`;
+    const stdoutBlock = r.stdout.length > 0 ? r.stdout : "";
+    const stderrBlock = r.stderr.length > 0
+      ? (r.stdout.length > 0 ? "\n--- stderr ---\n" : "") + r.stderr
+      : "";
+    const body = stdoutBlock + stderrBlock;
+    return header + cmdLine + (body.length > 0 ? body : "(no output)\n");
+  });
+  await openVirtualInPanelSlot({
+    name: "*Dev Container Lifecycle*",
+    mode: "devcontainer-info",
+    entries: [{ text: sections.join("\n"), properties: { type: "log" } }],
+  });
+
+  const failed = results.filter((r) => r.result.exit_code !== 0);
+  if (failed.length === 0) {
     editor.setStatus(editor.t("status.completed", { name: cmdName }));
+    return;
   }
+  // Surface the first failure in the status message — same key
+  // the old sequential path used so existing translations keep
+  // working.
+  const first = failed[0];
+  editor.setStatus(
+    editor.t("status.failed_sub", {
+      name: cmdName,
+      label: first.label,
+      code: String(first.result.exit_code),
+    }),
+  );
 }
-registerHandler("devcontainer_on_lifecycle_confirmed", devcontainer_on_lifecycle_confirmed);
 
 function devcontainer_show_features(): void {
   if (!config || !config.features || Object.keys(config.features).length === 0) {
@@ -1044,23 +1386,15 @@ async function devcontainer_show_forwarded_ports_panel(): Promise<void> {
     return;
   }
 
-  if (portsPanelOpen && portsPanelBufferId !== null) {
-    await renderPortsPanel();
-    return;
-  }
-
+  // Bug #6 retest: route through the shared panel slot rather
+  // than `createVirtualBufferInSplit` (which always splits) and
+  // drop the flag-based dedupe (which left state stale when the
+  // user closed the panel manually with `q`).
   const rows = await gatherForwardedPortRows();
   const entries = buildPortsPanelEntries(rows);
-  const result = await editor.createVirtualBufferInSplit({
+  const result = await openVirtualInPanelSlot({
     name: "*Dev Container Ports*",
     mode: "devcontainer-ports",
-    readOnly: true,
-    showLineNumbers: false,
-    showCursors: true,
-    editingDisabled: true,
-    lineWrap: true,
-    ratio: 0.35,
-    direction: "horizontal",
     entries,
   });
   if (result !== null) {
@@ -1133,28 +1467,7 @@ function showCliNotFoundPopup(): void {
   });
 }
 
-function devcontainer_on_action_result(data: ActionPopupResultData): void {
-  if (data.popup_id === "devcontainer-cli-help") {
-    switch (data.action_id) {
-      case "copy_install":
-        editor.setClipboard(INSTALL_COMMAND);
-        editor.setStatus(editor.t("status.copied_install", { cmd: INSTALL_COMMAND }));
-        break;
-      case "dismiss":
-      case "dismissed":
-        break;
-    }
-    return;
-  }
-  if (data.popup_id === "devcontainer-attach") {
-    devcontainer_on_attach_popup(data);
-    return;
-  }
-  if (data.popup_id === "devcontainer-failed-attach") {
-    devcontainer_on_failed_attach_popup(data);
-  }
-}
-registerHandler("devcontainer_on_action_result", devcontainer_on_action_result);
+
 
 /// Surface a proactive action popup after a failed attach so users
 /// don't have to notice the Remote Indicator's red state on their own.
@@ -1266,6 +1579,8 @@ function parseDevcontainerUpOutput(stdout: string): DevcontainerUpResult | null
 
 function buildContainerAuthorityPayload(
   result: DevcontainerUpResult,
+  baseEnv: Array<[string, string]>,
+  hostWorkspace: string | null,
 ): AuthorityPayload | null {
   if (!result.containerId) return null;
   const user = result.remoteUser ?? null;
@@ -1282,6 +1597,20 @@ function buildContainerAuthorityPayload(
 
   const shortId = result.containerId.slice(0, 12);
 
+  // Plumb the host↔container workspace mapping through to the
+  // authority. Without this, every LSP URI carrying a workspace path
+  // is mis-translated at the host/container boundary: didOpen sends
+  // host paths to the in-container LSP, and Goto-Definition responses
+  // come back with container paths the editor opens verbatim on the
+  // host. Both roots must be present and absolute for the mapping to
+  // be useful — when either is missing we leave path_translation
+  // unset and accept the (broken) status quo rather than installing a
+  // half-mapping that translates one direction.
+  const path_translation =
+    hostWorkspace && workspace
+      ? { host_root: hostWorkspace, remote_root: workspace }
+      : undefined;
+
   return {
     filesystem: { kind: "local" },
     spawner: {
@@ -1289,6 +1618,7 @@ function buildContainerAuthorityPayload(
       container_id: result.containerId,
       user,
       workspace,
+      env: baseEnv,
     },
     terminal_wrapper: {
       kind: "explicit",
@@ -1297,6 +1627,7 @@ function buildContainerAuthorityPayload(
       manages_cwd: true,
     },
     display_label: "Container:" + shortId,
+    path_translation,
   };
 }
 
@@ -1425,6 +1756,11 @@ async function runDevcontainerUp(extraArgs: string[]): Promise<void> {
     return;
   }
   rememberLastBuildLogPath(logPath);
+  // Drop any session-restored build logs from previous runs before
+  // opening the fresh one. Without this, `Show Build Logs` after a
+  // cold restart would race the freshly-minted timestamp file against
+  // a stale one in another split, with no visual cue which is which.
+  closeStaleBuildLogBuffers(cwd);
   // Open the log in a split below so the user sees lines stream in
   // (auto-revert polls every 2s) without losing the buffer they were
   // editing. `split_horizontal` duplicates the current buffer into a
@@ -1483,7 +1819,22 @@ async function runDevcontainerUp(extraArgs: string[]): Promise<void> {
     return;
   }
 
-  const payload = buildContainerAuthorityPayload(parsed);
+  // Capture the in-container `userEnvProbe` env BEFORE we hand the
+  // payload to setAuthority. setAuthority restarts the editor; once
+  // the new editor's spawner is wired with the captured PATH, LSP
+  // `command_exists` and `spawn_stdio` see the same binaries the
+  // user's interactive shell sees (e.g. `pylsp` installed by a
+  // `postCreateCommand` into `~/.local/bin`). Per spec, when
+  // `userEnvProbe` is unset the default is `loginInteractiveShell`.
+  const baseEnv = await captureContainerLoginEnv(parsed);
+
+  // Capture the host workspace path so the authority can translate
+  // LSP URIs at the host↔container boundary. `editor.getCwd()` is
+  // the production host workspace today; we read it just before
+  // setAuthority so the value matches the editor that's about to be
+  // rebuilt.
+  const hostWorkspace = editor.getCwd();
+  const payload = buildContainerAuthorityPayload(parsed, baseEnv, hostWorkspace);
   if (!payload) {
     enterFailedAttach(editor.t("status.rebuild_missing_container_id"));
     return;
@@ -1498,6 +1849,13 @@ async function runDevcontainerUp(extraArgs: string[]): Promise<void> {
   // decide between success (container authority live) and silent
   // failure (no authority landed — surfaces as FailedAttach).
   writeAttachAttempt();
+  // Persist `remoteWorkspaceFolder` so the post-restart plugin
+  // instance can pass it as the cwd to lifecycle commands. The
+  // runtime's `spawnProcess` auto-fills working_dir (host path)
+  // when cwd is omitted — that breaks `docker exec -w` for
+  // configs whose `workspaceFolder` differs from the host
+  // workspace path. See `lifecycleCwd()`.
+  writeRemoteWorkspace(parsed.remoteWorkspaceFolder ?? null);
   editor.setAuthority(payload);
 }
 
@@ -1552,19 +1910,138 @@ function lastBuildLogKey(): string {
 /// rebuilds the editor and workspace restore brings the log buffer
 /// back, the first `Show Build Logs` finds the restored split and
 /// focuses it instead of stacking a new one on top.
+/// Resolve the split id to drop a panel into. If we have a
+/// previously-claimed panel split that's still alive, reuse it.
+/// Otherwise grab the currently focused split — never spawn a
+/// new one. Returns the chosen split id.
+function resolvePanelSplit(): number {
+  if (panelSplitId !== null) {
+    const stillAlive = editor.listSplits().some((s) => s.splitId === panelSplitId);
+    if (stillAlive) return panelSplitId;
+    panelSplitId = null;
+  }
+  const active = editor.getActiveSplitId();
+  panelSplitId = active;
+  return active;
+}
+
+/// Per-name registry of panel buffers. Keyed by the
+/// `*Dev Container*` / `*Dev Container Logs*` etc. names so
+/// re-running a Show command refreshes its own buffer in place
+/// without destroying the other Show commands' buffers. Lives
+/// in module state — resets on plugin reload, which is fine
+/// since buffer ids change across editor restarts anyway and
+/// the next Show * invocation will (re)create as needed.
+const namedPanelBuffers = new Map<string, number>();
+
+/// Drop a virtual buffer into the shared panel slot.
+///
+/// Per-name dedupe: re-running the same Show command refreshes
+/// the existing same-name buffer in place (`setVirtualBufferContent`)
+/// rather than creating a new one. Different Show commands keep
+/// their own buffers — `Show Container Logs` no longer wipes out
+/// `Show Container Info`'s buffer, so the user can switch back to
+/// it via the tab bar / buffer list.
+///
+/// Returns the new buffer id, or null if the runtime call failed.
+async function openVirtualInPanelSlot(opts: {
+  name: string;
+  mode: string;
+  entries: TextPropertyEntry[];
+  readOnly?: boolean;
+  showLineNumbers?: boolean;
+  showCursors?: boolean;
+  editingDisabled?: boolean;
+  lineWrap?: boolean;
+}): Promise<{ bufferId: number; splitId: number } | null> {
+  const splitId = resolvePanelSplit();
+  const liveBuffers = editor.listBuffers();
+
+  // If we already have a same-name buffer (and it's still alive),
+  // refresh its contents and surface it in the panel split rather
+  // than minting a duplicate. This is the per-command-buffer fix:
+  // running `Show Container Logs` twice updates one buffer instead
+  // of stacking two; running it then `Show Container Info` keeps
+  // both alive.
+  const existingId = namedPanelBuffers.get(opts.name);
+  if (existingId !== undefined) {
+    const existing = liveBuffers.find((b) => b.id === existingId);
+    if (existing) {
+      editor.setVirtualBufferContent(
+        existing.id,
+        opts.entries as unknown as Record<string, unknown>[],
+      );
+      editor.focusSplit(splitId);
+      editor.showBuffer(existing.id);
+      panelBufferIds.add(existing.id);
+      return { bufferId: existing.id, splitId };
+    }
+    namedPanelBuffers.delete(opts.name);
+  }
+
+  const result = await editor.createVirtualBufferInExistingSplit({
+    name: opts.name,
+    splitId,
+    mode: opts.mode,
+    readOnly: opts.readOnly ?? true,
+    showLineNumbers: opts.showLineNumbers ?? false,
+    showCursors: opts.showCursors ?? true,
+    editingDisabled: opts.editingDisabled ?? true,
+    lineWrap: opts.lineWrap ?? false,
+    entries: opts.entries,
+  });
+  if (result === null) return null;
+  panelBufferIds.add(result.bufferId);
+  namedPanelBuffers.set(opts.name, result.bufferId);
+  return { bufferId: result.bufferId, splitId };
+}
+
+/// File-backed equivalent for build-log files: focuses the
+/// panel-slot split and opens the file there. `openFile` is
+/// idempotent by path, so re-running `Show Build Logs` for the
+/// same file just brings the existing buffer to the front; we
+/// don't need our own dedupe layer.
+///
+/// We also turn line-wrap off — build logs are wide structured
+/// output (docker buildx, lifecycle stdout) that's much more
+/// readable scrolled horizontally than soft-wrapped at column 80.
+function openFileInPanelSlot(path: string): void {
+  const splitId = resolvePanelSplit();
+  editor.focusSplit(splitId);
+  editor.openFile(path, null, null);
+  // After the file is open, find its buffer id and disable
+  // line wrap. The new-buffer case sets this on first open;
+  // subsequent invocations are no-ops.
+  const opened = editor.listBuffers().find((b) => b.path === path);
+  if (opened) {
+    editor.setLineWrap(opened.id, null, false);
+    panelBufferIds.add(opened.id);
+  }
+}
+
 function openBuildLogInSplit(path: string): void {
+  openFileInPanelSlot(path);
+}
+
+/// Close every open build-log buffer for this workspace before the new
+/// attach mints its own log. Without this, a session-restored buffer
+/// (whose contents are stale from the previous run) sits next to the
+/// fresh streaming log and the user has to guess which one is live.
+///
+/// Pure heuristic: any buffer whose path lives under
+/// `<cwd>/.fresh-cache/devcontainer-logs/` is a build log. The
+/// directory is plugin-owned (see `prepareBuildLogFile`), so the
+/// false-positive surface is empty unless a user puts arbitrary files
+/// there themselves — at which point closing them on attach is also
+/// the right call.
+function closeStaleBuildLogBuffers(cwd: string): void {
+  const prefix = editor.pathJoin(cwd, ".fresh-cache", "devcontainer-logs");
   const buffers = editor.listBuffers();
-  const existing = buffers.find((b) => b.path === path);
-  if (existing && existing.splits.length > 0) {
-    editor.focusSplit(existing.splits[0]);
-    return;
+  for (const b of buffers) {
+    if (b.path && b.path.startsWith(prefix)) {
+      editor.closeBuffer(b.id);
+    }
   }
-  // Not visible anywhere → create a new split and open the log
-  // there. openFile reuses the buffer when the path is already
-  // loaded (e.g. open but not in any split), so no duplicate
-  // buffers either way.
-  editor.executeAction("split_horizontal");
-  editor.openFile(path, null, null);
 }
 
 function rememberLastBuildLogPath(path: string): void {
@@ -1620,10 +2097,48 @@ async function devcontainer_retry_attach(): Promise<void> {
 registerHandler("devcontainer_retry_attach", devcontainer_retry_attach);
 
 async function devcontainer_detach(): Promise<void> {
+  // Honor `shutdownAction` per spec: default for image/Dockerfile
+  // is `stopContainer`. Stop the container BEFORE clearing
+  // authority — clearing the authority drops our spawner, so we'd
+  // lose the easy way to issue `docker stop` against the right
+  // daemon. Use `spawnHostProcess` because the container is about
+  // to disappear; routing through the soon-to-be-cleared container
+  // authority makes no sense.
+  await stopContainerIfShutdownActionRequires();
   editor.clearAuthority();
 }
 registerHandler("devcontainer_detach", devcontainer_detach);
 
+/// If `shutdownAction` says to stop the container (default for
+/// image/Dockerfile), spawn `docker stop <id>` on the host.
+/// No-op for `none` / `stopCompose` (compose has its own
+/// teardown the plugin doesn't drive). Failures are logged but
+/// don't block the detach itself — the user's intent is to stop
+/// using the container, and forcing them to keep it because
+/// `docker stop` errored would be worse than leaving an orphan.
+async function stopContainerIfShutdownActionRequires(): Promise<void> {
+  const action = config?.shutdownAction ?? "stopContainer";
+  if (action !== "stopContainer") return;
+
+  const label = editor.getAuthorityLabel();
+  const prefix = "Container:";
+  if (!label.startsWith(prefix)) return;
+  const containerId = label.slice(prefix.length);
+  if (containerId.length === 0) return;
+
+  const which = await editor.spawnHostProcess("which", ["docker"]);
+  if (which.exit_code !== 0) {
+    editor.debug(`devcontainer: docker not on PATH; skipping shutdownAction=stopContainer`);
+    return;
+  }
+  const result = await editor.spawnHostProcess("docker", ["stop", containerId]);
+  if (result.exit_code !== 0) {
+    editor.debug(
+      `devcontainer: docker stop ${containerId} exited ${result.exit_code}: ${result.stderr.trim()}`,
+    );
+  }
+}
+
 /// Abort an in-flight attach by killing the `devcontainer up` host
 /// spawn. No-op when nothing is in flight. The indicator is flipped
 /// back to Local immediately — cancel is a user-initiated revert,
@@ -1718,16 +2233,11 @@ async function devcontainer_show_logs(): Promise<void> {
     ? mergedParts.join("\n")
     : editor.t("status.logs_empty");
 
-  const result = await editor.createVirtualBufferInSplit({
+  // Bug #6 retest: was always splitting on every invocation
+  // (no dedupe at all). Route through the shared panel slot.
+  const result = await openVirtualInPanelSlot({
     name: "*Dev Container Logs*",
     mode: "devcontainer-info",
-    readOnly: true,
-    showLineNumbers: false,
-    showCursors: true,
-    editingDisabled: true,
-    lineWrap: true,
-    ratio: 0.4,
-    direction: "horizontal",
     entries: [{ text: merged, properties: { type: "log" } }],
   });
   if (result !== null) {
@@ -1822,6 +2332,14 @@ function writeAttachDecision(value: AttachDecision): void {
   editor.setGlobalState(attachDecisionKey(), value);
 }
 
+/// In-memory "Ignore (once)" — true after the user picks the
+/// session-only Ignore option in the attach popup. Cleared on
+/// plugin reload, which means the next editor restart asks again.
+/// This is deliberately separate from the persisted "Ignore (always)"
+/// decision (`writeAttachDecision("dismissed")`) so users have a
+/// real choice between "not now" and "stop asking forever".
+let attachDismissedThisSession = false;
+
 /// Breadcrumb written before calling `editor.setAuthority(payload)`
 /// — setAuthority restarts the editor, so there's no clean callback
 /// to hook once the new authority is live. If the post-restart plugin
@@ -1864,7 +2382,8 @@ function showAttachPrompt(): void {
     }),
     actions: [
       { id: "attach", label: editor.t("popup.attach_action_attach") },
-      { id: "dismiss", label: editor.t("popup.attach_action_dismiss") },
+      { id: "dismiss_once", label: editor.t("popup.attach_action_dismiss_once") },
+      { id: "dismiss_always", label: editor.t("popup.attach_action_dismiss_always") },
     ],
   });
 }
@@ -1876,8 +2395,16 @@ function devcontainer_on_attach_popup(data: ActionPopupResultData): void {
     // Fire and forget: runDevcontainerUp's setAuthority call restarts
     // the editor, so nothing after this runs anyway.
     void devcontainer_attach();
-  } else {
+  } else if (data.action_id === "dismiss_always") {
+    // Persistent ignore: write to plugin global state so the next
+    // editor restart in this workspace finds the breadcrumb and
+    // skips the popup entirely.
     writeAttachDecision("dismissed");
+  } else {
+    // `dismiss_once` (or the legacy `dismiss` id from older
+    // popups whose state is replayed mid-session): in-memory flag
+    // only. The next editor restart in this workspace re-asks.
+    attachDismissedThisSession = true;
   }
 }
 registerHandler("devcontainer_on_attach_popup", devcontainer_on_attach_popup);
@@ -1886,14 +2413,192 @@ registerHandler("devcontainer_on_attach_popup", devcontainer_on_attach_popup);
 // Event Handlers
 // =============================================================================
 
-editor.on("prompt_confirmed", "devcontainer_on_lifecycle_confirmed");
-editor.on("action_popup_result", "devcontainer_on_action_result");
+editor.on("prompt_confirmed", async (data) => {
+  if (data.prompt_type !== "devcontainer-lifecycle") return;
+
+  const cmdName = data.input;
+  if (!config || !cmdName) return;
+
+  const cmd = (config as Record<string, unknown>)[cmdName] as LifecycleCommand | undefined;
+  if (!cmd) return;
+
+  // cwd: when attached to a Container, pass the in-container
+  // `remoteWorkspaceFolder` so `docker exec -w` lands inside
+  // the container. When local, pass "" — the runtime treats
+  // empty-string cwd the same as omitted (both fall back to
+  // working_dir). Avoids passing literal `undefined` through
+  // the QuickJS bridge, which the marshaller rejects with
+  // "Error converting from js 'undefined' into type 'string'".
+  const cwd = lifecycleCwd() ?? "";
+  const env = await effectiveLifecycleEnv();
+  if (typeof cmd === "string") {
+    editor.setStatus(editor.t("status.running", { name: cmdName }));
+    const [bin, args] = wrapWithEnv(env, "sh", ["-c", cmd]);
+    const result = await editor.spawnProcess(bin, args, cwd);
+    await surfaceLifecycleResult(cmdName, null, cmd, result);
+  } else if (Array.isArray(cmd)) {
+    const [origBin, ...origArgs] = cmd;
+    const [bin, args] = wrapWithEnv(env, origBin, origArgs);
+    editor.setStatus(editor.t("status.running", { name: cmdName }));
+    const result = await editor.spawnProcess(bin, args, cwd);
+    await surfaceLifecycleResult(cmdName, null, [origBin, ...origArgs].join(" "), result);
+  } else {
+    // Object form: see the rewritten parallel branch in
+    // `runLifecycleObjectForm`.
+    await runLifecycleObjectForm(cmdName, cmd);
+  }
+});
+editor.on("action_popup_result", (data) => {
+  if (data.popup_id === "devcontainer-cli-help") {
+    switch (data.action_id) {
+      case "copy_install":
+        editor.setClipboard(INSTALL_COMMAND);
+        editor.setStatus(editor.t("status.copied_install", { cmd: INSTALL_COMMAND }));
+        break;
+      case "dismiss":
+      case "dismissed":
+        break;
+    }
+    return;
+  }
+  if (data.popup_id === "devcontainer-attach") {
+    devcontainer_on_attach_popup(data);
+    return;
+  }
+  if (data.popup_id === "devcontainer-failed-attach") {
+    devcontainer_on_failed_attach_popup(data);
+  }
+});
+editor.on("authority_changed", (data) => {
+  registerCommands();
+  const label = (data as { label?: string } | undefined)?.label ?? "";
+  if (label.startsWith("Container:")) {
+    void runAutoForwardSweep();
+  } else {
+    notifiedPorts.clear();
+  }
+});
+
+/// Re-register state-gated commands when the authority transitions
+/// (local ↔ container). Without this, after `setAuthority` lands a
+/// container we'd still have `Attach` / `Cancel Startup` in the
+/// palette and `Detach` / `Show Logs` missing.
+///
+/// Also runs the auto-forward port-detection sweep when entering
+/// container mode — Bug #4 (L171). Detecting an entry from
+/// `forwardPorts` that's actually bound (host-side) and emitting
+/// the spec'd `onAutoForward: notify` toast.
+
+
+/// Set of `port/protocol` keys we've already fired the
+/// `onAutoForward: notify` toast for in the current attach
+/// session. Cleared on detach so a re-attach re-notifies.
+const notifiedPorts = new Set<string>();
+
+/// Bug #4 (L171): emit the spec'd `onAutoForward: notify` toast
+/// for ports that are both declared in `forwardPorts` AND
+/// actually bound on the host (visible in `docker port <id>`).
+///
+/// Scoped fix: only the notification half of the spec. Actually
+/// publishing ports that aren't already mapped is a separate
+/// effort — it requires either a host-side userspace forwarder
+/// (the VS Code approach) or `appPort`/runArgs glue when starting
+/// the container, both of which are larger than this commit.
+async function runAutoForwardSweep(): Promise<void> {
+  if (!config?.forwardPorts || config.forwardPorts.length === 0) return;
+  const rows = await gatherForwardedPortRows();
+  for (const row of rows) {
+    if (row.source !== "configured") continue;
+    if (!row.binding) continue;
+    const attrs = config.portsAttributes?.[row.port];
+    if (attrs?.onAutoForward !== "notify") continue;
+    const key = `${row.port}/${row.protocol.toLowerCase()}`;
+    if (notifiedPorts.has(key)) continue;
+    notifiedPorts.add(key);
+    const labelSuffix = attrs.label ? ` (${attrs.label})` : "";
+    editor.setStatus(
+      editor.t("status.port_forwarded", {
+        port: row.port,
+        label: labelSuffix,
+      }),
+    );
+  }
+}
 
 // =============================================================================
 // Command Registration
 // =============================================================================
 
+/// State-gated commands that get re-evaluated on every authority
+/// transition. Listed in one place so `registerCommands` and the
+/// `authority_changed` cleanup path stay in sync.
+///
+/// `show_forwarded_ports_panel` stays available in BOTH modes —
+/// the panel renders configured `forwardPorts` even when no
+/// container is up, which is useful for previewing a config
+/// (and one of the tests exercises that exact "configured only"
+/// branch).
+const ATTACHED_ONLY_COMMANDS = ["%cmd.detach", "%cmd.show_logs"];
+const DETACHED_ONLY_COMMANDS = ["%cmd.attach", "%cmd.cancel_attach"];
+
+/// Bug #3 (L170): when `devcontainer.json` exists but fails to
+/// parse, register *only* a tiny recovery set so the user has an
+/// in-editor path to fix the JSON. Without this, the plugin's
+/// init path used to register zero commands and the user lost
+/// the entire `Dev Container:` family until restarting the
+/// editor.
+function registerRecoveryCommands(): void {
+  // Drop full-mode entries in case we're transitioning from a
+  // working config to a broken one (rebuild → restart → reparse
+  // fails). `unregisterCommand` is a no-op when the name isn't
+  // registered.
+  for (const name of ATTACHED_ONLY_COMMANDS) editor.unregisterCommand(name);
+  for (const name of DETACHED_ONLY_COMMANDS) editor.unregisterCommand(name);
+  for (const name of [
+    "%cmd.show_info",
+    "%cmd.show_features",
+    "%cmd.show_ports",
+    "%cmd.rebuild",
+    "%cmd.run_lifecycle",
+  ]) {
+    editor.unregisterCommand(name);
+  }
+  // `Open Config` is the recovery escape hatch — we set
+  // `configPath` even on parse failure so this opens the broken
+  // file in the editor for the user to repair.
+  editor.registerCommand(
+    "%cmd.open_config",
+    "%cmd.open_config_desc",
+    "devcontainer_open_config",
+    null,
+  );
+  // `Show Build Logs` stays available so the user can read the
+  // last rebuild output (likely shows the validation error from
+  // the CLI / docker layer too).
+  editor.registerCommand(
+    "%cmd.show_build_logs",
+    "%cmd.show_build_logs_desc",
+    "devcontainer_show_build_logs",
+    null,
+  );
+}
+
 function registerCommands(): void {
+  // Commands that are state-relevant in BOTH local and container
+  // modes (`Show Info`, `Open Config`, etc.) get registered
+  // unconditionally. Commands that are only meaningful in one
+  // mode are gated below — `attach` / `cancel_attach` only when
+  // not already attached, `detach` / `show_forwarded_ports_panel` /
+  // `show_logs` only when attached. The plugin reloads after
+  // `setAuthority` AND we listen for `authority_changed` so this
+  // function runs on every transition.
+  const attached = editor.getAuthorityLabel().startsWith("Container:");
+  // Drop any stale state-gated registrations from the previous
+  // mode before re-registering. `editor.unregisterCommand` is a
+  // no-op when the name isn't registered, so this is safe to call
+  // even on first init.
+  for (const name of ATTACHED_ONLY_COMMANDS) editor.unregisterCommand(name);
+  for (const name of DETACHED_ONLY_COMMANDS) editor.unregisterCommand(name);
   editor.registerCommand(
     "%cmd.show_info",
     "%cmd.show_info_desc",
@@ -1906,12 +2611,6 @@ function registerCommands(): void {
     "devcontainer_open_config",
     null,
   );
-  editor.registerCommand(
-    "%cmd.run_lifecycle",
-    "%cmd.run_lifecycle_desc",
-    "devcontainer_run_lifecycle",
-    null,
-  );
   editor.registerCommand(
     "%cmd.show_features",
     "%cmd.show_features_desc",
@@ -1930,42 +2629,58 @@ function registerCommands(): void {
     "devcontainer_rebuild",
     null,
   );
-  editor.registerCommand(
-    "%cmd.attach",
-    "%cmd.attach_desc",
-    "devcontainer_attach",
-    null,
-  );
-  editor.registerCommand(
-    "%cmd.detach",
-    "%cmd.detach_desc",
-    "devcontainer_detach",
-    null,
-  );
-  editor.registerCommand(
-    "%cmd.show_logs",
-    "%cmd.show_logs_desc",
-    "devcontainer_show_logs",
-    null,
-  );
   editor.registerCommand(
     "%cmd.show_build_logs",
     "%cmd.show_build_logs_desc",
     "devcontainer_show_build_logs",
     null,
   );
+  // `run_lifecycle` works in both modes — `initializeCommand` is
+  // host-side per spec, the rest are container-side. The picker
+  // itself filters which entries are runnable.
   editor.registerCommand(
-    "%cmd.cancel_attach",
-    "%cmd.cancel_attach_desc",
-    "devcontainer_cancel_attach",
+    "%cmd.run_lifecycle",
+    "%cmd.run_lifecycle_desc",
+    "devcontainer_run_lifecycle",
     null,
   );
+  // `show_forwarded_ports_panel` works in both modes too — the
+  // panel renders configured `forwardPorts` even with no
+  // container up. (The "configured only" branch is what the
+  // panel's regression test exercises.)
   editor.registerCommand(
     "%cmd.show_forwarded_ports_panel",
     "%cmd.show_forwarded_ports_panel_desc",
     "devcontainer_show_forwarded_ports_panel",
     null,
   );
+  if (attached) {
+    editor.registerCommand(
+      "%cmd.detach",
+      "%cmd.detach_desc",
+      "devcontainer_detach",
+      null,
+    );
+    editor.registerCommand(
+      "%cmd.show_logs",
+      "%cmd.show_logs_desc",
+      "devcontainer_show_logs",
+      null,
+    );
+  } else {
+    editor.registerCommand(
+      "%cmd.attach",
+      "%cmd.attach_desc",
+      "devcontainer_attach",
+      null,
+    );
+    editor.registerCommand(
+      "%cmd.cancel_attach",
+      "%cmd.cancel_attach_desc",
+      "devcontainer_cancel_attach",
+      null,
+    );
+  }
 }
 
 // =============================================================================
@@ -2049,18 +2764,30 @@ if (findConfig()) {
       );
       return;
     }
-    // One-shot per-session dismissal: if the user already said "Not
-    // now" in this Editor process, don't re-prompt. On a cold restart
-    // the state is gone and we ask again — that's fine.
+    // Persistent dismissal (`Ignore (always in this directory)`)
+    // OR a successful prior attach — both are recorded in plugin
+    // global state and survive editor restarts. Skip the popup.
     const previousDecision = readAttachDecision();
     if (previousDecision !== null) return;
+    // Session-only dismissal (`Ignore (once)`): in-memory flag,
+    // cleared on plugin reload so the *next* editor restart
+    // re-asks in this workspace.
+    if (attachDismissedThisSession) return;
     showAttachPrompt();
   }
-  registerHandler(
-    "devcontainer_maybe_show_attach_prompt",
-    devcontainer_maybe_show_attach_prompt,
-  );
-  editor.on("plugins_loaded", "devcontainer_maybe_show_attach_prompt");
+  editor.on("plugins_loaded", devcontainer_maybe_show_attach_prompt);
 } else {
-  editor.debug("Dev Container plugin: no devcontainer.json found");
+  // Bug #2 + #3: a `devcontainer.json` that exists but fails to
+  // parse used to fail silently AND drop every `Dev Container:`
+  // command from the palette, leaving no in-editor recovery path
+  // (the user had to restart the editor). Now: surface the parse
+  // error in the status bar AND register a small recovery set
+  // (Open Config + Show Build Logs) so the user can navigate to
+  // the broken file and fix it.
+  if (lastParseError) {
+    showParseErrorIfAny();
+    registerRecoveryCommands();
+  } else {
+    editor.debug("Dev Container plugin: no devcontainer.json found");
+  }
 }