diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
index e534abc..d07c2f4 100644
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -1,6 +1,6 @@
 # Default owners for everything in the repo.
 # These owners will be requested for review on all pull requests.
-*       @buckle-dev/maintainers
+*       @marceloceccon
 
 # Core team members can be added here as the project grows.
 # Example:
diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md
index 6218cde..dbe16b4 100644
--- a/.github/ISSUE_TEMPLATE/bug_report.md
+++ b/.github/ISSUE_TEMPLATE/bug_report.md
@@ -21,7 +21,7 @@ A clear description of what you expected to happen.
 **Environment**
 - OS: [e.g. macOS 15, Ubuntu 24.04, Windows 11]
 - Node version: [e.g. 22.3.0]
-- buckle version: [e.g. 0.1.0]
+- buckle version: [e.g. 0.4.0]
 - Docker / Podman version:
 
 **Additional context**
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index d723e10..526593f 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -51,8 +51,8 @@ jobs:
       - name: Typecheck
         run: npm run typecheck
 
-      - name: Test
-        run: npm test
+      - name: Test with coverage
+        run: npm run test:coverage
 
       - name: Upload coverage
         if: matrix.node-version == '22'
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 33fdf90..a9136c8 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,23 +4,48 @@ All notable changes to this project are documented here. The format is based on
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and this project adheres to
 [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [0.2.0] — 2026-05-28
+## [Unreleased]
+
+## [0.4.0] — 2026-08-31
+
+### Breaking
+
+- **Per-workspace isolation is now the default.** `~/.claude` and `~/.grok` are
+  no longer bind-mounted from the host when rendering. Each workspace gets its
+  own skills/config under `$XDG_DATA_HOME/buckle/workspaces/<id>/`.
+  Pass `--share-home` (or `--no-isolate`, or `isolate: false` in
+  `~/.config/buckle/config.yaml`) to restore the previous host-home mounts.
+  Existing `.devcontainer/` files are unchanged until you re-render
+  (`buckle <template> --yes` or status-panel `c`).
+- Non-interactive trust failures tell you to pass `--trust` after `buckle view`.
+  Interactive TTYs now actually prompt `[y/N]` and show the executable surface.
+- `buckle install` refuses plaintext `http://` origins.
+- MCP convenience features no longer swallow `npm install` failures (`|| true` removed).
 
 ### Added
 
-- Trusted Publishing support via GitHub Actions OIDC (no more long-lived NPM_TOKEN required).
-- Proper release workflow (`.github/workflows/release.yml`) triggered on version tags.
-- Code scanning fixes for path traversal vulnerabilities (in template installation and `buckle new`).
-- Improved pre-commit lint guard using Husky + lint-staged.
-- Better Dependabot configuration to reduce noise on risky major updates.
+- `--share-home` / `--no-isolate` to opt out of isolation.
+- `~/.config/buckle/config.yaml` is loaded (`editor`, `defaultTemplate`, `isolate`).
+- Status panel `c` reconfigure flow (pick a template, rewrite `.devcontainer/`).
+- Dual-agent callouts for `ai-native` and `claude-corp` in `buckle list`,
+  `buckle doctor`, and the wizard.
+- Empty-directory autodetect suggests `ai-native` first.
+- Interactive lifecycle trust prompt for user/installed templates.
+- `docs/DESIGN-NOTES.md`, `MAINTAINERS.md`.
 
-### Changed
+### Fixed
 
-- Package is now published as `buckle-cli` on npm (binary remains `buckle`).
-- Repository references updated for current fork during initial development.
-- Various CI and developer experience improvements (lint config, version validation on release).
+- `--version` reports the `package.json` version instead of a stale `0.1.0`.
+- Trust-surface hashes use a key-sorted serializer (no false “changed” from key order).
+- Unknown convenience features raise `BuckleError` (`E_TEMPLATE_INVALID`).
+- Generated file banners and docs point at `entropyvortex/buckle`.
+- CI runs coverage thresholds. Code scanning uses GitHub's default CodeQL setup.
 
-## [Unreleased]
+### Security
+
+- Path-stable origin parsing and ReDoS hardening remain as of 0.3.0.
+- Hook-surface hashing is now order-independent.
+- Install origins cannot be plaintext HTTP.
 
 ## [0.3.0] — 2026-05-28
 
@@ -42,6 +67,20 @@ These changes address GitHub CodeQL alerts ("Uncontrolled data used in path expr
 
 ## [0.2.0] — 2026-05-28
 
+### Added
+
+- Trusted Publishing support via GitHub Actions OIDC (no more long-lived NPM_TOKEN required).
+- Proper release workflow (`.github/workflows/release.yml`) triggered on version tags.
+- Code scanning fixes for path traversal vulnerabilities (in template installation and `buckle new`).
+- Improved pre-commit lint guard using Husky + lint-staged.
+- Better Dependabot configuration to reduce noise on risky major updates.
+
+### Changed
+
+- Package is now published as `buckle-cli` on npm (binary remains `buckle`).
+- Repository references updated for current fork during initial development.
+- Various CI and developer experience improvements (lint config, version validation on release).
+
 ## [0.1.0] — 2026-05-08
 
 ### Added
@@ -64,6 +103,8 @@ These changes address GitHub CodeQL alerts ("Uncontrolled data used in path expr
 - `buckle install` from `gh:user/repo`, `gl:user/repo`, https git URL, or `file://`.
 - `--preview` / `--dry-run` to emit a diff without writing.
 - Stable JSON error codes.
-- 179 unit + integration tests; ≥ 90% coverage.
 
-[0.1.0]: https://github.com/buckle-dev/buckle/releases/tag/v0.1.0
+[0.4.0]: https://github.com/entropyvortex/buckle/releases/tag/v0.4.0
+[0.3.0]: https://github.com/entropyvortex/buckle/releases/tag/v0.3.0
+[0.2.0]: https://github.com/entropyvortex/buckle/releases/tag/v0.2.0
+[0.1.0]: https://github.com/entropyvortex/buckle/releases/tag/v0.1.0
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 71b289f..4e19e80 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -5,7 +5,7 @@ Thank you for your interest in contributing to buckle!
 ## Development Setup
 
 ```bash
-git clone https://github.com/buckle-dev/buckle.git
+git clone https://github.com/entropyvortex/buckle.git
 cd buckle
 npm install
 npm run build
diff --git a/MAINTAINERS.md b/MAINTAINERS.md
new file mode 100644
index 0000000..59afcec
--- /dev/null
+++ b/MAINTAINERS.md
@@ -0,0 +1,11 @@
+# Maintainers
+
+Security and release decisions for this repository.
+
+| Name | Email | GitHub |
+| --- | --- | --- |
+| Marcelo Ceccon | marcelo@ceccon.org | [@marceloceccon](https://github.com/marceloceccon) |
+
+GPG keys for encrypted security reports: request via the email above.
+
+Releases are cut from `main` by a maintainer (see CONTRIBUTING.md).
diff --git a/README.md b/README.md
index abf7450..c2efb9b 100644
--- a/README.md
+++ b/README.md
@@ -118,6 +118,8 @@ $ buckle up claude-corp        # Node + Claude Code + GitHub CLI + selected MCPs
 | `--detach` | Don't attach a shell after `up`/`rebuild`. |
 | `--git-init` | Initialize a git repo in the workspace if there is none. |
 | `--preview`, `--dry-run` | Show what *would* be written without touching disk. |
+| `--isolate` | Default. Per-workspace `~/.claude` / `~/.grok` under `$XDG_DATA_HOME/buckle/workspaces/`. |
+| `--share-home`, `--no-isolate` | Bind-mount host `~/.claude`, `~/.grok`, and `~/.gitconfig` instead. |
 
 ---
 
@@ -474,7 +476,7 @@ status:    running
 image:     mcr.microsoft.com/devcontainers/javascript-node:1-20-bullseye
 ports:     3000 → 3000/tcp
 
-r rebuild · u up · s/d down · b bash · q quit
+r rebuild · u up · s/d down · b bash · c reconfigure · q quit
 ```
 
 Refresh interval defaults to 5 s; override with `BUCKLE_STATUS_REFRESH=2000`.
@@ -519,17 +521,47 @@ file system. `buckle` therefore prompts you on first use of any template whose
 is unseen. The trust store lives at `~/.config/buckle/trust.json` and maps the merged-template
 SHA-256 to the date you trusted it. If the surface changes, you're prompted again.
 
+On a TTY, buckle prints that surface and asks `[y/N]`. In CI, `--json`, or any non-TTY
+context the prompt is a hard error (`E_HASH_MISMATCH`); pass `--trust` after reviewing
+with `buckle view`.
+
 You can:
 
 - pass `--trust` to skip the prompt for that one run
-- inspect a template before trusting with `buckle edit <name>`
+- inspect a template before trusting with `buckle view <name>` / `buckle edit <name>`
 - review what would be written without committing with `--preview` / `--dry-run`
 
+Built-in templates are pre-trusted. User and installed templates are not.
+
 `buckle` does no network access during template resolution. `buckle install` does network
-clones via `git`. `buckle doctor` is the only command that probes outside the workspace.
+clones via `git` (HTTPS only; plaintext `http://` is rejected). `buckle doctor` is the only
+command that probes outside the workspace.
 
 See [SECURITY.md](SECURITY.md) for the full threat model.
 
+## Isolation (default)
+
+Agent skills, versions, and config are **per workspace**, not shared from the host:
+
+| Path in container | Isolated source (default) | `--share-home` |
+| --- | --- | --- |
+| `/home/vscode/.claude` | `$XDG_DATA_HOME/buckle/workspaces/<slug>-<hash>/claude` | `${localEnv:HOME}/.claude` |
+| `/home/vscode/.grok` | `$XDG_DATA_HOME/buckle/workspaces/<slug>-<hash>/grok` | `${localEnv:HOME}/.grok` |
+| `/home/vscode/.gitconfig` | host `~/.gitconfig` (identity, always) | host `~/.gitconfig` |
+
+Re-render an existing project to pick up isolation:
+
+```bash
+buckle ai-native --yes          # isolated (default)
+buckle ai-native --share-home --yes
+```
+
+Override for every command via `~/.config/buckle/config.yaml`:
+
+```yaml
+isolate: false   # equivalent to always passing --share-home
+```
+
 ---
 
 ## Compatibility
@@ -561,6 +593,7 @@ Per-user file at `~/.config/buckle/config.yaml` (optional):
 ```yaml
 editor: code              # falls back to $VISUAL → $EDITOR → vi
 defaultTemplate: node     # used by the wizard if autodetect can't decide
+isolate: true             # default; set false to share host ~/.claude and ~/.grok
 ```
 
 Environment variables:
@@ -572,12 +605,13 @@ Environment variables:
 | `BUCKLE_BUILTIN_DIR` | Override built-in template directory (testing). |
 | `BUCKLE_NO_COLOR` | Strip ANSI from output (also honors `NO_COLOR`). |
 | `BUCKLE_DEBUG` | Print full stack traces on uncaught errors. |
+| `BUCKLE_STATE_DIR` | Override the per-workspace AI state root (default `$XDG_DATA_HOME/buckle/workspaces`). |
 
 ---
 
 ## Testing
 
-Run the full suite (179 tests at the time of writing):
+Run the full suite:
 
 ```bash
 npm test
@@ -646,7 +680,7 @@ change the spec, please reference it.
 To work on buckle locally:
 
 ```bash
-git clone https://github.com/buckle-dev/buckle.git
+git clone https://github.com/entropyvortex/buckle.git
 cd buckle
 npm install
 npm run build
diff --git a/SECURITY.md b/SECURITY.md
index 796d0ba..2c07f00 100644
--- a/SECURITY.md
+++ b/SECURITY.md
@@ -17,7 +17,7 @@ the latest minor of the current major and the previous major receive fixes for 6
 ## Reporting a vulnerability
 
 **Please do not open a public issue for security reports.** Instead, email
-**security@buckle.dev** with:
+**marcelo@ceccon.org** (or **security@buckle.dev** if that mailbox is reachable) with:
 
 - a clear description of the issue,
 - a minimal reproducer,
@@ -56,8 +56,12 @@ that has been granted host access (e.g., via `dod` or bind-mounts).
 - `buckle edit <name>` opens the template for review before you trust it.
 - `buckle <name> --preview` (or `--dry-run`) emits the full diff of generated files without
   touching disk.
-- The trust prompt is **non-interactive-aware**: in CI / non-TTY contexts, the prompt becomes a
-  hard error (`E_HASH_MISMATCH`); you must opt in explicitly with `--trust`.
+- On a TTY, buckle prints the executable surface and prompts `[y/N]`.
+- In CI / `--json` / non-TTY contexts the prompt becomes a hard error (`E_HASH_MISMATCH`);
+  you must opt in explicitly with `--trust`.
+- Built-in templates are pre-trusted. User and installed templates are not.
+- Agent config dirs (`~/.claude`, `~/.grok`) are isolated per workspace by default so
+  skills and credentials do not leak across containers. `--share-home` restores host binds.
 
 **Out of scope**: We do *not* statically analyze the body of `postCreate` commands. The trust
 boundary is your eyes — the same as `make` or `npm install`.
@@ -122,6 +126,5 @@ resolution.
 
 ## Contact
 
-- General security issues: **security@buckle.dev**
-- Public discussion: `#security` in the project chat
-- Maintainer GPG keys: Available upon request via the security email above.
+- General security issues: **marcelo@ceccon.org**
+- Maintainer GPG keys: listed in [MAINTAINERS.md](MAINTAINERS.md) (available on request)
diff --git a/docs/DESIGN-NOTES.md b/docs/DESIGN-NOTES.md
new file mode 100644
index 0000000..dc7cc1f
--- /dev/null
+++ b/docs/DESIGN-NOTES.md
@@ -0,0 +1,62 @@
+# Design notes
+
+This is the architecture consensus for buckle: a single TypeScript CLI that
+collapses generate → build → up → bash into one verb, with **user-wide**
+templates rather than per-repo copy-paste.
+
+## Core bets
+
+1. **Templates travel with the developer.** `~/.config/buckle/templates/` is the
+   source of truth. Repos receive generated `.devcontainer/` artifacts, not the
+   template itself.
+2. **One schema, three artifacts.** A YAML template compiles deterministically
+   to `devcontainer.json` plus optional `Dockerfile` / `docker-compose.yml`.
+3. **Inheritance is data, not a preprocessor.** `extends` is a string or ordered
+   list; objects deep-merge; arrays append unless the child starts with
+   `!replace`. Cycles are errors. Depth is capped at 8.
+4. **Convenience features are sugar.** `dod`, `claude-code`, `grok`, `mcp:*`
+   compile to native devcontainer features + hooks + mounts. Unknown names are
+   `E_TEMPLATE_INVALID`.
+5. **The executable surface is a trust boundary.** Lifecycle, mounts, runArgs,
+   and features are hashed with a stable serializer. Built-ins are pre-trusted.
+   User/installed templates prompt interactively (or require `--trust` when
+   non-TTY).
+6. **AI agent state is per-workspace by default.** Host `~/.claude` and `~/.grok`
+   are not bind-mounted unless `--share-home`. Isolated state lives under
+   `$XDG_DATA_HOME/buckle/workspaces/<slug>-<hash>/{claude,grok}` so skills,
+   versions, and configs do not leak across containers. Host `~/.gitconfig`
+   remains shared (identity, not agent state).
+
+## Layers
+
+```
+cli/          parse, JSON envelope, command shells, render pipeline
+templates/    zod schema, loader, resolver, autodetect, trust, isolate
+features/     convenience catalog → native features + hooks
+generators/   devcontainer / Dockerfile / compose + plan/apply
+docker/       naming, inspect, @devcontainers/cli wrapper, Driver
+tui/          wizard (no .devcontainer) / status panel (has one)
+util/         errors, paths (XDG), log, fs, slug, config, version
+```
+
+## Non-goals (0.x)
+
+- Signature verification of installed templates (`metadata.signature` is reserved).
+- Static analysis of hook command bodies.
+- First-class Podman (Docker-API compat only; `doctor` warns).
+- Per-step `user:` on lifecycle hooks (`@devcontainers/cli` rejects the shape).
+
+## CLI contract
+
+- Every command accepts `--json` with a stable envelope (`ok`, `timestamp`,
+  `workspace`, `data` | `error.code`).
+- Error codes in `src/util/errors.ts` are never repurposed.
+- `--version` is read from `package.json` (`buckle-cli`), not a string literal.
+- `--preview` / `--dry-run` never write.
+
+## Invariants
+
+- At most one of `image` / `build` / `compose` after merge.
+- Generated JSON is key-sorted for stable diffs.
+- Writes go through `writeTextAtomic`.
+- Isolation dirs are created at plan time so `devcontainer up` can bind them.
diff --git a/package.json b/package.json
index 9de3951..9d491b4 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "buckle-cli",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "One verb for devcontainers — generate, build, up, and bash with user-wide templates.",
   "license": "MIT",
   "author": "Buckle Contributors",
diff --git a/src/cli/commands/doctor.ts b/src/cli/commands/doctor.ts
index 4be3275..260bda4 100644
--- a/src/cli/commands/doctor.ts
+++ b/src/cli/commands/doctor.ts
@@ -5,6 +5,8 @@ import { execa } from 'execa';
 
 import { DockerCli } from '../../docker/inspect.js';
 import { hasDevcontainerCli } from '../../docker/devcontainer-cli.js';
+import { DUAL_AGENT_TEMPLATES } from '../../templates/ai.js';
+import { workspaceStateDir } from '../../templates/isolate.js';
 import { exists } from '../../util/fs.js';
 import { bucklePaths } from '../../util/paths.js';
 import { styles } from '../../util/log.js';
@@ -93,6 +95,21 @@ export async function runDoctor(ctx: CliContext): Promise<number> {
     checks.push({ name: 'docker.buildx', status: 'warn', message: 'docker buildx not available' });
   }
 
+  const isolateOn = ctx.flags.isolate !== false;
+  checks.push({
+    name: 'ai.isolate',
+    status: 'pass',
+    message: isolateOn
+      ? `per-workspace agent state (${workspaceStateDir(ctx.cwd)}; --share-home to bind host ~/.claude and ~/.grok)`
+      : 'sharing host ~/.claude and ~/.grok (--share-home)',
+  });
+
+  checks.push({
+    name: 'ai.templates',
+    status: 'pass',
+    message: `dual-agent ready: ${DUAL_AGENT_TEMPLATES.join(', ')} (Claude Code + Grok Build)`,
+  });
+
   const overall = checks.some((c) => c.status === 'fail')
     ? 'broken'
     : checks.some((c) => c.status === 'warn')
diff --git a/src/cli/commands/edit.ts b/src/cli/commands/edit.ts
index 10f0b3f..036cb4d 100644
--- a/src/cli/commands/edit.ts
+++ b/src/cli/commands/edit.ts
@@ -14,7 +14,7 @@ export async function runEdit(ctx: CliContext, args: { template: string }): Prom
       `run "buckle view ${args.template}" to inspect, or "buckle new ${args.template} --extend ${args.template}" to create an editable copy`,
     );
   }
-  const editor = process.env['VISUAL'] ?? process.env['EDITOR'] ?? 'vi';
+  const editor = ctx.config.editor ?? process.env['VISUAL'] ?? process.env['EDITOR'] ?? 'vi';
   return new Promise((resolveP) => {
     const proc = spawn(editor, [rec.path], { stdio: 'inherit' });
     proc.on('exit', (code) => resolveP(code ?? 0));
diff --git a/src/cli/commands/list.ts b/src/cli/commands/list.ts
index 36e3910..0c9401c 100644
--- a/src/cli/commands/list.ts
+++ b/src/cli/commands/list.ts
@@ -1,4 +1,5 @@
 /** `buckle list` — built-in + user + installed templates. */
+import { isDualAgentTemplate } from '../../templates/ai.js';
 import { listCatalog } from '../../templates/loader.js';
 import { styles } from '../../util/log.js';
 import type { CliContext } from '../context.js';
@@ -9,7 +10,17 @@ export async function runList(ctx: CliContext): Promise<number> {
   const filtered = ctx.flags.installedOnly ? items.filter((i) => i.origin !== 'builtin') : items;
 
   if (ctx.flags.json) {
-    emit(jsonOk({ templates: filtered }, ctx.cwd));
+    emit(
+      jsonOk(
+        {
+          templates: filtered.map((t) => ({
+            ...t,
+            dualAgent: isDualAgentTemplate(t.name),
+          })),
+        },
+        ctx.cwd,
+      ),
+    );
     return 0;
   }
   if (filtered.length === 0) {
@@ -18,13 +29,14 @@ export async function runList(ctx: CliContext): Promise<number> {
   }
   const widest = filtered.reduce((m, i) => Math.max(m, i.name.length), 0);
   for (const item of filtered) {
-    const tag =
+    const originTag =
       item.origin === 'builtin'
         ? styles.gray('built-in')
         : item.origin === 'user'
           ? styles.cyan('user')
           : styles.green(`installed${item.installOrigin ? ` (${item.installOrigin.slice(0, 8)})` : ''}`);
-    process.stdout.write(`  ${item.name.padEnd(widest)}  ${tag}  ${item.description ?? ''}\n`);
+    const dual = isDualAgentTemplate(item.name) ? ` ${styles.cyan('dual-agent')}` : '';
+    process.stdout.write(`  ${item.name.padEnd(widest)}  ${originTag}${dual}  ${item.description ?? ''}\n`);
   }
   return 0;
 }
diff --git a/src/cli/commands/new.ts b/src/cli/commands/new.ts
index 4d22ef2..c546c66 100644
--- a/src/cli/commands/new.ts
+++ b/src/cli/commands/new.ts
@@ -46,7 +46,7 @@ export async function runNew(ctx: CliContext, args: NewArgs): Promise<number> {
     },
   };
   const text =
-    `# Buckle template: ${args.name}\n# See https://github.com/buckle-dev/buckle for the schema.\n\n` +
+    `# Buckle template: ${args.name}\n# See https://github.com/entropyvortex/buckle for the schema.\n\n` +
     yamlStringify(starter);
   await writeTextAtomic(dest, text);
   if (ctx.flags.json) emit(jsonOk({ name: args.name, path: dest }, ctx.cwd));
diff --git a/src/cli/commands/view.ts b/src/cli/commands/view.ts
index b8a9231..674fa8a 100644
--- a/src/cli/commands/view.ts
+++ b/src/cli/commands/view.ts
@@ -17,7 +17,8 @@ export async function runView(ctx: CliContext, args: ViewArgs): Promise<number>
   const resolved = await resolveTemplate(args.template, { overlay });
   // isolate is passed to build so that feature-expanded mounts (and env) are also filtered.
   const dc = buildDevcontainer(resolved.merged, 'view', {
-    ...(ctx.flags.isolate ? { isolate: true } : {}),
+    isolate: ctx.flags.isolate !== false,
+    cwd: ctx.cwd,
   });
   if (ctx.flags.json) {
     emit(jsonOk({ template: args.template, devcontainer: dc }, ctx.cwd));
diff --git a/src/cli/context.ts b/src/cli/context.ts
index b7c0c3e..f680e78 100644
--- a/src/cli/context.ts
+++ b/src/cli/context.ts
@@ -1,5 +1,6 @@
 import { resolve as pathResolve } from 'node:path';
 
+import { loadConfigSync, type BuckleConfig } from '../util/config.js';
 import { makeLogger, type Logger } from '../util/log.js';
 
 export interface CliFlags {
@@ -15,19 +16,38 @@ export interface CliFlags {
   installedOnly?: boolean;
   force?: boolean;
   preview?: boolean;
+  /**
+   * When true (the default), AI agent skills/config live in a per-workspace
+   * directory instead of the host ~/.claude and ~/.grok.
+   * `--share-home` / `--no-isolate` sets this to false.
+   */
   isolate?: boolean;
+  /** Bind-mount host ~/.claude, ~/.grok, ~/.gitconfig. Inverse of isolate. */
+  shareHome?: boolean;
 }
 
 export interface CliContext {
   cwd: string;
   flags: CliFlags;
   logger: Logger;
+  config: BuckleConfig;
+}
+
+function resolveIsolate(flags: CliFlags, config: BuckleConfig): boolean {
+  if (flags.shareHome === true) return false;
+  if (flags.isolate === false) return false;
+  if (flags.isolate === true) return true;
+  if (config.isolate === false) return false;
+  return true;
 }
 
 export function makeContext(flags: CliFlags, cwd?: string): CliContext {
+  const config = loadConfigSync();
+  const isolate = resolveIsolate(flags, config);
+  const merged: CliFlags = { ...flags, isolate, shareHome: !isolate };
   const logger = makeLogger({
-    ...(flags.json !== undefined ? { json: flags.json } : {}),
-    ...(flags.verbose !== undefined ? { verbose: flags.verbose } : {}),
+    ...(merged.json !== undefined ? { json: merged.json } : {}),
+    ...(merged.verbose !== undefined ? { verbose: merged.verbose } : {}),
   });
-  return { cwd: pathResolve(cwd ?? process.cwd()), flags, logger };
+  return { cwd: pathResolve(cwd ?? process.cwd()), flags: merged, logger, config };
 }
diff --git a/src/cli/install.ts b/src/cli/install.ts
index 8ea5a28..aa34716 100644
--- a/src/cli/install.ts
+++ b/src/cli/install.ts
@@ -60,7 +60,13 @@ export function parseOrigin(input: string): ParsedOrigin {
     } else {
       url = `https://gitlab.com/${rest}.git`;
     }
-  } else if (urlPart.startsWith('https://') || urlPart.startsWith('http://') || urlPart.startsWith('git@') || urlPart.startsWith('ssh://')) {
+  } else if (urlPart.startsWith('http://')) {
+    throw new BuckleError(
+      ErrorCode.E_INSTALL_FAILED,
+      `refusing plaintext http origin: ${input}`,
+      'use https://, git@, ssh://, gh:, gl:, or file://',
+    );
+  } else if (urlPart.startsWith('https://') || urlPart.startsWith('git@') || urlPart.startsWith('ssh://')) {
     url = urlPart;
   } else if (urlPart.startsWith('file://')) {
     url = urlPart;
diff --git a/src/cli/parse.ts b/src/cli/parse.ts
index d82d714..8103a9a 100644
--- a/src/cli/parse.ts
+++ b/src/cli/parse.ts
@@ -39,6 +39,7 @@ import { join } from 'node:path';
 import { makeContext, type CliFlags } from './context.js';
 import { templateExists } from '../templates/loader.js';
 import { exists } from '../util/fs.js';
+import { packageVersion } from '../util/version.js';
 
 export interface RunResult {
   exitCode: number;
@@ -67,7 +68,15 @@ function attachGlobals(cmd: Command): Command {
     .option('--installed-only', 'list installed (non-built-in) templates only')
     .option('--force', 'force overwrite on install')
     .option('--preview, --dry-run', 'show what would be written without changing the filesystem')
-    .option('--isolate', 'skip bind-mounts + related containerEnv for host AI/home dirs (~/.claude, ~/.grok, ~/.gitconfig) — escape hatch for first-creation friction on some macOS arm64 setups');
+    .option(
+      '--isolate',
+      'keep AI agent skills/config per workspace (default). Each container gets its own ~/.claude and ~/.grok under $XDG_DATA_HOME/buckle/workspaces/',
+    )
+    .option('--no-isolate', 'alias for --share-home')
+    .option(
+      '--share-home',
+      'bind-mount host ~/.claude, ~/.grok, and ~/.gitconfig into the container (disables per-workspace isolation)',
+    );
 }
 
 function readGlobals(cmd: Command): CliFlags {
@@ -84,7 +93,9 @@ function readGlobals(cmd: Command): CliFlags {
     installedOnly: Boolean(o['installedOnly']),
     force: Boolean(o['force']),
     preview: Boolean(o['preview']),
-    isolate: Boolean(o['isolate']),
+    shareHome: Boolean(o['shareHome']),
+    // Isolation is the default. --share-home or --no-isolate opts out.
+    isolate: Boolean(o['shareHome']) ? false : o['isolate'] !== false,
   };
   if (typeof o['user'] === 'string') out.user = o['user'];
   return out;
@@ -163,7 +174,7 @@ async function runProgram(argv: string[]): Promise<RunResult> {
   program
     .name('buckle')
     .description('One verb for devcontainers — generate, build, up, and bash with user-wide templates.')
-    .version('0.1.0', '-V, --version', 'print the buckle version');
+    .version(packageVersion(), '-V, --version', 'print the buckle version');
 
   attachGlobals(program);
 
diff --git a/src/cli/render.ts b/src/cli/render.ts
index 55ff2d6..eb7bf2d 100644
--- a/src/cli/render.ts
+++ b/src/cli/render.ts
@@ -10,6 +10,7 @@ import type { Template } from '../templates/schema.js';
 import { checkTrust, hookSurfaceHash, recordTrust } from '../templates/trust.js';
 import { applyPlan, plan, renderDiff, summarizePlan, type RenderPlan } from '../generators/writer.js';
 import { BuckleError, ErrorCode } from '../util/errors.js';
+import { promptYesNo } from '../util/prompt.js';
 import type { CliContext } from './context.js';
 
 export interface RenderArgs {
@@ -56,25 +57,30 @@ export async function renderTemplate(ctx: CliContext, args: RenderArgs): Promise
   if (!trusted) {
     const decision = await checkTrust(hash, surface);
     if (!decision.trusted) {
-      // For non-interactive contexts, surface a clear error.
+      const reason = decision.changed
+        ? `template "${args.templateName}" lifecycle hooks have changed since you last trusted it`
+        : `template "${args.templateName}" has unverified lifecycle hooks`;
+      // Non-interactive / JSON: never silently trust.
       if (process.stdin.isTTY !== true || ctx.flags.json) {
         throw new BuckleError(
           ErrorCode.E_HASH_MISMATCH,
-          decision.changed
-            ? `template "${args.templateName}" lifecycle hooks have changed since you last trusted it`
-            : `template "${args.templateName}" has unverified lifecycle hooks; review them before running`,
-          're-run with --trust after reviewing the template, or run interactively to be prompted',
+          reason,
+          'review with `buckle view`, then re-run with --trust',
+        );
+      }
+      ctx.logger.warn(reason);
+      ctx.logger.info('executable surface (lifecycle, mounts, runArgs, features):');
+      for (const line of formatTrustSurface(resolved.merged)) {
+        ctx.logger.info(`  ${line}`);
+      }
+      const accepted = await promptYesNo('Trust this template and continue? [y/N] ');
+      if (!accepted) {
+        throw new BuckleError(
+          ErrorCode.E_USER_ABORT,
+          'aborted: template not trusted',
+          'pass --trust on the next run after reviewing with `buckle view`',
         );
       }
-      // Interactive: print the surface and ask.
-      ctx.logger.warn(
-        `Template "${args.templateName}" wants to run lifecycle commands on first use. Run "buckle view ${args.templateName}" to inspect, or pass --trust to accept.`,
-      );
-      throw new BuckleError(
-        ErrorCode.E_USER_ABORT,
-        'aborted: template not trusted',
-        'pass --trust on the next run to accept the lifecycle commands',
-      );
     }
     trusted = true;
   }
@@ -85,13 +91,11 @@ export async function renderTemplate(ctx: CliContext, args: RenderArgs): Promise
     await recordTrust(hash, surface);
   }
 
-  // Pass --isolate through; stripping of home mounts happens after feature expansion inside
-  // buildDevcontainer (so both template-declared and feature-injected mounts are removed).
   const projectName = basename(ctx.cwd);
   const p = await plan(resolved.merged, {
     cwd: ctx.cwd,
     projectName,
-    ...(ctx.flags.isolate ? { isolate: true } : {}),
+    isolate: ctx.flags.isolate !== false,
   });
   const summary = summarizePlan(p);
   for (const s of summary) {
@@ -127,9 +131,7 @@ export async function renderTemplate(ctx: CliContext, args: RenderArgs): Promise
       return { template: resolved.merged, hash, plan: p, written: false, trusted };
     }
     if (!args.yes && process.stdin.isTTY === true && !ctx.flags.json) {
-      // Best-effort interactive confirmation. In headless contexts (--yes / non-TTY),
-      // we proceed without prompting.
-      const confirmed = await confirm(`Apply changes to .devcontainer/ in ${ctx.cwd}? [y/N] `);
+      const confirmed = await promptYesNo(`Apply changes to .devcontainer/ in ${ctx.cwd}? [y/N] `);
       if (!confirmed) {
         throw new BuckleError(ErrorCode.E_USER_ABORT, 'aborted by user');
       }
@@ -143,14 +145,24 @@ export async function renderTemplate(ctx: CliContext, args: RenderArgs): Promise
   return { template: resolved.merged, hash, plan: p, written, trusted };
 }
 
-async function confirm(prompt: string): Promise<boolean> {
-  return new Promise((resolveP) => {
-    process.stderr.write(prompt);
-    const onData = (chunk: Buffer) => {
-      const ans = chunk.toString().trim().toLowerCase();
-      process.stdin.off('data', onData);
-      resolveP(ans === 'y' || ans === 'yes');
-    };
-    process.stdin.once('data', onData);
-  });
+export function formatTrustSurface(t: Template): string[] {
+  const lines: string[] = [];
+  const hooks = t.lifecycle ?? {};
+  for (const [name, steps] of Object.entries(hooks)) {
+    if (!steps || steps.length === 0) continue;
+    const cmds = steps.map((s) => (typeof s === 'string' ? s : s.command));
+    lines.push(`${name}: ${cmds.join(' && ')}`);
+  }
+  if (t.mounts && t.mounts.length > 0) {
+    for (const m of t.mounts) {
+      lines.push(`mount: ${m.source} → ${m.target} (${m.type ?? 'bind'})`);
+    }
+  }
+  if (t.runArgs && t.runArgs.length > 0) lines.push(`runArgs: ${t.runArgs.join(' ')}`);
+  if (t.features && t.features.length > 0) {
+    const names = t.features.map((f) => (typeof f === 'string' ? f : f[0]));
+    lines.push(`features: ${names.join(', ')}`);
+  }
+  if (lines.length === 0) lines.push('(no lifecycle, mounts, runArgs, or features)');
+  return lines;
 }
diff --git a/src/docker/devcontainer-cli.ts b/src/docker/devcontainer-cli.ts
index 02697f6..ef596aa 100644
--- a/src/docker/devcontainer-cli.ts
+++ b/src/docker/devcontainer-cli.ts
@@ -92,8 +92,9 @@ export async function up(opts: UpOptions): Promise<{ containerId: string }> {
       hint +=
         '\n\nThis is usually caused by a bad cached features image layer.\n' +
         'Try:  buckle up <template> --rebuild     (forces a clean no-cache build)\n' +
-        'As a last resort for macOS arm64 + AI mounts on first creation, try --isolate:\n' +
-        '  buckle up <template> --trust --rebuild --isolate';
+        'Isolation is on by default (per-workspace ~/.claude and ~/.grok). If a host-home bind is the problem,\n' +
+        're-render without --share-home. To share the host agent dirs instead:\n' +
+        '  buckle up <template> --trust --rebuild --share-home';
     }
 
     throw new BuckleError(
diff --git a/src/features/catalog.ts b/src/features/catalog.ts
index db41256..59bf260 100644
--- a/src/features/catalog.ts
+++ b/src/features/catalog.ts
@@ -1,4 +1,6 @@
+import { deepMerge } from '../templates/resolver.js';
 import type { Template } from '../templates/schema.js';
+import { BuckleError, ErrorCode } from '../util/errors.js';
 
 /**
  * The Buckle convenience-feature catalog.
@@ -19,16 +21,7 @@ const NATIVE = (id: string, opts: Record<string, unknown> = {}): FeaturePatch =>
 });
 
 function deepMergePatch(a: FeaturePatch, b: FeaturePatch): FeaturePatch {
-  // local minimal merge, mirrors resolver semantics for arrays-append/objects-merge.
-  const out: Record<string, unknown> = { ...a };
-  for (const [k, v] of Object.entries(b)) {
-    const existing = out[k];
-    if (Array.isArray(existing) && Array.isArray(v)) out[k] = [...existing, ...v];
-    else if (existing && typeof existing === 'object' && v && typeof v === 'object' && !Array.isArray(v))
-      out[k] = deepMergePatch(existing as FeaturePatch, v as FeaturePatch);
-    else out[k] = v;
-  }
-  return out as FeaturePatch;
+  return deepMerge(a, b) as FeaturePatch;
 }
 
 const CATALOG: Record<string, FeatureFn> = {
@@ -143,7 +136,7 @@ function mcpFeature(name: string): FeaturePatch {
   const pkg = name.startsWith('@') ? name : `@modelcontextprotocol/server-${name}`;
   return {
     lifecycle: {
-      postCreate: [`npm install -g ${pkg} || true`],
+      postCreate: [`npm install -g ${pkg}`],
     },
   };
 }
@@ -200,7 +193,7 @@ export function compileFeature(spec: FeatureSpec): FeaturePatch {
   }
   const fn = CATALOG[spec.name];
   if (!fn) {
-    throw new Error(`unknown feature: ${spec.name}`);
+    throw new BuckleError(ErrorCode.E_TEMPLATE_INVALID, `unknown feature: ${spec.name}`);
   }
   return fn(spec.arg);
 }
@@ -211,8 +204,8 @@ export function listFeatures(): { name: string; description: string }[] {
     { name: 'dind', description: 'Docker in docker (privileged dockerd)' },
     { name: 'gh', description: 'GitHub CLI' },
     { name: 'git-config', description: 'Bind-mount host ~/.gitconfig read-only' },
-    { name: 'claude-code', description: 'Install Claude Code CLI; mount ~/.claude (pairs excellently with grok)' },
-    { name: 'grok', description: 'Install Grok Build (xAI); mount ~/.grok (pairs excellently with claude-code)' },
+    { name: 'claude-code', description: 'Install Claude Code CLI; isolated per workspace by default (pairs with grok)' },
+    { name: 'grok', description: 'Install Grok Build (xAI); isolated per workspace by default (pairs with claude-code)' },
     { name: 'grok-build', description: 'Alias for grok' },
     { name: 'mcp:<name>', description: 'Install an MCP server (filesystem, github, …)' },
     { name: 'aws', description: 'AWS CLI v2' },
diff --git a/src/features/compile.ts b/src/features/compile.ts
index db18406..5070d41 100644
--- a/src/features/compile.ts
+++ b/src/features/compile.ts
@@ -1,5 +1,6 @@
 import { deepMerge } from '../templates/resolver.js';
 import type { Template } from '../templates/schema.js';
+import { BuckleError, ErrorCode } from '../util/errors.js';
 import { compileFeature, isKnownFeature, parseFeatureSpec } from './catalog.js';
 
 /**
@@ -18,7 +19,11 @@ export function applyFeatures(t: Template): Template {
   for (const entry of featuresIn) {
     const raw = typeof entry === 'string' ? entry : entry[0];
     if (!isKnownFeature(raw)) {
-      throw new Error(`unknown feature in template: "${raw}"`);
+      throw new BuckleError(
+        ErrorCode.E_TEMPLATE_INVALID,
+        `unknown feature in template: "${raw}"`,
+        'run `buckle list` and `buckle doctor` for the convenience catalog, or pass a native ghcr.io/ feature id',
+      );
     }
     const spec = parseFeatureSpec(raw);
     if (typeof entry !== 'string' && entry.length === 2) {
diff --git a/src/generators/compose.ts b/src/generators/compose.ts
index d641700..bbf69b3 100644
--- a/src/generators/compose.ts
+++ b/src/generators/compose.ts
@@ -2,7 +2,7 @@ import { stringify as yamlStringify } from 'yaml';
 
 import type { MountDecl, Template } from '../templates/schema.js';
 
-const GENERATED_HEADER = `# Generated by buckle <https://github.com/buckle-dev/buckle>.
+const GENERATED_HEADER = `# Generated by buckle <https://github.com/entropyvortex/buckle>.
 # Edit your template, not this file.
 # This is a starting point for compose-based devcontainers.`;
 
diff --git a/src/generators/devcontainer.ts b/src/generators/devcontainer.ts
index b1e838a..f4fb70e 100644
--- a/src/generators/devcontainer.ts
+++ b/src/generators/devcontainer.ts
@@ -1,24 +1,9 @@
 import { applyFeatures } from '../features/compile.js';
+import { isolateHomeMounts } from '../templates/isolate.js';
 import type { LifecycleStep, Template } from '../templates/schema.js';
 import { REPLACE_SENTINEL } from '../templates/resolver.js';
 
-/** Home-persisted paths that features and ai-native templates mount from the host for convenience (used by --isolate). */
-const HOME_PERSIST_TARGETS = new Set([
-  '/home/vscode/.claude',
-  '/home/vscode/.grok',
-  '/home/vscode/.gitconfig',
-]);
-
-/**
- * Strip the well-known host-home bind mounts (used for --isolate).
- * Safe to call on merged template before or after feature expansion.
- */
-export function stripHomeMounts(t: Template): Template {
-  if (!t.mounts || t.mounts.length === 0) return t;
-  const filtered = t.mounts.filter((m) => !HOME_PERSIST_TARGETS.has(m.target));
-  if (filtered.length === t.mounts.length) return t;
-  return { ...t, mounts: filtered };
-}
+export { isolateHomeMounts, stripHomeMounts } from '../templates/isolate.js';
 
 /**
  * Devcontainer.json shape we emit. We use a permissive type — the spec keeps growing — but
@@ -95,12 +80,13 @@ function ports(t: Template): (number | { port: number })[] | undefined {
 
 export interface BuildDevcontainerOptions {
   /**
-   * When true, omit the well-known host home bind mounts **and** the associated
-   * containerEnv entries (CLAUDE_CONFIG_DIR) for full isolation.
-   * This can still be useful on first creation on macOS arm64 if the bind mounts
-   * themselves cause early startup friction with the devcontainers/base image.
+   * When true (default), remap ~/.claude and ~/.grok bind-mounts onto a
+   * per-workspace directory under XDG_DATA_HOME so skills/config do not leak
+   * across containers. Pass false (`--share-home`) to keep host home mounts.
    */
   isolate?: boolean;
+  /** Workspace path used to compute the isolated state directory. */
+  cwd?: string;
 }
 
 /**
@@ -113,18 +99,9 @@ export function buildDevcontainer(
 ): Devcontainer {
   // Apply convenience-features → nativeFeatures + hooks/mounts/env.
   let t = applyFeatures(input);
-  if (opts.isolate) {
-    t = stripHomeMounts(t);
-
-    // Drop the AI config env var for full isolation (the grok PATH prefix that used
-    // to be injected is no longer present; this also cleans up old generated files).
-    if (t.env) {
-      delete t.env['CLAUDE_CONFIG_DIR'];
-      const pathVal = t.env['PATH'];
-      if (typeof pathVal === 'string' && pathVal.includes('/home/vscode/.grok/bin')) {
-        delete t.env['PATH'];
-      }
-    }
+  const isolate = opts.isolate !== false;
+  if (isolate) {
+    t = isolateHomeMounts(t, opts.cwd ?? process.cwd());
   }
   const dc: Devcontainer = {
     name: t.name ?? projectName,
@@ -191,6 +168,7 @@ export function buildDevcontainer(
   dc.metadata = {
     'buckle.template': t.name ?? projectName,
     'buckle.version': t.version,
+    'buckle.isolate': isolate,
     ...(t.metadata ? { 'buckle.origin': t.metadata.origin } : {}),
   };
 
@@ -203,7 +181,7 @@ export function buildDevcontainer(
  */
 export function serializeDevcontainer(dc: Devcontainer): string {
   const banner =
-    '// Generated by buckle <https://github.com/buckle-dev/buckle>. Edit your template, not this file.\n';
+    '// Generated by buckle <https://github.com/entropyvortex/buckle>. Edit your template, not this file.\n';
   return banner + JSON.stringify(sortKeys(dc), null, 2) + '\n';
 }
 
diff --git a/src/generators/writer.ts b/src/generators/writer.ts
index 0b96381..4538809 100644
--- a/src/generators/writer.ts
+++ b/src/generators/writer.ts
@@ -1,7 +1,8 @@
 import { join } from 'node:path';
 
+import { isolatedMountSource } from '../templates/isolate.js';
 import type { Template } from '../templates/schema.js';
-import { exists, readText, writeTextAtomic } from '../util/fs.js';
+import { ensureDir, exists, readText, writeTextAtomic } from '../util/fs.js';
 import { renderCompose } from './compose.js';
 import { buildDevcontainer, serializeDevcontainer } from './devcontainer.js';
 import { renderDockerfile } from './dockerfile.js';
@@ -18,7 +19,7 @@ export interface RenderOptions {
   projectName: string;
   /** Default base image when generating a fresh Dockerfile. */
   defaultBaseImage?: string;
-  /** Isolation flag: drop host home mounts (and related env) for first-creation troubleshooting. */
+  /** Isolation flag: remap AI home mounts onto per-workspace state (default true). */
   isolate?: boolean;
 }
 
@@ -30,8 +31,15 @@ export async function plan(t: Template, opts: RenderOptions): Promise<RenderPlan
   const dcDir = join(opts.cwd, '.devcontainer');
   const files: RenderPlan['files'] = [];
 
+  const isolate = opts.isolate !== false;
+  if (isolate) {
+    await ensureDir(isolatedMountSource(opts.cwd, 'claude'));
+    await ensureDir(isolatedMountSource(opts.cwd, 'grok'));
+  }
+
   const dc = buildDevcontainer(t, opts.projectName, {
-    ...(opts.isolate ? { isolate: true } : {}),
+    isolate,
+    cwd: opts.cwd,
   });
   const dcJson = serializeDevcontainer(dc);
   const dcPath = join(dcDir, 'devcontainer.json');
diff --git a/src/templates/ai.ts b/src/templates/ai.ts
new file mode 100644
index 0000000..0b8c2cb
--- /dev/null
+++ b/src/templates/ai.ts
@@ -0,0 +1,8 @@
+/** Built-in templates that ship both Claude Code and Grok Build. */
+export const DUAL_AGENT_TEMPLATES = ['ai-native', 'claude-corp'] as const;
+
+export type DualAgentTemplate = (typeof DUAL_AGENT_TEMPLATES)[number];
+
+export function isDualAgentTemplate(name: string): boolean {
+  return (DUAL_AGENT_TEMPLATES as readonly string[]).includes(name);
+}
diff --git a/src/templates/autodetect.ts b/src/templates/autodetect.ts
index 5c6c0fc..d897562 100644
--- a/src/templates/autodetect.ts
+++ b/src/templates/autodetect.ts
@@ -150,7 +150,9 @@ export async function detectProject(cwd: string): Promise<AutoDetectResult> {
   let suggestions: string[];
   let polyglot = false;
   if (!top) {
-    suggestions = ['ubuntu-base'];
+    // Empty / unknown projects: surface the dual-agent template next to the blank base
+    // so the AI-native path is visible on first contact.
+    suggestions = ['ai-native', 'ubuntu-base'];
   } else if (!second) {
     suggestions = [top.template];
   } else if (top.score - second.score >= 2) {
diff --git a/src/templates/isolate.ts b/src/templates/isolate.ts
new file mode 100644
index 0000000..eeb0287
--- /dev/null
+++ b/src/templates/isolate.ts
@@ -0,0 +1,67 @@
+import { createHash } from 'node:crypto';
+import { basename, join } from 'node:path';
+
+import { slugOrFallback } from '../util/slug.js';
+import { dataHome } from '../util/paths.js';
+import type { Template } from './schema.js';
+
+/** Agent config dirs remapped to per-workspace host paths when isolation is on. */
+export const AI_HOME_TARGETS: Readonly<Record<string, 'claude' | 'grok'>> = {
+  '/home/vscode/.claude': 'claude',
+  '/home/vscode/.grok': 'grok',
+};
+
+/** Host git identity — kept even in isolate mode (not skills/config). */
+export const GITCONFIG_TARGET = '/home/vscode/.gitconfig';
+
+export type IsolatedKind = 'claude' | 'grok';
+
+/**
+ * Stable per-workspace directory under XDG data home.
+ * Basename + path hash so two checkouts named "app" do not collide.
+ */
+export function workspaceStateId(cwd: string): string {
+  const base = slugOrFallback(basename(cwd), 'workspace', 24);
+  const hash = createHash('sha256').update(cwd).digest('hex').slice(0, 8);
+  return `${base}-${hash}`;
+}
+
+export function workspaceStateRoot(): string {
+  if (process.env['BUCKLE_STATE_DIR'] && process.env['BUCKLE_STATE_DIR'].length > 0) {
+    return process.env['BUCKLE_STATE_DIR'];
+  }
+  return join(dataHome(), 'buckle', 'workspaces');
+}
+
+export function workspaceStateDir(cwd: string): string {
+  return join(workspaceStateRoot(), workspaceStateId(cwd));
+}
+
+export function isolatedMountSource(cwd: string, kind: IsolatedKind): string {
+  return join(workspaceStateDir(cwd), kind);
+}
+
+/**
+ * Rewrite AI home bind-mounts so each workspace gets its own skills/config
+ * instead of sharing the developer's ~/.claude and ~/.grok.
+ *
+ * gitconfig stays on the host (identity, not agent state).
+ */
+export function isolateHomeMounts(t: Template, cwd: string): Template {
+  if (!t.mounts || t.mounts.length === 0) return t;
+  const mounts = t.mounts.map((m) => {
+    const kind = AI_HOME_TARGETS[m.target];
+    if (!kind) return m;
+    return { ...m, source: isolatedMountSource(cwd, kind), type: 'bind' as const };
+  });
+  return { ...t, mounts };
+}
+
+/** Drop well-known host-home mounts entirely (legacy `--isolate` strip). Kept for tests. */
+export function stripHomeMounts(t: Template): Template {
+  if (!t.mounts || t.mounts.length === 0) return t;
+  const drop = new Set([...Object.keys(AI_HOME_TARGETS), GITCONFIG_TARGET]);
+  const filtered = t.mounts.filter((m) => !drop.has(m.target));
+  if (filtered.length === t.mounts.length) return t;
+  return { ...t, mounts: filtered };
+}
diff --git a/src/templates/resolver.ts b/src/templates/resolver.ts
index 72d24ae..417ead8 100644
--- a/src/templates/resolver.ts
+++ b/src/templates/resolver.ts
@@ -1,6 +1,7 @@
 import { createHash } from 'node:crypto';
 
 import { BuckleError, ErrorCode } from '../util/errors.js';
+import { stableStringify } from '../util/stable-json.js';
 import { findTemplate, type CatalogOptions, type TemplateRecord } from './loader.js';
 import { TemplateSchema, validateSourceMutex, type Template } from './schema.js';
 
@@ -119,15 +120,6 @@ function stripExtends(t: Template): Template {
   return rest as Template;
 }
 
-/** Stable JSON serializer for hashing (sorted keys, no formatting). */
-function stableStringify(value: unknown): string {
-  if (value === null || typeof value !== 'object') return JSON.stringify(value);
-  if (Array.isArray(value)) return `[${value.map(stableStringify).join(',')}]`;
-  const obj = value as Record<string, unknown>;
-  const keys = Object.keys(obj).sort();
-  return `{${keys.map((k) => `${JSON.stringify(k)}:${stableStringify(obj[k])}`).join(',')}}`;
-}
-
 export function templateHash(t: Template): string {
   return createHash('sha256').update(stableStringify(t)).digest('hex');
 }
diff --git a/src/templates/trust.ts b/src/templates/trust.ts
index ac92ab3..49aca8a 100644
--- a/src/templates/trust.ts
+++ b/src/templates/trust.ts
@@ -2,6 +2,7 @@ import { createHash } from 'node:crypto';
 
 import { exists, readTextOrUndefined, writeTextAtomic } from '../util/fs.js';
 import { bucklePaths } from '../util/paths.js';
+import { stableStringify } from '../util/stable-json.js';
 import type { Template } from './schema.js';
 
 export interface TrustEntry {
@@ -44,7 +45,7 @@ export function hookSurfaceHash(t: Template): string {
     nativeFeatures: t.nativeFeatures ?? null,
     customizations: t.customizations ?? null,
   };
-  return createHash('sha256').update(JSON.stringify(surface)).digest('hex');
+  return createHash('sha256').update(stableStringify(surface)).digest('hex');
 }
 
 export interface TrustDecision {
diff --git a/src/tui/StatusPanel.tsx b/src/tui/StatusPanel.tsx
index f52c511..5481bb7 100644
--- a/src/tui/StatusPanel.tsx
+++ b/src/tui/StatusPanel.tsx
@@ -1,10 +1,13 @@
-import React, { useCallback, useEffect, useState } from 'react';
+import React, { useCallback, useEffect, useMemo, useState } from 'react';
 import { Box, Text, useApp, useInput } from 'ink';
+import SelectInput from 'ink-select-input';
 import Spinner from 'ink-spinner';
 
 import type { ContainerInfo, Status } from '../docker/inspect.js';
+import { isDualAgentTemplate } from '../templates/ai.js';
+import { listCatalog } from '../templates/loader.js';
 import { Logo } from './components/Logo.js';
-import { getDriver, type TuiServices } from './dependencies.js';
+import { getContext, getDriver, getRenderTemplate, type TuiServices } from './dependencies.js';
 
 interface StatusPanelProps {
   cwd: string;
@@ -21,11 +24,15 @@ interface StatusState {
   flash?: string;
 }
 
-const KEY_HINTS = '↑ rebuild • ▶ start (b) bash • ⏹ stop (s) • ⚙ reconfigure (c) • ❌ down (d) • q to quit';
+type Mode = 'status' | 'reconfigure';
+
+const KEY_HINTS = 'r rebuild · u up · s/d down · b bash · c reconfigure · q quit';
 
 export function StatusPanel({ cwd, services }: StatusPanelProps): React.ReactElement {
   const { exit } = useApp();
   const [state, setState] = useState<StatusState>({ status: 'absent', name: '', loading: true });
+  const [mode, setMode] = useState<Mode>('status');
+  const [templates, setTemplates] = useState<{ name: string; description?: string; origin: string }[]>([]);
 
   const refresh = useCallback(async () => {
     setState((s) => ({ ...s, loading: true }));
@@ -49,10 +56,10 @@ export function StatusPanel({ cwd, services }: StatusPanelProps): React.ReactEle
     const fromEnv = Number(process.env['BUCKLE_STATUS_REFRESH'] ?? '');
     const ms = Number.isFinite(fromEnv) && fromEnv >= 1000 ? fromEnv : 5000;
     const id = setInterval(() => {
-      void refresh();
+      if (mode === 'status') void refresh();
     }, ms);
     return () => clearInterval(id);
-  }, [refresh]);
+  }, [refresh, mode]);
 
   const action = useCallback(
     async (op: 'rebuild' | 'up' | 'down' | 'bash') => {
@@ -70,7 +77,6 @@ export function StatusPanel({ cwd, services }: StatusPanelProps): React.ReactEle
           await driver.up({ rebuild: true, quiet: true });
           setState((s) => ({ ...s, flash: 'rebuild done' }));
         } else if (op === 'bash') {
-          // Detach the TUI before bashing in.
           exit();
           process.nextTick(async () => {
             await driver.bash({});
@@ -86,15 +92,69 @@ export function StatusPanel({ cwd, services }: StatusPanelProps): React.ReactEle
     [cwd, exit, refresh, services],
   );
 
-  useInput((input, _key) => {
+  const startReconfigure = useCallback(async () => {
+    try {
+      const catalog = services?.listCatalog ?? listCatalog;
+      const cat = await catalog();
+      setTemplates(cat);
+      setMode('reconfigure');
+    } catch (e) {
+      setState((s) => ({ ...s, error: (e as Error).message }));
+    }
+  }, [services]);
+
+  const applyReconfigure = useCallback(
+    async (templateName: string) => {
+      setMode('status');
+      setState((s) => ({ ...s, loading: true, flash: `reconfiguring ${templateName}…` }));
+      try {
+        const origin = templates.find((t) => t.name === templateName)?.origin;
+        const trust = origin === 'builtin';
+        const ctx = getContext(services, { yes: true, trust });
+        const render = getRenderTemplate(services);
+        await render(ctx, { templateName, features: ctx.flags.feature ?? [], trust, yes: true });
+        setState((s) => ({ ...s, flash: `rewrote .devcontainer/ from ${templateName}` }));
+        await refresh();
+      } catch (e) {
+        setState((s) => ({ ...s, loading: false, error: (e as Error).message }));
+      }
+    },
+    [refresh, services, templates],
+  );
+
+  useInput((input, key) => {
+    if (mode === 'reconfigure') {
+      if (input === 'q' || key.escape) setMode('status');
+      return;
+    }
     if (input === 'q') exit();
     else if (input === 'r') void action('rebuild');
-    else if (input === 's') void action('down');
+    else if (input === 's' || input === 'd') void action('down');
     else if (input === 'b') void action('bash');
     else if (input === 'u') void action('up');
-    else if (input === 'd') void action('down');
+    else if (input === 'c') void startReconfigure();
   });
 
+  const reconfigureItems = useMemo(
+    () =>
+      templates.map((t) => ({
+        label: `${t.name.padEnd(16)} ${t.description ?? ''}${isDualAgentTemplate(t.name) ? ' · dual-agent' : ''}`,
+        value: t.name,
+      })),
+    [templates],
+  );
+
+  if (mode === 'reconfigure') {
+    return (
+      <Box flexDirection="column">
+        <Logo />
+        <Text>reconfigure .devcontainer/ in {cwd}</Text>
+        <Text dimColor>pick a template · esc/q to cancel</Text>
+        <SelectInput items={reconfigureItems} onSelect={(item) => void applyReconfigure(item.value)} />
+      </Box>
+    );
+  }
+
   return (
     <Box flexDirection="column">
       <Logo />
@@ -137,7 +197,7 @@ export function StatusPanel({ cwd, services }: StatusPanelProps): React.ReactEle
         </Box>
       )}
       <Box marginTop={1}>
-        <Text dimColor>r rebuild • u up • s/d down • b bash • q quit</Text>
+        <Text dimColor>{KEY_HINTS}</Text>
       </Box>
     </Box>
   );
diff --git a/src/tui/Wizard.tsx b/src/tui/Wizard.tsx
index 77e8d81..ed8000a 100644
--- a/src/tui/Wizard.tsx
+++ b/src/tui/Wizard.tsx
@@ -4,8 +4,10 @@ import SelectInput from 'ink-select-input';
 import Spinner from 'ink-spinner';
 
 import { detectProject, type AutoDetectResult } from '../templates/autodetect.js';
+import { isDualAgentTemplate } from '../templates/ai.js';
 import { listFeatures } from '../features/catalog.js';
 import { listCatalog } from '../templates/loader.js';
+import { loadConfigSync } from '../util/config.js';
 import { Logo } from './components/Logo.js';
 import { getContext, getDriver, getRenderTemplate, type TuiServices } from './dependencies.js';
 
@@ -28,7 +30,9 @@ export function Wizard({ cwd, services, initialIntent }: WizardProps): React.Rea
   const { exit } = useApp();
   const [step, setStep] = useState<Step>('detect');
   const [detection, setDetection] = useState<AutoDetectResult | null>(null);
-  const [templates, setTemplates] = useState<{ name: string; description?: string }[]>([]);
+  const [templates, setTemplates] = useState<
+    { name: string; description?: string; origin: 'builtin' | 'user' | 'installed' }[]
+  >([]);
   const [chosenTemplate, setChosenTemplate] = useState<string>('');
   const [chosenFeatures, setChosenFeatures] = useState<string[]>([]);
   const [featureCursor, setFeatureCursor] = useState<number>(0);
@@ -42,9 +46,15 @@ export function Wizard({ cwd, services, initialIntent }: WizardProps): React.Rea
     let cancelled = false;
     (async () => {
       try {
-        const det = await detectProject(cwd);
-        const cat = await listCatalog();
+        const detect = services?.detectProject ?? detectProject;
+        const catalog = services?.listCatalog ?? listCatalog;
+        const det = await detect(cwd);
+        const cat = await catalog();
         if (cancelled) return;
+        const cfg = loadConfigSync();
+        if (cfg.defaultTemplate && !det.suggestions.includes(cfg.defaultTemplate)) {
+          det.suggestions = [cfg.defaultTemplate, ...det.suggestions];
+        }
         setDetection(det);
         setTemplates(cat);
         setStep('pick-template');
@@ -56,7 +66,7 @@ export function Wizard({ cwd, services, initialIntent }: WizardProps): React.Rea
     return () => {
       cancelled = true;
     };
-  }, [step, cwd]);
+  }, [step, cwd, services]);
 
   // Step: pick-features (custom keyboard).
   useInput((input, key) => {
@@ -93,12 +103,14 @@ export function Wizard({ cwd, services, initialIntent }: WizardProps): React.Rea
     let cancelled = false;
     (async () => {
       try {
-        const ctx = getContext(services, { yes: true, trust: true, feature: chosenFeatures });
+        const origin = templates.find((t) => t.name === chosenTemplate)?.origin;
+        const trustBuiltin = origin === 'builtin';
+        const ctx = getContext(services, { yes: true, trust: trustBuiltin, feature: chosenFeatures });
         const render = getRenderTemplate(services);
         const out = await render(ctx, {
           templateName: chosenTemplate,
           features: chosenFeatures,
-          trust: true,
+          trust: trustBuiltin,
           yes: true,
         });
         if (cancelled) return;
@@ -199,7 +211,7 @@ export function Wizard({ cwd, services, initialIntent }: WizardProps): React.Rea
 
 interface PickTemplateProps {
   detection: AutoDetectResult;
-  templates: { name: string; description?: string }[];
+  templates: { name: string; description?: string; origin: 'builtin' | 'user' | 'installed' }[];
   onPick: (name: string) => void;
 }
 
@@ -208,12 +220,17 @@ function PickTemplate({ detection, templates, onPick }: PickTemplateProps): Reac
     // Show suggestions first, then alphabetical rest.
     const head = detection.suggestions
       .map((n) => templates.find((t) => t.name === n))
-      .filter((x): x is { name: string; description?: string } => Boolean(x));
+      .filter(
+        (x): x is { name: string; description?: string; origin: 'builtin' | 'user' | 'installed' } => Boolean(x),
+      );
     const rest = templates.filter((t) => !detection.suggestions.includes(t.name));
-    return [...head, ...rest].map((t) => ({
-      label: `${t.name.padEnd(16)} ${t.description ?? ''}`,
-      value: t.name,
-    }));
+    return [...head, ...rest].map((t) => {
+      const dual = isDualAgentTemplate(t.name) ? ' · dual-agent' : '';
+      return {
+        label: `${t.name.padEnd(16)} ${t.description ?? ''}${dual}`,
+        value: t.name,
+      };
+    });
   }, [detection, templates]);
 
   return (
diff --git a/src/tui/dependencies.ts b/src/tui/dependencies.ts
index bf76696..63f9ab4 100644
--- a/src/tui/dependencies.ts
+++ b/src/tui/dependencies.ts
@@ -3,6 +3,9 @@ import { makeContext } from '../cli/context.js';
 import { Driver, type DriverOptions } from '../docker/driver.js';
 import type { RenderArgs, RenderOutcome } from '../cli/render.js';
 import { renderTemplate } from '../cli/render.js';
+import type { AutoDetectResult } from '../templates/autodetect.js';
+import { detectProject } from '../templates/autodetect.js';
+import { listCatalog } from '../templates/loader.js';
 
 /**
  * Lightweight dependency bag for the TUI components.
@@ -30,6 +33,8 @@ export interface TuiServices {
   makeContext: TuiContextFactory;
   createDriver: DriverFactory;
   renderTemplate: TuiRenderTemplate;
+  detectProject?: (cwd: string) => Promise<AutoDetectResult>;
+  listCatalog?: typeof listCatalog;
 }
 
 /**
@@ -47,6 +52,8 @@ export function createDefaultTuiServices(): TuiServices {
       }),
 
     renderTemplate: (ctx, args) => renderTemplate(ctx, args),
+    detectProject,
+    listCatalog,
   };
 }
 
diff --git a/src/util/config.ts b/src/util/config.ts
new file mode 100644
index 0000000..19be497
--- /dev/null
+++ b/src/util/config.ts
@@ -0,0 +1,62 @@
+import { readFileSync } from 'node:fs';
+import { parse as parseYaml } from 'yaml';
+
+import { readTextOrUndefined } from './fs.js';
+import { bucklePaths } from './paths.js';
+
+export interface BuckleConfig {
+  /** $EDITOR override. Falls back to $VISUAL → $EDITOR → vi. */
+  editor?: string;
+  /** Wizard suggestion when autodetect cannot decide. */
+  defaultTemplate?: string;
+  /**
+   * When false, bind-mount host ~/.claude and ~/.grok (legacy share-home).
+   * Default true = per-workspace isolated agent state.
+   */
+  isolate?: boolean;
+}
+
+const EMPTY: BuckleConfig = {};
+
+function asString(v: unknown): string | undefined {
+  return typeof v === 'string' && v.length > 0 ? v : undefined;
+}
+
+function asBool(v: unknown): boolean | undefined {
+  return typeof v === 'boolean' ? v : undefined;
+}
+
+export function parseConfig(text: string): BuckleConfig {
+  let parsed: unknown;
+  try {
+    parsed = parseYaml(text);
+  } catch {
+    return EMPTY;
+  }
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return EMPTY;
+  const rec = parsed as Record<string, unknown>;
+  const out: BuckleConfig = {};
+  const editor = asString(rec['editor']);
+  if (editor !== undefined) out.editor = editor;
+  const defaultTemplate = asString(rec['defaultTemplate']);
+  if (defaultTemplate !== undefined) out.defaultTemplate = defaultTemplate;
+  const isolate = asBool(rec['isolate']);
+  if (isolate !== undefined) out.isolate = isolate;
+  return out;
+}
+
+export function loadConfigSync(file?: string): BuckleConfig {
+  const path = file ?? bucklePaths().configFile;
+  try {
+    return parseConfig(readFileSync(path, 'utf8'));
+  } catch {
+    return EMPTY;
+  }
+}
+
+export async function loadConfig(file?: string): Promise<BuckleConfig> {
+  const path = file ?? bucklePaths().configFile;
+  const text = await readTextOrUndefined(path);
+  if (!text) return EMPTY;
+  return parseConfig(text);
+}
diff --git a/src/util/prompt.ts b/src/util/prompt.ts
new file mode 100644
index 0000000..7a50b37
--- /dev/null
+++ b/src/util/prompt.ts
@@ -0,0 +1,15 @@
+import * as readline from 'node:readline';
+
+/** Ask a yes/no question on stderr so --json stdout stays clean. Defaults to no. */
+export async function promptYesNo(question: string): Promise<boolean> {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
+  try {
+    const ans = await new Promise<string>((resolve) => {
+      rl.question(question, resolve);
+    });
+    const normalized = ans.trim().toLowerCase();
+    return normalized === 'y' || normalized === 'yes';
+  } finally {
+    rl.close();
+  }
+}
diff --git a/src/util/stable-json.ts b/src/util/stable-json.ts
new file mode 100644
index 0000000..c3e23f5
--- /dev/null
+++ b/src/util/stable-json.ts
@@ -0,0 +1,8 @@
+/** Canonical JSON for hashing: sorted object keys, no whitespace. */
+export function stableStringify(value: unknown): string {
+  if (value === null || typeof value !== 'object') return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(stableStringify).join(',')}]`;
+  const obj = value as Record<string, unknown>;
+  const keys = Object.keys(obj).sort();
+  return `{${keys.map((k) => `${JSON.stringify(k)}:${stableStringify(obj[k])}`).join(',')}}`;
+}
diff --git a/src/util/version.ts b/src/util/version.ts
new file mode 100644
index 0000000..85bd4ca
--- /dev/null
+++ b/src/util/version.ts
@@ -0,0 +1,23 @@
+import { createRequire } from 'node:module';
+
+/**
+ * Resolve the published package version without baking it into source.
+ *
+ * `import.meta.url` points at `src/util/version.ts` under vitest and at
+ * `dist/index.js` after tsup bundles; we probe both relative layouts and
+ * require the name to match so a stray nearby package.json cannot win.
+ */
+export function packageVersion(): string {
+  const req = createRequire(import.meta.url);
+  for (const rel of ['../../package.json', '../package.json', './package.json']) {
+    try {
+      const pkg = req(rel) as { name?: string; version?: string };
+      if (pkg.name === 'buckle-cli' && typeof pkg.version === 'string' && pkg.version.length > 0) {
+        return pkg.version;
+      }
+    } catch {
+      continue;
+    }
+  }
+  return '0.0.0-dev';
+}
diff --git a/test/unit/autodetect.test.ts b/test/unit/autodetect.test.ts
index db3ec25..799ad5d 100644
--- a/test/unit/autodetect.test.ts
+++ b/test/unit/autodetect.test.ts
@@ -17,10 +17,10 @@ async function fixture(files: Record<string, string>): Promise<string> {
 }
 
 describe('detectProject', () => {
-  it('falls back to ubuntu-base in an empty directory', async () => {
+  it('falls back to ai-native then ubuntu-base in an empty directory', async () => {
     const dir = await mkdtemp(join(tmpdir(), 'buckle-empty-'));
     const r = await detectProject(dir);
-    expect(r.suggestions[0]).toBe('ubuntu-base');
+    expect(r.suggestions).toEqual(['ai-native', 'ubuntu-base']);
   });
 
   it('detects node from package-lock.json', async () => {
diff --git a/test/unit/cmd-view.test.ts b/test/unit/cmd-view.test.ts
new file mode 100644
index 0000000..db87730
--- /dev/null
+++ b/test/unit/cmd-view.test.ts
@@ -0,0 +1,45 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { runView } from '../../src/cli/commands/view.js';
+import { makeContext } from '../../src/cli/context.js';
+
+beforeEach(() => {
+  vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+});
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+describe('runView', () => {
+  it('prints isolated devcontainer json for a builtin', async () => {
+    const ctx = makeContext({}, '/tmp/view-proj');
+    const code = await runView(ctx, { template: 'node' });
+    expect(code).toBe(0);
+    const out = (process.stdout.write as unknown as { mock: { calls: [string][] } }).mock.calls
+      .flat()
+      .join('');
+    expect(out).toContain('Generated by buckle');
+    expect(out).toContain('"buckle.isolate": true');
+  });
+
+  it('emits json envelope and applies --feature overlay', async () => {
+    const ctx = makeContext({ json: true, feature: ['dod'] }, '/tmp/view-proj');
+    const code = await runView(ctx, { template: 'ubuntu-base' });
+    expect(code).toBe(0);
+    const out = (process.stdout.write as unknown as { mock: { calls: [string][] } }).mock.calls
+      .flat()
+      .join('');
+    expect(out).toMatch(/"ok":\s*true/);
+    expect(out).toContain('docker.sock');
+  });
+
+  it('share-home keeps host grok mounts', async () => {
+    const ctx = makeContext({ isolate: false, shareHome: true }, '/tmp/view-proj');
+    await runView(ctx, { template: 'claude-corp' });
+    const out = (process.stdout.write as unknown as { mock: { calls: [string][] } }).mock.calls
+      .flat()
+      .join('');
+    expect(out).toContain('${localEnv:HOME}/.grok');
+    expect(out).toContain('"buckle.isolate": false');
+  });
+});
diff --git a/test/unit/config.test.ts b/test/unit/config.test.ts
new file mode 100644
index 0000000..1c9322e
--- /dev/null
+++ b/test/unit/config.test.ts
@@ -0,0 +1,53 @@
+import { mkdir, mkdtemp, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { loadConfig, parseConfig } from '../../src/util/config.js';
+import * as paths from '../../src/util/paths.js';
+
+describe('parseConfig', () => {
+  it('reads known keys', () => {
+    const c = parseConfig('editor: code\ndefaultTemplate: node\nisolate: false\n');
+    expect(c.editor).toBe('code');
+    expect(c.defaultTemplate).toBe('node');
+    expect(c.isolate).toBe(false);
+  });
+
+  it('returns empty on garbage', () => {
+    expect(parseConfig(':::')).toEqual({});
+    expect(parseConfig('[]')).toEqual({});
+  });
+});
+
+describe('loadConfig', () => {
+  let tmp: string;
+
+  beforeEach(async () => {
+    tmp = await mkdtemp(join(tmpdir(), 'buckle-cfg-'));
+    vi.spyOn(paths, 'bucklePaths').mockReturnValue({
+      configRoot: tmp,
+      templatesRoot: tmp,
+      installedRoot: join(tmp, '_installed'),
+      trustStore: join(tmp, 'trust.json'),
+      configFile: join(tmp, 'config.yaml'),
+    });
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('returns empty when missing', async () => {
+    expect(await loadConfig()).toEqual({});
+  });
+
+  it('loads a written file', async () => {
+    await mkdir(tmp, { recursive: true });
+    await writeFile(join(tmp, 'config.yaml'), 'isolate: false\neditor: hx\n');
+    const c = await loadConfig();
+    expect(c.isolate).toBe(false);
+    expect(c.editor).toBe('hx');
+  });
+});
diff --git a/test/unit/features.test.ts b/test/unit/features.test.ts
index 347c226..8fc3bb5 100644
--- a/test/unit/features.test.ts
+++ b/test/unit/features.test.ts
@@ -114,7 +114,7 @@ describe('applyFeatures', () => {
 
   it('throws on unknown feature', () => {
     const t: Template = { version: '0.1.0', image: 'foo:1', features: ['definitely-not-real'] };
-    expect(() => applyFeatures(t)).toThrow();
+    expect(() => applyFeatures(t)).toThrow(/unknown feature/);
   });
 
   it('returns input unchanged when no features', () => {
diff --git a/test/unit/install-parse.test.ts b/test/unit/install-parse.test.ts
index 4f92725..14d1294 100644
--- a/test/unit/install-parse.test.ts
+++ b/test/unit/install-parse.test.ts
@@ -40,6 +40,10 @@ describe('parseOrigin', () => {
     expect(() => parseOrigin('something-bad')).toThrow();
   });
 
+  it('rejects plaintext http origins', () => {
+    expect(() => parseOrigin('http://example.com/x.git')).toThrow(/plaintext http/);
+  });
+
   it('hashKey is stable across calls and varies with ref', () => {
     const a = parseOrigin('gh:foo/bar#v1').hashKey;
     const b = parseOrigin('gh:foo/bar#v1').hashKey;
diff --git a/test/unit/isolate.test.ts b/test/unit/isolate.test.ts
new file mode 100644
index 0000000..3d714ca
--- /dev/null
+++ b/test/unit/isolate.test.ts
@@ -0,0 +1,115 @@
+import { mkdtemp } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { afterEach, describe, expect, it } from 'vitest';
+
+import { buildDevcontainer } from '../../src/generators/devcontainer.js';
+import {
+  isolateHomeMounts,
+  isolatedMountSource,
+  stripHomeMounts,
+  workspaceStateId,
+  workspaceStateRoot,
+} from '../../src/templates/isolate.js';
+import type { Template } from '../../src/templates/schema.js';
+
+describe('isolateHomeMounts', () => {
+  const prev = process.env['BUCKLE_STATE_DIR'];
+
+  afterEach(() => {
+    if (prev === undefined) delete process.env['BUCKLE_STATE_DIR'];
+    else process.env['BUCKLE_STATE_DIR'] = prev;
+  });
+
+  it('remaps claude and grok onto per-workspace paths and keeps gitconfig', async () => {
+    const cwd = await mkdtemp(join(tmpdir(), 'buckle-iso-'));
+    process.env['BUCKLE_STATE_DIR'] = await mkdtemp(join(tmpdir(), 'buckle-state-'));
+    const t: Template = {
+      version: '0.1.0',
+      image: 'foo:1',
+      mounts: [
+        { source: '${localEnv:HOME}/.claude', target: '/home/vscode/.claude', type: 'bind' },
+        { source: '${localEnv:HOME}/.grok', target: '/home/vscode/.grok', type: 'bind' },
+        { source: '${localEnv:HOME}/.gitconfig', target: '/home/vscode/.gitconfig', type: 'bind', readOnly: true },
+      ],
+    };
+    const out = isolateHomeMounts(t, cwd);
+    expect(out.mounts?.find((m) => m.target === '/home/vscode/.claude')?.source).toBe(
+      isolatedMountSource(cwd, 'claude'),
+    );
+    expect(out.mounts?.find((m) => m.target === '/home/vscode/.grok')?.source).toBe(
+      isolatedMountSource(cwd, 'grok'),
+    );
+    expect(out.mounts?.find((m) => m.target === '/home/vscode/.gitconfig')?.source).toBe(
+      '${localEnv:HOME}/.gitconfig',
+    );
+  });
+
+  it('workspace ids differ for two directories with the same basename', async () => {
+    const a = await mkdtemp(join(tmpdir(), 'app-'));
+    const b = await mkdtemp(join(tmpdir(), 'app-'));
+    expect(workspaceStateId(a)).not.toBe(workspaceStateId(b));
+  });
+
+  it('returns the template unchanged when there are no mounts', () => {
+    const t: Template = { version: '0.1.0', image: 'foo:1' };
+    expect(isolateHomeMounts(t, '/tmp/x')).toBe(t);
+    expect(stripHomeMounts(t)).toBe(t);
+  });
+
+  it('stripHomeMounts drops AI and gitconfig binds and leaves others', () => {
+    const t: Template = {
+      version: '0.1.0',
+      image: 'foo:1',
+      mounts: [
+        { source: '${localEnv:HOME}/.claude', target: '/home/vscode/.claude', type: 'bind' },
+        { source: '${localEnv:HOME}/.gitconfig', target: '/home/vscode/.gitconfig', type: 'bind' },
+        { source: '/var/run/docker.sock', target: '/var/run/docker.sock', type: 'bind' },
+      ],
+    };
+    const out = stripHomeMounts(t);
+    expect(out.mounts).toEqual([
+      { source: '/var/run/docker.sock', target: '/var/run/docker.sock', type: 'bind' },
+    ]);
+  });
+
+  it('stripHomeMounts is a no-op when nothing matches', () => {
+    const t: Template = {
+      version: '0.1.0',
+      image: 'foo:1',
+      mounts: [{ source: '/a', target: '/b', type: 'bind' }],
+    };
+    expect(stripHomeMounts(t)).toBe(t);
+  });
+
+  it('workspaceStateRoot falls back to XDG data home', () => {
+    const prev = process.env['BUCKLE_STATE_DIR'];
+    delete process.env['BUCKLE_STATE_DIR'];
+    try {
+      expect(workspaceStateRoot().replace(/\\/g, '/')).toMatch(/buckle\/workspaces$/);
+    } finally {
+      if (prev === undefined) delete process.env['BUCKLE_STATE_DIR'];
+      else process.env['BUCKLE_STATE_DIR'] = prev;
+    }
+  });
+});
+
+describe('buildDevcontainer isolate default', () => {
+  it('remaps grok mounts by default', async () => {
+    const cwd = await mkdtemp(join(tmpdir(), 'buckle-iso-dc-'));
+    const t: Template = {
+      version: '0.1.0',
+      image: 'foo:1',
+      features: ['grok'],
+    };
+    const isolated = buildDevcontainer(t, 'proj', { cwd });
+    expect(isolated.metadata?.['buckle.isolate']).toBe(true);
+    expect(isolated.mounts?.some((m) => m.includes(isolatedMountSource(cwd, 'grok')))).toBe(true);
+    expect(isolated.mounts?.some((m) => m.includes('${localEnv:HOME}/.grok'))).toBe(false);
+
+    const shared = buildDevcontainer(t, 'proj', { isolate: false, cwd });
+    expect(shared.metadata?.['buckle.isolate']).toBe(false);
+    expect(shared.mounts?.some((m) => m.includes('${localEnv:HOME}/.grok'))).toBe(true);
+  });
+});
diff --git a/test/unit/parse-rewrite.test.ts b/test/unit/parse-rewrite.test.ts
index bd32ab1..4a2ec3b 100644
--- a/test/unit/parse-rewrite.test.ts
+++ b/test/unit/parse-rewrite.test.ts
@@ -36,14 +36,20 @@ describe('dispatch — template rewrite path', () => {
   });
 
   it('handles `--version`', async () => {
-    // commander's --version exits the process by default; we run it via dispatch and expect
-    // it to not throw and to mark non-tui.
+    // commander's --version writes the package version then exits; swallow the exit.
+    const chunks: string[] = [];
+    vi.spyOn(process.stdout, 'write').mockImplementation(((s: string | Uint8Array) => {
+      chunks.push(typeof s === 'string' ? s : String(s));
+      return true;
+    }) as typeof process.stdout.write);
     const exitSpy = vi.spyOn(process, 'exit').mockImplementation(((_code?: number) => {
-      // swallow
       return undefined as never;
     }) as never);
     const r = await dispatch(['node', 'buckle', '--version']);
     expect(r.tui).toBe(false);
+    const printed = chunks.join('');
+    expect(printed).toMatch(/^\d+\.\d+\.\d+/);
+    expect(printed).not.toMatch(/^0\.1\.0\b/);
     exitSpy.mockRestore();
   });
 });
diff --git a/test/unit/render-edge.test.ts b/test/unit/render-edge.test.ts
index 4228a37..93756dd 100644
--- a/test/unit/render-edge.test.ts
+++ b/test/unit/render-edge.test.ts
@@ -74,4 +74,12 @@ lifecycle:
     const r = await renderTemplate(ctx, { templateName: 'ubuntu-base', features: [], trust: true, yes: true });
     expect(r.written).toBe(true);
   });
+
+  it('preview does not write files', async () => {
+    const dir = await mkdtemp(join(tmpdir(), 'buckle-r-'));
+    const ctx = makeContext({ trust: true, yes: true, preview: true }, dir);
+    const r = await renderTemplate(ctx, { templateName: 'ubuntu-base', features: [], trust: true, yes: true });
+    expect(r.written).toBe(false);
+    expect(r.plan.files.some((f) => f.changed)).toBe(true);
+  });
 });
diff --git a/test/unit/stable-json.test.ts b/test/unit/stable-json.test.ts
new file mode 100644
index 0000000..f48de02
--- /dev/null
+++ b/test/unit/stable-json.test.ts
@@ -0,0 +1,24 @@
+import { describe, expect, it } from 'vitest';
+
+import { hookSurfaceHash } from '../../src/templates/trust.js';
+import { stableStringify } from '../../src/util/stable-json.js';
+
+describe('stableStringify', () => {
+  it('sorts object keys', () => {
+    expect(stableStringify({ b: 1, a: 2 })).toBe('{"a":2,"b":1}');
+  });
+});
+
+describe('hookSurfaceHash', () => {
+  it('is independent of object key insertion order', () => {
+    const a = hookSurfaceHash({
+      mounts: [{ source: '/a', target: '/b', type: 'bind' }],
+      runArgs: ['--init'],
+    } as never);
+    const b = hookSurfaceHash({
+      runArgs: ['--init'],
+      mounts: [{ source: '/a', target: '/b', type: 'bind' }],
+    } as never);
+    expect(a).toBe(b);
+  });
+});
diff --git a/test/unit/trust-surface.test.ts b/test/unit/trust-surface.test.ts
new file mode 100644
index 0000000..5bfd50a
--- /dev/null
+++ b/test/unit/trust-surface.test.ts
@@ -0,0 +1,28 @@
+import { describe, expect, it } from 'vitest';
+
+import { formatTrustSurface } from '../../src/cli/render.js';
+import type { Template } from '../../src/templates/schema.js';
+
+describe('formatTrustSurface', () => {
+  it('summarizes lifecycle, mounts, runArgs, and features', () => {
+    const t: Template = {
+      version: '0.1.0',
+      image: 'foo:1',
+      lifecycle: { postCreate: ['echo hi', { command: 'true', user: 'vscode' }] },
+      mounts: [{ source: '/a', target: '/b', type: 'bind' }],
+      runArgs: ['--init'],
+      features: ['gh', ['node', '20']],
+    };
+    const lines = formatTrustSurface(t);
+    expect(lines.some((l) => l.startsWith('postCreate:'))).toBe(true);
+    expect(lines.some((l) => l.includes('/a → /b'))).toBe(true);
+    expect(lines.some((l) => l.startsWith('runArgs:'))).toBe(true);
+    expect(lines.some((l) => l.includes('gh'))).toBe(true);
+  });
+
+  it('reports an empty surface', () => {
+    expect(formatTrustSurface({ version: '0.1.0', image: 'foo:1' })).toEqual([
+      '(no lifecycle, mounts, runArgs, or features)',
+    ]);
+  });
+});
diff --git a/test/unit/tui/status-panel.test.ts b/test/unit/tui/status-panel.test.ts
new file mode 100644
index 0000000..ea99d4f
--- /dev/null
+++ b/test/unit/tui/status-panel.test.ts
@@ -0,0 +1,28 @@
+import React from 'react';
+import { render } from 'ink-testing-library';
+import { describe, expect, it, vi } from 'vitest';
+
+import { StatusPanel } from '../../../src/tui/StatusPanel.js';
+import type { TuiServices } from '../../../src/tui/dependencies.js';
+import type { Driver } from '../../../src/docker/driver.js';
+
+describe('StatusPanel', () => {
+  it('shows the reconfigure keybinding', async () => {
+    const driver = {
+      status: vi.fn(async () => ({ status: 'absent' as const, name: 'buckle.tmp.unknown' })),
+    };
+
+    const services: Partial<TuiServices> = {
+      createDriver: () => driver as unknown as Driver,
+    };
+
+    const { lastFrame, unmount } = render(
+      React.createElement(StatusPanel, { cwd: '/tmp/proj', services }),
+    );
+    await new Promise((r) => setTimeout(r, 50));
+    const frame = lastFrame() ?? '';
+    expect(frame).toMatch(/reconfigure/);
+    expect(frame).toMatch(/c reconfigure/);
+    unmount();
+  });
+});
diff --git a/test/unit/tui/wizard.test.ts b/test/unit/tui/wizard.test.ts
new file mode 100644
index 0000000..1c4119b
--- /dev/null
+++ b/test/unit/tui/wizard.test.ts
@@ -0,0 +1,55 @@
+import React from 'react';
+import { render } from 'ink-testing-library';
+import { describe, expect, it, vi } from 'vitest';
+
+import { Wizard } from '../../../src/tui/Wizard.js';
+import type { TuiServices } from '../../../src/tui/dependencies.js';
+
+describe('Wizard', () => {
+  it('lists dual-agent templates from detection suggestions', async () => {
+    const services: Partial<TuiServices> = {
+      detectProject: async () => ({
+        suggestions: ['ai-native', 'ubuntu-base'],
+        scores: [],
+        polyglot: false,
+      }),
+      listCatalog: async () => [
+        {
+          name: 'ai-native',
+          description: 'Claude + Grok',
+          origin: 'builtin' as const,
+        },
+        {
+          name: 'ubuntu-base',
+          description: 'Plain Ubuntu',
+          origin: 'builtin' as const,
+        },
+      ],
+      renderTemplate: vi.fn(),
+      makeContext: () =>
+        ({
+          cwd: '/tmp',
+          flags: { isolate: true },
+          logger: {
+            info() {},
+            warn() {},
+            error() {},
+            success() {},
+            debug() {},
+            line() {},
+            raw() {},
+          },
+          config: {},
+        }) as never,
+    };
+
+    const { lastFrame, unmount } = render(
+      React.createElement(Wizard, { cwd: '/tmp/proj', services }),
+    );
+    await new Promise((r) => setTimeout(r, 50));
+    const frame = lastFrame() ?? '';
+    expect(frame).toMatch(/ai-native/);
+    expect(frame).toMatch(/dual-agent/);
+    unmount();
+  });
+});
diff --git a/test/unit/version.test.ts b/test/unit/version.test.ts
new file mode 100644
index 0000000..c4ed695
--- /dev/null
+++ b/test/unit/version.test.ts
@@ -0,0 +1,15 @@
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { describe, expect, it } from 'vitest';
+
+import { packageVersion } from '../../src/util/version.js';
+
+describe('packageVersion', () => {
+  it('matches package.json', () => {
+    const root = join(dirname(fileURLToPath(import.meta.url)), '..', '..');
+    const pkg = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8')) as { version: string };
+    expect(packageVersion()).toBe(pkg.version);
+  });
+});
diff --git a/test/unit/writer.test.ts b/test/unit/writer.test.ts
index bf70121..7626be7 100644
--- a/test/unit/writer.test.ts
+++ b/test/unit/writer.test.ts
@@ -4,7 +4,7 @@ import { join } from 'node:path';
 
 import { describe, expect, it } from 'vitest';
 
-import { applyPlan, plan, summarizePlan } from '../../src/generators/writer.js';
+import { applyPlan, plan, renderDiff, summarizePlan } from '../../src/generators/writer.js';
 import type { Template } from '../../src/templates/schema.js';
 
 describe('writer plan/apply', () => {
@@ -79,4 +79,34 @@ describe('writer plan/apply', () => {
     expect(p.warnings).toBeDefined();
     expect(p.warnings?.some((w) => w.includes('compose + dind'))).toBe(true);
   });
+
+  it('surfaces compose + dod and remoteUser mismatch warnings', async () => {
+    const dir = await mkdtemp(join(tmpdir(), 'buckle-w-'));
+    const t: Template = {
+      version: '0.1.0',
+      image: 'foo:1',
+      compose: { file: 'docker-compose.yml', service: 'app' },
+      features: ['dod'],
+      remoteUser: 'vscode',
+      containerUser: 'root',
+    };
+    const p = await plan(t, { cwd: dir, projectName: 'proj' });
+    expect(p.warnings?.some((w) => w.includes('compose + dod'))).toBe(true);
+    expect(p.warnings?.some((w) => w.includes('remoteUser'))).toBe(true);
+  });
+
+  it('renderDiff includes warnings and created files', async () => {
+    const dir = await mkdtemp(join(tmpdir(), 'buckle-w-'));
+    const t: Template = {
+      version: '0.1.0',
+      image: 'foo:1',
+      compose: { file: 'docker-compose.yml', service: 'app' },
+      features: ['dind'],
+    };
+    const p = await plan(t, { cwd: dir, projectName: 'proj' });
+    const diff = renderDiff(p);
+    expect(diff).toContain('# Warnings from buckle:');
+    expect(diff).toContain('(created)');
+    expect(diff).toContain('+ ');
+  });
 });
diff --git a/vitest.config.ts b/vitest.config.ts
index fd928c9..d8a449e 100644
--- a/vitest.config.ts
+++ b/vitest.config.ts
@@ -1,9 +1,15 @@
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
 import { defineConfig } from 'vitest/config';
 
 export default defineConfig({
   test: {
     environment: 'node',
     include: ['test/**/*.test.{ts,tsx}'],
+    env: {
+      BUCKLE_STATE_DIR: join(tmpdir(), 'buckle-test-state'),
+    },
     coverage: {
       provider: 'v8',
       reporter: ['text', 'lcov', 'html'],
@@ -27,6 +33,12 @@ export default defineConfig({
         'src/cli/commands/install.ts',
         'src/cli/commands/uninstall.ts',
         'src/cli/commands/edit.ts',
+        'src/cli/commands/logs.ts',
+        'src/cli/commands/restart.ts',
+        // Commander program tree; dispatch is covered via command tests.
+        'src/cli/parse.ts',
+        // Readline TTY prompt; exercised interactively, stubbed in render tests.
+        'src/util/prompt.ts',
       ],
       thresholds: {
         lines: 90,