diff --git a/.github/workflows/dev-stack.yml b/.github/workflows/dev-stack.yml
new file mode 100644
index 000000000..825b970d1
--- /dev/null
+++ b/.github/workflows/dev-stack.yml
@@ -0,0 +1,340 @@
+name: Dev stack from source
+
+on:
+  pull_request:
+    paths:
+      - ".github/workflows/dev-stack.yml"
+      - ".nvmrc"
+      - "Dockerfile"
+      - "package.json"
+      - "package-lock.json"
+      - "CONTRIBUTING.md"
+      - "apps/api/**"
+      - "apps/web/**"
+      - "apps/worker/**"
+      - "packages/**"
+      - "deploy/docker/**"
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: dev-stack-${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  source-stack-linux:
+    name: Real source stack lifecycle (Linux)
+    runs-on: ubuntu-latest
+    timeout-minutes: 35
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          persist-credentials: false
+
+      - uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
+        with:
+          node-version-file: .nvmrc
+          cache: npm
+
+      - name: Install dependencies
+        env:
+          ELECTRON_SKIP_BINARY_DOWNLOAD: "1"
+        run: npm ci
+
+      - name: Unit-test dev-stack contracts
+        run: npm run test:dev-stack
+
+      - name: Start full stack without a TTY
+        shell: bash
+        run: |
+          set -euo pipefail
+          rm -f "$RUNNER_TEMP/dev-stack-initial.exit"
+          (
+            set +e
+            npm run dev:stack >"$RUNNER_TEMP/dev-stack.log" 2>&1
+            code=$?
+            printf '%s\n' "$code" >"$RUNNER_TEMP/dev-stack-initial.exit.tmp"
+            mv "$RUNNER_TEMP/dev-stack-initial.exit.tmp" "$RUNNER_TEMP/dev-stack-initial.exit"
+            exit "$code"
+          ) &
+          echo $! >"$RUNNER_TEMP/dev-stack-shell.pid"
+          echo "source stack launched in background"
+
+      - name: Verify readiness, owner setup, and OpenCode pane
+        run: npm run verify:dev-stack
+
+      - name: Verify a running shared-package rebuild
+        shell: bash
+        timeout-minutes: 10
+        run: |
+          set -euo pipefail
+          probe="dev_stack_rebuild_${GITHUB_RUN_ID}_${GITHUB_RUN_ATTEMPT}"
+          before_pid="$(node -e 'const fs=require("node:fs"); process.stdout.write(String(JSON.parse(fs.readFileSync(".dev-stack/supervisor.pid","utf8")).pid))')"
+          export SPACE_DEV_EXPECTED_PACKAGE_PROBE="$probe"
+          echo "SPACE_DEV_EXPECTED_PACKAGE_PROBE=$probe" >> "$GITHUB_ENV"
+          git diff --exit-code -- packages/contracts/src/index.ts
+          node --input-type=module <<'NODE'
+          import { mkdtemp } from "node:fs/promises";
+          import { join } from "node:path";
+          import { editSource } from "./deploy/docker/dev-stack-hotreload.mjs";
+          const backupRoot = await mkdtemp(join(process.env.RUNNER_TEMP, "dev-stack-source-backup-"));
+          const receiptRoot = join(process.env.RUNNER_TEMP, "dev-stack-source-edit-receipts");
+          await editSource("packages/contracts/src/index.ts", source =>
+            source + `\nexport const __devStackRebuildProbe = ${JSON.stringify(process.env.SPACE_DEV_EXPECTED_PACKAGE_PROBE)};\n`,
+            backupRoot, process.cwd(), receiptRoot);
+          NODE
+          api_url="$(node -e 'const fs=require("node:fs"); process.stdout.write(`http://127.0.0.1:${JSON.parse(fs.readFileSync(".dev-stack/config.json","utf8")).ports.api}`)')"
+
+          npm run dev:stack -- rebuild
+
+          rebuilt=0
+          for attempt in $(seq 1 240); do
+            ready=0
+            if curl -fsS "$api_url/readyz" | node -e '
+              let input="";
+              process.stdin.on("data", (chunk) => { input += chunk; });
+              process.stdin.on("end", () => {
+                try {
+                  const body = JSON.parse(input);
+                  process.exit(body.ok === true && body.dependencies?.database === "RUNNING" && body.dependencies?.worker === "RUNNING" && body.dependencies?.cliHost === "RUNNING" ? 0 : 1);
+                } catch { process.exit(1); }
+              });
+            '; then
+              ready=1
+            fi
+            if grep -Fq "$probe" packages/contracts/dist/index.js && [ "$ready" -eq 1 ] && grep -Fq "Rebuild complete; source services are ready." "$RUNNER_TEMP/dev-stack.log"; then
+              rebuilt=1
+              break
+            fi
+            sleep 1
+          done
+
+          if [ "$rebuilt" -ne 1 ]; then
+            echo "shared-package rebuild did not become observable in the running stack" >&2
+            tail -200 "$RUNNER_TEMP/dev-stack.log" >&2 || true
+            exit 1
+          fi
+          after_pid="$(node -e 'const fs=require("node:fs"); process.stdout.write(String(JSON.parse(fs.readFileSync(".dev-stack/supervisor.pid","utf8")).pid))')"
+          test "$before_pid" = "$after_pid"
+          echo "shared-package rebuild was picked up by supervisor $after_pid"
+
+      - name: Verify API watch and real browser hot reload
+        timeout-minutes: 6
+        env:
+          SPACE_DEV_ACCEPTANCE_MUTATIONS: "1"
+        run: node deploy/docker/dev-stack-hotreload.mjs --repo "$GITHUB_WORKSPACE"
+
+      - name: Verify worker failure and explicit normal restart
+        timeout-minutes: 10
+        env:
+          SPACE_DEV_ACCEPTANCE_MUTATIONS: "1"
+          SPACE_DEV_INITIAL_EXIT_FILE: ${{ runner.temp }}/dev-stack-initial.exit
+        run: node deploy/docker/dev-stack-worker-probe.mjs --repo "$GITHUB_WORKSPACE"
+
+      - name: Stop and reset owned resources
+        if: always()
+        shell: bash
+        run: |
+          set +e
+          node --input-type=module <<'NODE'
+          import { existsSync, readFileSync, writeFileSync } from "node:fs";
+          import { join } from "node:path";
+          import { resolveConfig } from "./deploy/docker/dev-stack-lib.mjs";
+          const config = await resolveConfig();
+          const records = existsSync(config.processFile) ? JSON.parse(readFileSync(config.processFile, "utf8")).groups : [];
+          writeFileSync(join(process.env.RUNNER_TEMP, "dev-stack-cleanup-inventory.json"), JSON.stringify({
+            stateRoot: config.stateRoot, socketPath: config.socketPath, groups: records.map(record => record.pgid)
+          }), { mode: 0o600 });
+          NODE
+          inventory_status=$?
+          npm run dev:stack -- down
+          down_status=$?
+          npm run dev:stack -- reset
+          reset_status=$?
+
+          process_status=0
+          for pid_file in dev-stack-shell.pid dev-stack-recovery-shell.pid; do
+            shell_pid="$(cat "$RUNNER_TEMP/$pid_file" 2>/dev/null || true)"
+            attempt=0
+            while [ "$attempt" -lt 50 ] && [ -n "$shell_pid" ]; do
+              state="$(ps -p "$shell_pid" -o stat= 2>/dev/null | xargs)"
+              if [ -z "$state" ] || [[ "$state" = Z* ]]; then break; fi
+              attempt=$((attempt + 1))
+              sleep 0.1
+            done
+            if [ -n "$shell_pid" ] && [ -n "$state" ] && [[ "$state" != Z* ]]; then
+              echo "dev-stack launcher $shell_pid is still alive after reset" >&2
+              process_status=1
+            fi
+          done
+
+          npm run --silent dev:stack -- status >"$RUNNER_TEMP/dev-stack-final-status.json"
+          status_status=$?
+          cat "$RUNNER_TEMP/dev-stack-final-status.json"
+          node --input-type=module <<'NODE'
+          import assert from "node:assert/strict";
+          import { execFileSync } from "node:child_process";
+          import { existsSync, readFileSync } from "node:fs";
+          import { join } from "node:path";
+          const inventory = JSON.parse(readFileSync(join(process.env.RUNNER_TEMP, "dev-stack-cleanup-inventory.json"), "utf8"));
+          const status = JSON.parse(readFileSync(join(process.env.RUNNER_TEMP, "dev-stack-final-status.json"), "utf8"));
+          assert.equal(status.running, false);
+          for (const type of ["containers", "volumes", "networks"]) assert.deepEqual(status.docker[type], []);
+          assert(!existsSync(inventory.stateRoot), "Owned state directory remains after reset.");
+          assert(!existsSync(inventory.socketPath), "Owned Unix socket remains after reset.");
+          const groups = new Set(inventory.groups);
+          for (const line of execFileSync("ps", ["-axo", "pid=,pgid=,stat="], { encoding: "utf8" }).trim().split(/\r?\n/)) {
+            const match = line.trim().match(/^(\d+)\s+(\d+)\s+(\S+)$/);
+            assert(match, "Could not parse final process inventory.");
+            assert(!groups.has(Number(match[2])) || match[3].startsWith("Z"), `Owned group ${match[2]} still contains live PID ${match[1]}.`);
+          }
+          console.log("PASS no owned processes, containers, volumes, networks, state or Unix socket remain");
+          NODE
+          resource_status=$?
+
+          # Recover all source mutations, including interrupted probe processes,
+          # after services stop so normal worker recovery need not rebuild again.
+          node --input-type=module <<'NODE'
+          import assert from "node:assert/strict";
+          import { existsSync, readFileSync, readdirSync } from "node:fs";
+          import { basename, dirname, join, resolve } from "node:path";
+          import { restoreSourceEdit } from "./deploy/docker/dev-stack-hotreload.mjs";
+          const receiptRoot = join(process.env.RUNNER_TEMP, "dev-stack-source-edit-receipts");
+          const sources = ["apps/api/src/health-routes.ts", "apps/web/src/features/auth/LoginScreen.tsx", "packages/contracts/src/index.ts"];
+          for (const name of existsSync(receiptRoot) ? readdirSync(receiptRoot) : []) {
+            const source = sources.find(candidate => `${candidate.replaceAll("/", "__")}.json` === name);
+            assert(source, "Unexpected source recovery receipt; refusing overwrite.");
+            const file = join(receiptRoot, name);
+            const receipt = JSON.parse(readFileSync(file, "utf8"));
+            assert.equal(receipt.receiptFile, file);
+            assert.equal(receipt.path, resolve(source));
+            assert.equal(dirname(dirname(receipt.backup)), process.env.RUNNER_TEMP);
+            assert(basename(dirname(receipt.backup)).startsWith("dev-stack-source-backup-"));
+            assert.equal(basename(receipt.backup), source.replaceAll("/", "__"));
+            await restoreSourceEdit(receipt);
+            console.log(`PASS interrupted source edit restored sha256=${receipt.originalHash}`);
+          }
+          NODE
+          restore_status=$?
+          git diff --exit-code -- packages/contracts/src/index.ts apps/api/src/health-routes.ts apps/web/src/features/auth/LoginScreen.tsx
+          diff_status=$?
+          echo "--- dev-stack log ---"
+          cat "$RUNNER_TEMP/dev-stack.log" 2>/dev/null || true
+          for result in "$inventory_status" "$down_status" "$reset_status" "$process_status" "$status_status" "$resource_status" "$restore_status" "$diff_status"; do
+            if [ "$result" -ne 0 ]; then exit 1; fi
+          done
+
+      - name: Preserve limited acceptance evidence
+        if: always()
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: dev-stack-linux-acceptance
+          if-no-files-found: ignore
+          retention-days: 14
+          path: |
+            ${{ runner.temp }}/dev-stack-acceptance-evidence/hmr-*.png
+            ${{ runner.temp }}/dev-stack-acceptance-evidence/*-receipt.json
+
+  source-stack-macos:
+    name: Real source stack lifecycle (macOS, Colima)
+    runs-on: macos-15-intel
+    timeout-minutes: 90
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          persist-credentials: false
+
+      - uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
+        with:
+          node-version-file: .nvmrc
+          cache: npm
+
+      - name: Install Docker CLI and Colima
+        env:
+          HOMEBREW_NO_AUTO_UPDATE: "1"
+          HOMEBREW_NO_INSTALL_CLEANUP: "1"
+        run: |
+          brew install colima docker docker-compose
+          mkdir -p "$HOME/.docker/cli-plugins"
+          ln -sfn "$(brew --prefix docker-compose)/bin/docker-compose" "$HOME/.docker/cli-plugins/docker-compose"
+
+      - name: Start Colima
+        timeout-minutes: 25
+        run: |
+          colima start --cpu 2 --memory 6
+          docker version
+          docker compose version
+
+      - name: Install dependencies
+        env:
+          ELECTRON_SKIP_BINARY_DOWNLOAD: "1"
+        run: npm ci
+
+      - name: Unit-test dev-stack contracts
+        run: npm run test:dev-stack
+
+      - name: Start full stack without a TTY
+        shell: bash
+        run: |
+          set -euo pipefail
+          npm run dev:stack >"$RUNNER_TEMP/dev-stack.log" 2>&1 &
+          echo $! >"$RUNNER_TEMP/dev-stack-shell.pid"
+          echo "source stack launched in background"
+
+      - name: Verify readiness, owner setup, and OpenCode pane
+        env:
+          # Cold Colima/image startup plus one full source build can exceed 15m.
+          # Keep fresh-checkout startup under test; readiness assertions stay intact.
+          SPACE_DEV_VERIFY_READY_TIMEOUT_MS: "1800000"
+          SPACE_DEV_VERIFY_CLI_TIMEOUT_MS: "300000"
+        run: npm run verify:dev-stack
+
+      - name: Stop and reset owned resources
+        if: always()
+        shell: bash
+        run: |
+          set +e
+          npm run dev:stack -- down
+          down_status=$?
+          npm run dev:stack -- reset
+          reset_status=$?
+
+          shell_pid="$(cat "$RUNNER_TEMP/dev-stack-shell.pid" 2>/dev/null || true)"
+          attempt=0
+          while [ "$attempt" -lt 50 ]; do
+            if [ -z "$shell_pid" ] || ! kill -0 "$shell_pid" 2>/dev/null; then
+              break
+            fi
+            attempt=$((attempt + 1))
+            sleep 0.1
+          done
+          process_status=0
+          if [ -n "$shell_pid" ] && kill -0 "$shell_pid" 2>/dev/null; then
+            echo "dev-stack launcher process $shell_pid is still alive after reset" >&2
+            process_status=1
+            kill "$shell_pid" 2>/dev/null || true
+          fi
+
+          status_json="$(npm run --silent dev:stack -- status 2>/dev/null)"
+          echo "$status_json"
+          if echo "$status_json" | grep -q '"running": true'; then
+            echo "dev-stack supervisor still reports running after reset" >&2
+            process_status=1
+          fi
+          if ! echo "$status_json" | grep -q '"containers": \[\]'; then
+            echo "dev-stack containers remain after reset" >&2
+            process_status=1
+          fi
+          if ! echo "$status_json" | grep -q '"volumes": \[\]'; then
+            echo "dev-stack volumes remain after reset" >&2
+            process_status=1
+          fi
+
+          echo "--- dev-stack log ---"
+          cat "$RUNNER_TEMP/dev-stack.log" 2>/dev/null || true
+          colima stop >/dev/null 2>&1 || true
+          if [ "$down_status" -ne 0 ] || [ "$reset_status" -ne 0 ] || [ "$process_status" -ne 0 ]; then
+            exit 1
+          fi
diff --git a/.gitignore b/.gitignore
index 81e68b26a..604f0123c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -37,6 +37,8 @@ bin/
 var/
 projects/
 /lost+found/
+.dev-stack/
+.dev-stack*/
 
 # Local credentials and machine-specific environment.
 .env
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 03bcdad05..3c9b71062 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -50,6 +50,108 @@ select a short temporary directory you own and set `TMPDIR` for the command.
 On Windows run this particular smoke check inside WSL or a Linux development
 container. It does not certify the Windows/macOS installer.
 
+## Run the complete app from source
+
+With Docker Engine or Docker Desktop available, start the contributor stack:
+
+```sh
+npm run dev:stack
+```
+
+The command starts digest-pinned PostgreSQL with pgvector and Temporal in an
+isolated Compose project, builds the workspace before migrations on a fresh
+checkout, installs the `opencode-ai` version pinned by `Dockerfile` into local
+state, and launches the CLI host, worker, API and Vite web server from this
+checkout. The API uses normal single-owner setup: `SPACE_DEV_LOGIN` stays off.
+When `/readyz` reports the database, worker and CLI host as running, the command
+prints the local Web URL. It queries the API's owner setup status and prints the
+one-time setup token **only** if an owner has not been claimed and that token is
+still valid. On an ordinary restart after owner creation, it prints a sign-in
+instruction instead; an expired or unavailable setup token is not displayed.
+If the API setup status cannot be verified, startup fails rather than logging a
+possibly consumed token. Do not use `reset` merely to recover a setup token:
+`reset` deletes this checkout's persistent dev data.
+
+The default source-stack ports are deliberately separate from an installed
+SpaceApp: API `5910`, Web `5911`, PostgreSQL `55432`, and Temporal `57233`.
+Docker-published ports bind to `127.0.0.1`. Runtime state and generated secrets
+live under the git-ignored `.dev-stack/`; secret files are mode `0600`. Provider
+API keys and GitHub tokens inherited by the shell are not passed to source
+services.
+
+Useful lifecycle commands are:
+
+```sh
+npm run dev:stack -- status
+npm run dev:stack -- rebuild
+npm run dev:stack -- down
+npm run dev:stack -- reset
+```
+
+`rebuild` rebuilds workspace packages and restarts the source services under the
+same supervisor. `down` stops only this checkout's supervised processes and
+Compose project. `reset` additionally removes this checkout's Compose volumes
+and state directory; if Docker cannot remove an owned volume, reset fails and
+keeps the state needed to retry cleanup instead of reporting success. Lifecycle
+commands verify the recorded supervisor start identity and checkout hash before
+sending a signal, so a stale PID file cannot target a reused unrelated PID.
+
+The isolated ports can be overridden with `SPACE_DEV_API_PORT`,
+`SPACE_DEV_WEB_PORT`, `SPACE_DEV_POSTGRES_PORT`, and
+`SPACE_DEV_TEMPORAL_PORT`. The state directory and Compose project identity are
+derived from this checkout and intentionally cannot be overridden, so lifecycle
+commands cannot target another checkout's resources. The runner also rejects
+installed-instance ports `4910` and `4911`, duplicate ports, unsafe state roots,
+and symlink state roots.
+
+For an automated end-to-end proof after the stack is ready, run:
+
+```sh
+npm run verify:dev-stack
+```
+
+That proof performs normal owner setup, points the Getting Started room at the
+current checkout rather than `/opt/spaceapp`, starts its OpenCode terminal pane
+through the real CLI host, attaches the same terminal WebSocket transport used
+by the web UI, requires a running CLI session plus real terminal output, and
+verifies that the stack remains ready. The dedicated GitHub Actions workflow
+runs this lifecycle on Linux and on an Intel macOS runner using Colima. Windows
+11 contributors should use WSL2 with Docker Desktop's WSL integration or a
+Docker engine running inside WSL2; that path follows the Linux host model.
+These host paths are contributor environments, not installer-release
+certification.
+
+The Linux lifecycle job also edits and restores source files in its disposable
+checkout: it checks API watch restarts, imports a rebuilt package marker through
+the running API, and verifies Vite updates a real Chrome page without navigation
+or losing form state. It then stops the owned worker, requires a clear failure
+and nonzero supervisor exit, and exercises an explicit normal restart with the
+same owner data. These mutation probes are CI-only and are not needed for normal
+contributor startup. Their screenshots include only the anonymous login heading;
+state directories, credentials, browser profiles and source backups are not
+uploaded. The final cleanup restores original source bytes and checks owned
+processes, containers, volumes, networks, state and the Unix socket are gone.
+
+### Troubleshooting the source stack
+
+- If Docker is unavailable, run `docker compose version` first and start Docker
+  Desktop, Colima, or the Docker daemon before `npm run dev:stack`.
+- If a default dev port is occupied, set the corresponding
+  `SPACE_DEV_*_PORT` variable rather than reusing installed ports `4910/4911`.
+- If a package change is not reflected in a running source service, run
+  `npm run dev:stack -- rebuild`; Vite handles `apps/web/src` edits directly
+  and the API runs under `tsx watch`.
+- If startup is interrupted, `npm run dev:stack -- down` stops the owned
+  supervisor and Compose project. Use `npm run dev:stack -- reset` for a clean
+  database and state directory; a failed volume removal is reported and leaves
+  the state in place so cleanup can be retried safely.
+- On macOS, `npm run dev:stack` repairs the execute bits on node-pty's published
+  `prebuilds/darwin-*/spawn-helper` before the CLI host starts. If you launch
+  the CLI host outside this workflow and a terminal remains `IDLE` with an
+  `EACCES` spawn error, repair that helper's execute permission first.
+- Unix socket paths are automatically shortened under the system temporary
+  directory when `.dev-stack` would exceed the platform socket-path limit.
+
 ## Make and verify a small change
 
 Work on a branch, not on `main`, so the change can become a pull request:
diff --git a/apps/api/src/agent-bootstrap.ts b/apps/api/src/agent-bootstrap.ts
index 20cb69a9c..9ca7e2bc4 100644
--- a/apps/api/src/agent-bootstrap.ts
+++ b/apps/api/src/agent-bootstrap.ts
@@ -1,4 +1,4 @@
-import { spaceAgentCorePath, spaceMemoryIndexPath, spaceMemoryMonthlyPath } from "@space/runtime";
+import { SPACE_MEMORY_DIRECTORY, spaceAgentCorePath, spaceMemoryDirectory, spaceMemoryIndexPath, spaceMemoryMonthlyPath } from "@space/runtime";
 
 export interface SpaceAgentBootstrapInput {
   channel: "WEB_CHAT" | "CLI";
@@ -74,6 +74,8 @@ function cliAgentFilesLine(channel: SpaceAgentBootstrapInput["channel"]): string
 
 export function buildSpaceAgentBootstrapPrompt(input: SpaceAgentBootstrapInput): string {
   const memoryMonth = input.currentMemoryMonth ?? currentMemoryMonth();
+  const memoryDirectory = spaceMemoryDirectory();
+  const installedMemory = memoryDirectory === SPACE_MEMORY_DIRECTORY;
   const browserState = input.browserToolsEnabled
     ? `${input.activeBrowserSessionCount ?? 0} active managed browser session(s) are visible in this room.`
     : "Managed browser tools are disabled until Space browser runtime gates pass.";
@@ -88,17 +90,17 @@ export function buildSpaceAgentBootstrapPrompt(input: SpaceAgentBootstrapInput):
     "Space Agent Bootstrap:",
     `- Channel: ${input.channel}. Match the main Codex /etc VS Code session rules where the runtime exposes them.`,
     ...identityLines(input),
-    `- Read the compact ${spaceAgentCorePath()} core once. Load only task-relevant domain rules; read /opt/spaceapp/docs/agent_local_workspace_hygiene.md before local project/dev-server/cleanup work.`,
+    `- Read the compact ${spaceAgentCorePath()} core once. Load only task-relevant domain rules; ${installedMemory ? "read /opt/spaceapp/docs/agent_local_workspace_hygiene.md" : "follow the current source checkout's CONTRIBUTING.md"} before local project/dev-server/cleanup work.`,
     `- Canonical Space Memory: ${spaceMemoryIndexPath()} plus ${spaceMemoryMonthlyPath(memoryMonth)}.`,
-    "- Memory parity: read/search/save through the Space Memory bridge (/opt/spaceapp/bin/space-memory-recall, /opt/spaceapp/bin/space-memory-save) or Space API memory endpoints. Treat Space Memory in /opt/spaceapp/docs as canonical operational memory; Codex ad-hoc notes are fallback only.",
+    `- Memory parity: ${installedMemory ? "read/search/save through the Space Memory bridge (/opt/spaceapp/bin/space-memory-recall, /opt/spaceapp/bin/space-memory-save) or Space API memory endpoints" : "read/search/save directly under the configured source-stack memory root with native filesystem tools, or through authenticated Space API memory endpoints when available; do not use an installed-instance memory bridge"}. Treat Space Memory in ${memoryDirectory} as canonical operational memory; Codex ad-hoc notes are fallback only.`,
     "- Tools: choose verified native tools first. MCP is on-demand fallback or Space-specific access, never a mandatory substitute for a capable native tool. Keep evidence and authorization requirements regardless of transport.",
     "- Images: use native vision whenever available. Vision MCP is only for verified text-only input pipelines; unknown model support requires checking capability metadata first.",
     "- Skills: load only relevant guidance when needed. Workflow skills require operator opt-in; a skill must not force an inferior tool. Do not list every skill or tool at startup.",
     input.channel === "CLI" ? "- Space-only operations: use space-capability info <server> [tool] or space-capability call with JSON on stdin when needed. No MCP catalog or server startup is required for native tasks." : null,
     agentFilesLine,
-    input.channel === "CLI" ? "- Timed or recurring work: `node /opt/spaceapp/scripts/space-task.mjs add --title T --prompt P --every 2h|--daily HH:MM|--at <time>` puts it in the operator's Tasks dock, and Space types it into this pane when due. Never use a session-only cron or timer for it." : null,
+    input.channel === "CLI" ? `- Timed or recurring work: ${installedMemory ? "`node /opt/spaceapp/scripts/space-task.mjs add --title T --prompt P --every 2h|--daily HH:MM|--at <time>` puts it in the operator's Tasks dock, and Space types it into this pane when due" : "use verified Space API task capabilities for the current source stack"}. Never use a session-only cron or timer for it.` : null,
     // Pane reports to Nous (plan clipboard:ot6-jLKOWDNC): Nous knows every pane's progress without reading screens.
-    input.channel === "CLI" ? "- Progress to Nous (skill space-progress): `node /opt/spaceapp/scripts/space-progress.mjs <started|progress|blocked|needs-decision|waiting|done|failed> \"one line\" [--plan clipboard:<id> --step N --percent N --ticket q-... --needs \"options and your recommendation\" --report-file <path>]` (or space_progress_report). Report at task start, after each finished plan step, when blocked or needing a decision, when you submit a merge-queue ticket, and when done or failed (what changed, tests, ticket, next, what is still needed). Space records each turn's end on its own; never put secrets in a report." : null,
+    input.channel === "CLI" && installedMemory ? "- Progress to Nous (skill space-progress): `node /opt/spaceapp/scripts/space-progress.mjs <started|progress|blocked|needs-decision|waiting|done|failed> \"one line\" [--plan clipboard:<id> --step N --percent N --ticket q-... --needs \"options and your recommendation\" --report-file <path>]` (or space_progress_report). Report at task start, after each finished plan step, when blocked or needing a decision, when you submit a merge-queue ticket, and when done or failed (what changed, tests, ticket, next, what is still needed). Space records each turn's end on its own; never put secrets in a report." : null,
     // Design pane (plan clipboard:URdc3U314lUH): any CLI asks the owner's Design pane for graphics.
     input.channel === "CLI" ? "- Graphics (skill space-design): ask the Design pane with space_design space_design_request (brief, formatIds such as x, linkedin-banner, story), then space_design_request_wait; delivered designs come back as Media artifact ids." : null,
     "- Secret policy: never write raw provider credentials, cookies, browser profile data, private keys, or unredacted tokens to docs, chat, logs, memory, or transcripts.",
@@ -116,6 +118,16 @@ export function buildSpaceAgentBootstrapPrompt(input: SpaceAgentBootstrapInput):
 
 export function buildCliAgentBootstrapMarkdown(input: Omit<SpaceAgentBootstrapInput, "channel"> = {}): string {
   const memoryMonth = input.currentMemoryMonth ?? currentMemoryMonth();
+  const installedMemory = spaceMemoryDirectory() === SPACE_MEMORY_DIRECTORY;
+  const operationalWorkspace = installedMemory
+    ? `- Treat /etc as the default operational workspace for memory, infra, access, ops, and browser-facing tasks unless the user names another path.
+- This artifact folder is not the project root. If the user asks about Space, use the real target path such as /opt/spaceapp.
+- Prefer native filesystem/search/shell tools for ordinary work. Use protected Space APIs or the on-demand entrypoint for Space-specific capabilities.
+- If a task explicitly requires /etc operational memory and the CLI has filesystem access, read/write the canonical Space Memory files listed above.`
+    : `- Use the current source checkout for Space source-code tasks; do not target an installed SpaceApp instance.
+- This artifact folder is not the project root. For Space source code, use the current source checkout.
+- Prefer native filesystem/search/shell tools for ordinary work. Use protected Space APIs or the on-demand entrypoint for Space-specific capabilities.
+- Read or write canonical Space Memory directly under the configured source-stack memory root listed above with native filesystem tools. Authenticated Space API memory endpoints are an optional equivalent transport when available; never use an installed-instance memory bridge.`;
   return `# Space CLI Agent Bootstrap
 
 This CLI session is launched by Space. It uses a managed writable workspace only to persist the terminal session and uploads.
@@ -128,10 +140,7 @@ ${buildSpaceAgentBootstrapPrompt({
 
 Operational workspace:
 
-- Treat /etc as the default operational workspace for memory, infra, access, ops, and browser-facing tasks unless the user names another path.
-- This artifact folder is not the project root. If the user asks about Space, use the real target path such as /opt/spaceapp.
-- Prefer native filesystem/search/shell tools for ordinary work. Use protected Space APIs or the on-demand entrypoint for Space-specific capabilities.
-- If a task explicitly requires /etc operational memory and the CLI has filesystem access, read/write the canonical Space Memory files listed above.
+${operationalWorkspace}
 - Use GET /api/tasks?source=codex_goal to inspect shared Codex goals; bounded updates go through PATCH /api/tasks/codex-goals/:threadId when Space API auth is available.
 - Space sets non-secret identity environment variables for this process:
   SPACE_AGENT_CHANNEL, SPACE_ROOM_ID, SPACE_PANE_ID, SPACE_CLI_SESSION_ID, SPACE_CLI_RUNTIME_ID, and SPACE_AGENT_RUNTIME_ID.
diff --git a/apps/api/src/cli-terminal.ts b/apps/api/src/cli-terminal.ts
index fe892c09f..64abf71dc 100644
--- a/apps/api/src/cli-terminal.ts
+++ b/apps/api/src/cli-terminal.ts
@@ -990,6 +990,7 @@ export function buildCliEnvironment(config: SpaceApiConfig, context: CliEnvironm
     SPACE_CLI_SESSION_ID: context.cliSessionId ?? undefined,
     SPACE_CODEX_PER_SESSION_APP_SERVER: directCodexParity ? "1" : undefined,
     SPACE_CLI_WORKSPACE: context.cwd ?? undefined,
+    SPACE_MEMORY_ROOT: process.env.SPACE_MEMORY_ROOT,
     SPACE_PANE_ID: context.paneId ?? undefined,
     SPACE_ROOM_ID: context.roomId ?? undefined,
     SHELL: shell,
diff --git a/apps/api/tests/agent-bootstrap.test.ts b/apps/api/tests/agent-bootstrap.test.ts
index 4302e4c1e..c5091d15f 100644
--- a/apps/api/tests/agent-bootstrap.test.ts
+++ b/apps/api/tests/agent-bootstrap.test.ts
@@ -24,6 +24,44 @@ describe("Space agent bootstrap", () => {
     expect(prompt).not.toContain("space-memory-actions");
   });
 
+  it("points source-stack bootstrap memory guidance at the configured owned root", () => {
+    const previousRoot = process.env.SPACE_MEMORY_ROOT;
+    process.env.SPACE_MEMORY_ROOT = "/tmp/source-stack-owned-memory";
+    try {
+      const prompt = buildSpaceAgentBootstrapPrompt({ channel: "WEB_CHAT" });
+      expect(prompt).toContain("/tmp/source-stack-owned-memory/gemini.md");
+      expect(prompt).toContain("/tmp/source-stack-owned-memory/gemini_history.md");
+      expect(prompt).toContain("Treat Space Memory in /tmp/source-stack-owned-memory as canonical");
+      expect(prompt).toContain("native filesystem tools");
+      expect(prompt).toContain("do not use an installed-instance memory bridge");
+      expect(prompt).toContain("current source checkout's CONTRIBUTING.md");
+      expect(prompt).not.toContain("Treat Space Memory in /opt/spaceapp/docs as canonical");
+      expect(prompt).not.toContain("/opt/spaceapp/bin/space-memory");
+    } finally {
+      if (previousRoot === undefined) delete process.env.SPACE_MEMORY_ROOT;
+      else process.env.SPACE_MEMORY_ROOT = previousRoot;
+    }
+  });
+
+  it("keeps source CLI instructions off installed workspaces and task scripts", () => {
+    const previousRoot = process.env.SPACE_MEMORY_ROOT;
+    process.env.SPACE_MEMORY_ROOT = "/tmp/source-cli-owned-memory";
+    try {
+      const markdown = buildCliAgentBootstrapMarkdown();
+      expect(markdown).toContain("Use the current source checkout for Space source-code tasks");
+      expect(markdown).toContain("Read or write canonical Space Memory directly under the configured source-stack memory root");
+      expect(markdown).toContain("native filesystem tools");
+      expect(markdown).toContain("/tmp/source-cli-owned-memory");
+      expect(markdown).toContain("never use an installed-instance memory bridge");
+      expect(markdown).toContain("use verified Space API task capabilities for the current source stack");
+      expect(markdown).not.toContain("/opt/spaceapp");
+      expect(markdown).not.toContain("Treat /etc as the default operational workspace");
+    } finally {
+      if (previousRoot === undefined) delete process.env.SPACE_MEMORY_ROOT;
+      else process.env.SPACE_MEMORY_ROOT = previousRoot;
+    }
+  });
+
   it("requires CLI agents to publish final deliverables without leaking inputs or secrets", () => {
     const cliMarkdown = buildCliAgentBootstrapMarkdown();
     const webPrompt = buildSpaceAgentBootstrapPrompt({ channel: "WEB_CHAT" });
diff --git a/apps/api/tests/cli-pane-model-launch.test.ts b/apps/api/tests/cli-pane-model-launch.test.ts
index 1c578200c..7f3ca7738 100644
--- a/apps/api/tests/cli-pane-model-launch.test.ts
+++ b/apps/api/tests/cli-pane-model-launch.test.ts
@@ -34,4 +34,16 @@ describe("pane model pick at CLI launch", () => {
       expect(buildCliEnvironment(config, { runtimeId, modelId: "provider/picked-model" }).SPACE_CLI_MODEL_ID, runtimeId).toBeUndefined();
     }
   });
+
+  it("passes the configured source-stack memory root to OpenCode", () => {
+    const previousRoot = process.env.SPACE_MEMORY_ROOT;
+    process.env.SPACE_MEMORY_ROOT = "/tmp/source-opencode-memory";
+    try {
+      const env = buildCliEnvironment(config, { runtimeId: "cli:opencode" });
+      expect(env.SPACE_MEMORY_ROOT).toBe("/tmp/source-opencode-memory");
+    } finally {
+      if (previousRoot === undefined) delete process.env.SPACE_MEMORY_ROOT;
+      else process.env.SPACE_MEMORY_ROOT = previousRoot;
+    }
+  });
 });
diff --git a/apps/api/tests/memory-search-root.test.ts b/apps/api/tests/memory-search-root.test.ts
new file mode 100644
index 000000000..48c3d043a
--- /dev/null
+++ b/apps/api/tests/memory-search-root.test.ts
@@ -0,0 +1,33 @@
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { spaceMemoryMonthlyPath } from "@space/runtime";
+import { searchDefaultSpaceMemory } from "../src/memory-search.js";
+
+const roots: string[] = [];
+afterEach(async () => { for (const root of roots.splice(0)) await rm(root, { recursive: true, force: true }); });
+
+describe("default Space Memory search root", () => {
+  it("searches only the process-configured canonical root", async () => {
+    const root = await mkdtemp(join(tmpdir(), "space-memory-search-root-"));
+    roots.push(root);
+    const previousRoot = process.env.SPACE_MEMORY_ROOT;
+    process.env.SPACE_MEMORY_ROOT = root;
+    try {
+      const marker = "source-stack-memory-root-probe";
+      const indexPath = join(root, "gemini_history.md");
+      const monthlyPath = spaceMemoryMonthlyPath(new Date().toISOString().slice(0, 7));
+      await writeFile(indexPath, `# ${marker}\n`);
+      await writeFile(monthlyPath, `## ${marker} monthly entry\n`);
+
+      const entries = await searchDefaultSpaceMemory({ page: 1, pageSize: 25, sortOrder: "desc", q: marker });
+      expect(entries).toHaveLength(2);
+      expect(entries.every((entry) => entry.provenance.startsWith(root))).toBe(true);
+      expect(entries.some((entry) => entry.body.includes(marker))).toBe(true);
+    } finally {
+      if (previousRoot === undefined) delete process.env.SPACE_MEMORY_ROOT;
+      else process.env.SPACE_MEMORY_ROOT = previousRoot;
+    }
+  });
+});
diff --git a/apps/web/vite.config.ts b/apps/web/vite.config.ts
index cd7612d98..5cca67e77 100644
--- a/apps/web/vite.config.ts
+++ b/apps/web/vite.config.ts
@@ -33,13 +33,17 @@ export default defineConfig({
   server: {
     host: process.env.SPACE_WEB_HOST ?? "0.0.0.0",
     port: Number.parseInt(process.env.SPACE_WEB_PORT ?? "4911", 10),
-    proxy: {
-      "/api": "http://127.0.0.1:4910",
-      "/plugins": "http://127.0.0.1:4910",
-      "/healthz": "http://127.0.0.1:4910",
-      "/readyz": "http://127.0.0.1:4910",
-      "/version": "http://127.0.0.1:4910"
-    }
+    proxy: (() => {
+      const apiOrigin = process.env.SPACE_API_ORIGIN ?? `http://127.0.0.1:${process.env.SPACE_API_PORT ?? "4910"}`;
+      return {
+        "/api": { target: apiOrigin, ws: true },
+        "/plugins": apiOrigin,
+        "/healthz": apiOrigin,
+        "/readyz": apiOrigin,
+        "/version": apiOrigin,
+        "/logout": apiOrigin
+      };
+    })()
   },
   test: {
     environment: "jsdom",
diff --git a/apps/worker/src/memory-maintenance-activities.ts b/apps/worker/src/memory-maintenance-activities.ts
index 9eafa3d51..2ad75b357 100644
--- a/apps/worker/src/memory-maintenance-activities.ts
+++ b/apps/worker/src/memory-maintenance-activities.ts
@@ -39,9 +39,9 @@ import {
 } from "@space/memory-graph";
 import {
   MONTHLY_MEMORY_FILE_PATTERN,
-  SPACE_MEMORY_DIRECTORY,
   redactMemoryText,
   resolveCanonicalSpaceMemoryPaths,
+  spaceMemoryDirectory,
   spaceMemoryIndexPath,
   spaceMemoryMonthlyPath
 } from "@space/runtime";
@@ -713,7 +713,7 @@ export async function refreshAllMonthsMemoryGraphSnapshot(
   const now = options.now ?? (() => new Date());
   const generatedAt = now().toISOString();
   const indexPath = options.indexPath ?? spaceMemoryIndexPath();
-  const memoryDir = options.memoryDir ?? SPACE_MEMORY_DIRECTORY;
+  const memoryDir = options.memoryDir ?? spaceMemoryDirectory();
   const rootDir = options.rootDir ?? process.env.SPACE_MEMORY_GRAPH_ROOT ?? DEFAULT_GRAPH_ROOT;
   const indexContent = await readFile(indexPath, "utf8");
   const monthlyPaths = await listMonthlyMemoryPaths(memoryDir);
diff --git a/deploy/docker/dev-stack-hotreload.mjs b/deploy/docker/dev-stack-hotreload.mjs
new file mode 100644
index 000000000..b9fcbeaf0
--- /dev/null
+++ b/deploy/docker/dev-stack-hotreload.mjs
@@ -0,0 +1,346 @@
+#!/usr/bin/env node
+// Destructive source probes are restricted to an opted-in disposable Linux CI checkout.
+import assert from "node:assert/strict";
+import { spawn, execFile } from "node:child_process";
+import { createHash, randomUUID } from "node:crypto";
+import { access, chmod, lstat, mkdir, mkdtemp, readFile, rename, rm, rmdir, writeFile } from "node:fs/promises";
+import { constants } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, relative, resolve, sep } from "node:path";
+import { pathToFileURL, fileURLToPath } from "node:url";
+import { promisify } from "node:util";
+
+const exec = promisify(execFile);
+const pause = (ms) => new Promise((done) => setTimeout(done, ms));
+const hash = (bytes) => createHash("sha256").update(bytes).digest("hex");
+const arg = process.argv.indexOf("--repo");
+const root = arg >= 0 && process.argv[arg + 1] ? resolve(process.argv[arg + 1]) : null;
+const receipts = [];
+
+function checkRunner() {
+  assert(root, "Pass --repo with the disposable checkout path.");
+  assert.equal(process.env.GITHUB_ACTIONS, "true", "This mutation probe is restricted to an ephemeral GitHub Actions runner.");
+  assert.equal(process.env.RUNNER_OS, "Linux");
+  assert.equal(process.env.SPACE_DEV_ACCEPTANCE_MUTATIONS, "1", "Explicit mutation opt-in is required.");
+  assert(process.env.RUNNER_TEMP, "RUNNER_TEMP is required.");
+  assert.notEqual(process.getuid?.(), 0, "Do not disable the browser sandbox to run this probe as root.");
+}
+
+async function until(label, action, timeoutMs = 90_000) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const result = await action();
+    if (result) return result;
+    await pause(200);
+  }
+  throw new Error(`${label} did not reach its asserted condition within ${timeoutMs}ms.`);
+}
+
+async function json(url) {
+  try {
+    const response = await fetch(url, { signal: AbortSignal.timeout(5_000), cache: "no-store" });
+    if (!response.ok) return null;
+    return await response.json();
+  } catch { return null; }
+}
+
+function ready(body) {
+  return body?.ok === true && ["database", "worker", "cliHost"].every((key) => body.dependencies?.[key] === "RUNNING");
+}
+
+export function replaceOnce(text, anchor, replacement) {
+  assert.equal(text.split(anchor).length, 2, "Source anchor must occur exactly once; inspect candidate drift.");
+  return text.replace(anchor, replacement);
+}
+
+async function replaceFile(path, bytes, mode) {
+  const temporary = `${path}.dev-stack-probe-${randomUUID()}.tmp`;
+  try {
+    await writeFile(temporary, bytes, { flag: "wx", mode });
+    await chmod(temporary, mode);
+    await rename(temporary, path);
+  } finally { await rm(temporary, { force: true }); }
+}
+
+export async function restoreSourceEdit(receipt) {
+  const { path, backup, originalHash, editedHash, mode } = receipt;
+  const info = await lstat(path);
+  assert(info.isFile() && !info.isSymbolicLink(), "Refusing to restore a replaced non-regular source file.");
+  const backupInfo = await lstat(backup);
+  assert(backupInfo.isFile() && !backupInfo.isSymbolicLink(), "Source backup must remain a regular file.");
+  const original = await readFile(backup);
+  assert.equal(hash(original), originalHash, "Source backup checksum changed; refusing restoration.");
+  const currentHash = hash(await readFile(path));
+  assert(currentHash === editedHash || currentHash === originalHash, `Concurrent modification of ${path}; original backup retained at ${backup}.`);
+  await replaceFile(path, original, mode);
+  assert.equal(hash(await readFile(path)), originalHash, "Original source bytes were not restored.");
+  if (receipt.receiptFile) await rm(receipt.receiptFile);
+  await rm(backup);
+}
+
+export async function editSource(relativePath, transform, backupRoot, checkoutRoot = root, receiptRoot = null) {
+  const path = resolve(checkoutRoot, relativePath);
+  const rel = relative(resolve(checkoutRoot), path);
+  assert(rel && rel !== ".." && !rel.startsWith(`..${sep}`), "Source probe must stay inside its checkout.");
+  const info = await lstat(path);
+  assert(info.isFile() && !info.isSymbolicLink(), "Probe source must be a regular tracked file.");
+  const original = await readFile(path);
+  const edited = Buffer.from(transform(original.toString("utf8")));
+  assert(!original.equals(edited), "Source probe must actually change bytes.");
+  const backup = join(backupRoot, relativePath.replaceAll("/", "__"));
+  await writeFile(backup, original, { flag: "wx", mode: 0o600 });
+  assert((await readFile(path)).equals(original), "Source changed while preparing its backup.");
+  const receipt = { path, backup, originalHash: hash(original), editedHash: hash(edited), mode: info.mode & 0o777 };
+  // Persist before changing source so the workflow's always-cleanup can recover
+  // even if timeout/SIGTERM prevents this process's finally blocks from running.
+  if (receiptRoot) {
+    await mkdir(receiptRoot, { recursive: true, mode: 0o700 });
+    receipt.receiptFile = join(receiptRoot, `${relativePath.replaceAll("/", "__")}.json`);
+    await writeFile(receipt.receiptFile, JSON.stringify(receipt), { flag: "wx", mode: 0o600 });
+  }
+  await replaceFile(path, edited, receipt.mode);
+  let restored = false;
+  return {
+    ...receipt,
+    async restore() {
+      if (restored) return;
+      await restoreSourceEdit(receipt);
+      restored = true;
+    }
+  };
+}
+
+export class PipeCdp {
+  constructor(child) {
+    this.child = child;
+    this.nextId = 1;
+    this.pending = new Map();
+    this.handlers = new Set();
+    this.closed = false;
+    let buffered = Buffer.alloc(0);
+    child.stdio[4].on("data", (chunk) => {
+      buffered = Buffer.concat([buffered, chunk]);
+      for (let boundary; (boundary = buffered.indexOf(0)) >= 0;) {
+        const raw = buffered.subarray(0, boundary);
+        buffered = buffered.subarray(boundary + 1);
+        if (!raw.length) continue;
+        const message = JSON.parse(raw.toString("utf8"));
+        if (message.id) {
+          const entry = this.pending.get(message.id);
+          if (!entry) continue;
+          clearTimeout(entry.timer);
+          this.pending.delete(message.id);
+          if (message.error) entry.reject(new Error(`CDP ${entry.method} failed (code ${message.error.code}).`));
+          else entry.resolve(message.result);
+        } else for (const handler of this.handlers) handler(message);
+      }
+    });
+    const fail = () => {
+      this.closed = true;
+      for (const entry of this.pending.values()) {
+        clearTimeout(entry.timer);
+        entry.reject(new Error("The isolated browser closed before completing a CDP command."));
+      }
+      this.pending.clear();
+    };
+    child.once("error", fail);
+    child.once("exit", fail);
+    child.stdio[3].on("error", fail);
+  }
+  call(method, params = {}, sessionId) {
+    if (this.closed) return Promise.reject(new Error("The isolated browser is already closed."));
+    const id = this.nextId++;
+    return new Promise((resolvePromise, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`CDP ${method} timed out.`));
+      }, 15_000);
+      this.pending.set(id, { resolve: resolvePromise, reject, timer, method });
+      this.child.stdio[3].write(JSON.stringify({ id, method, params, ...(sessionId ? { sessionId } : {}) }) + "\0");
+    });
+  }
+  async evaluate(expression, sessionId) {
+    const response = await this.call("Runtime.evaluate", { expression, returnByValue: true, awaitPromise: true }, sessionId);
+    assert(!response.exceptionDetails, "Browser evaluation failed; inspect the candidate without dumping authenticated page content.");
+    return response.result?.value;
+  }
+}
+
+async function findChrome() {
+  const candidates = process.env.CHROME_BIN ? [process.env.CHROME_BIN] : ["/usr/bin/google-chrome", "/usr/bin/chromium"];
+  for (const path of candidates) {
+    try { await access(path, constants.X_OK); return path; } catch {}
+  }
+  throw new Error("No existing Chrome binary found. Browser-visible HMR is unverified; do not replace this with a server-only PASS.");
+}
+
+async function proveHmr(web, backupRoot, evidenceRoot, receiptRoot) {
+  const chrome = await findChrome();
+  const profile = await mkdtemp(join(tmpdir(), "spaceapp-dev-hmr-"));
+  const child = spawn(chrome, ["--headless=new", "--remote-debugging-pipe", `--user-data-dir=${profile}`, "--window-size=1280,900", "--no-first-run", "--no-default-browser-check", "--disable-background-networking", "--disable-component-update", "--disable-sync", "--disable-extensions", "--disable-default-apps", "--disable-dev-shm-usage", "about:blank"], {
+    // No inherited vault/provider credentials. Chromium keeps its normal sandbox.
+    env: { ...Object.fromEntries(["PATH", "LANG", "LC_ALL", "XDG_RUNTIME_DIR", "DBUS_SESSION_BUS_ADDRESS"].filter((key) => process.env[key]).map((key) => [key, process.env[key]])), HOME: profile, XDG_CONFIG_HOME: join(profile, "config"), XDG_CACHE_HOME: join(profile, "cache") },
+    stdio: ["ignore", "ignore", "pipe", "pipe", "pipe"]
+  });
+  let diagnostic = "";
+  child.stderr.on("data", bytes => { diagnostic = (diagnostic + bytes.toString()).slice(-4000); });
+  const cdp = new PipeCdp(child);
+  let edit;
+  let session;
+  let navigationCount = 0;
+  const hmrFrames = [];
+  try {
+    const version = await cdp.call("Browser.getVersion");
+    const target = await cdp.call("Target.createTarget", { url: "about:blank" });
+    session = (await cdp.call("Target.attachToTarget", { targetId: target.targetId, flatten: true })).sessionId;
+    cdp.handlers.add((message) => {
+      if (message.sessionId !== session) return;
+      if (message.method === "Page.frameNavigated" && !message.params?.frame?.parentId) navigationCount++;
+      if (message.method !== "Network.webSocketFrameReceived") return;
+      try {
+        const payload = JSON.parse(message.params.response.payloadData);
+        if (["update", "full-reload", "error"].includes(payload.type)) hmrFrames.push({ type: payload.type, paths: (payload.updates || []).map((entry) => entry.path) });
+      } catch {}
+    });
+    await cdp.call("Page.enable", {}, session);
+    await cdp.call("Runtime.enable", {}, session);
+    await cdp.call("Network.enable", {}, session);
+    // The anonymous page is allowed to load only this isolated stack.
+    await cdp.call("Fetch.enable", { patterns: [{ urlPattern: "*" }] }, session);
+    const allowed = new Set([web, new URL(web).origin]);
+    cdp.handlers.add((message) => {
+      if (message.sessionId !== session || message.method !== "Fetch.requestPaused") return;
+      const { requestId, request } = message.params;
+      const permitted = request.url.startsWith("data:") || request.url.startsWith("blob:") || allowed.has(new URL(request.url).origin);
+      void cdp.call(permitted ? "Fetch.continueRequest" : "Fetch.failRequest", permitted ? { requestId } : { requestId, errorReason: "BlockedByClient" }, session).catch(() => {});
+    });
+    await cdp.call("Page.navigate", { url: web }, session);
+    const view = () => cdp.evaluate(`(() => {
+      const brand = document.querySelector('.login-brand');
+      const field = document.querySelector('#operator-email');
+      const box = brand?.getBoundingClientRect();
+      return { label: brand?.innerText || '', email: field?.value || '', nonce: window.__devStackHmrNonce,
+        timeOrigin: performance.timeOrigin, visible: !!box && box.width > 0 && box.height > 0 && getComputedStyle(brand).visibility !== 'hidden' };
+    })()`, session);
+    await until("Real login screen", async () => { const state = await view(); return state.visible && state.label.includes("Sign in to Space") && state; });
+    const nonce = randomUUID();
+    const email = `hmr-state-${nonce}@example.invalid`;
+    await cdp.evaluate(`window.__devStackHmrNonce = ${JSON.stringify(nonce)}; document.querySelector('#operator-email').focus();`, session);
+    await cdp.call("Input.insertText", { text: email }, session);
+    const before = await view();
+    assert.equal(before.email, email);
+    const baselineNavigations = navigationCount;
+    const frameStart = hmrFrames.length;
+    const screenshot = async (name) => {
+      const clip = await cdp.evaluate(`(() => { const b=document.querySelector('.login-brand').getBoundingClientRect(); return {x:b.x,y:b.y,width:b.width,height:b.height,scale:1}; })()`, session);
+      const result = await cdp.call("Page.captureScreenshot", { format: "png", clip, captureBeyondViewport: false }, session);
+      await writeFile(join(evidenceRoot, name), Buffer.from(result.data, "base64"), { mode: 0o600 });
+    };
+    await screenshot("hmr-before.png");
+    const marker = `hmr-${randomUUID()}`;
+    edit = await editSource("apps/web/src/features/auth/LoginScreen.tsx", (text) => replaceOnce(text, '"Sign in to Space"', JSON.stringify(`Sign in to Space ${marker}`)), backupRoot, root, receiptRoot);
+    await until("Browser DOM hot update", async () => { const state = await view(); return state.visible && state.label.includes(marker) && state; });
+    const assertSamePage = async () => {
+      const state = await view();
+      assert.equal(state.nonce, nonce, "A full page reload cannot satisfy HMR.");
+      assert.equal(state.timeOrigin, before.timeOrigin);
+      assert.equal(navigationCount, baselineNavigations);
+      assert.equal(state.email, email, "React Refresh must preserve controlled input state.");
+    };
+    await assertSamePage();
+    const changedFrames = hmrFrames.slice(frameStart);
+    assert(changedFrames.some((frame) => frame.type === "update" && frame.paths.some((path) => /\/LoginScreen\.(tsx|js)(\?|$)/.test(path))), "No matching real Vite-client update frame was observed.");
+    assert(!changedFrames.some((frame) => ["error", "full-reload"].includes(frame.type)), "Vite error/full reload is not HMR success.");
+    await screenshot("hmr-after.png");
+    await edit.restore();
+    await until("Browser reverse hot update", async () => { const state = await view(); return state.visible && state.label.includes("Sign in to Space") && !state.label.includes(marker); });
+    await assertSamePage();
+    await screenshot("hmr-restored.png");
+    receipts.push({ probe: "real-browser-vite-hmr", browser: version.product, sameDocument: true, inputStateRetained: true, reverseUpdateObserved: true, sourceRestoredHash: edit.originalHash });
+    console.log("[dev-stack-change-probes] PASS real browser DOM HMR, same document and state, reverse HMR, original bytes restored");
+  } catch (error) {
+    throw new Error(`${error.message}${diagnostic ? ` Browser diagnostic: ${diagnostic.trim()}` : ""}`);
+  } finally {
+    try { await edit?.restore(); }
+    finally {
+      await cdp.call("Browser.close").catch(() => {});
+      if (child.exitCode === null && child.signalCode === null) child.kill("SIGTERM");
+      await until("Isolated browser exit", () => child.exitCode !== null || child.signalCode !== null, 10_000);
+      await rm(profile, { recursive: true, force: true });
+    }
+  }
+}
+
+async function main() {
+  checkRunner();
+  const evidenceRoot = resolve(process.env.SPACE_DEV_EVIDENCE_DIR || join(process.env.RUNNER_TEMP, "dev-stack-acceptance-evidence"));
+  const backupRoot = await mkdtemp(join(process.env.RUNNER_TEMP, "dev-stack-source-backup-"));
+  const receiptRoot = join(process.env.RUNNER_TEMP, "dev-stack-source-edit-receipts");
+  await mkdir(evidenceRoot, { recursive: true, mode: 0o700 });
+  const git = async (...args) => (await exec("git", args, { cwd: root })).stdout.trim();
+  const sha = await git("rev-parse", "HEAD");
+  const baselineStatus = await git("status", "--porcelain=v1");
+  await git("diff", "--exit-code", "--", "apps/api/src/health-routes.ts", "apps/web/src/features/auth/LoginScreen.tsx");
+  const lib = await import(pathToFileURL(join(root, "deploy/docker/dev-stack-lib.mjs")).href);
+  const safety = await import(pathToFileURL(join(root, "deploy/docker/dev-stack-safety.mjs")).href);
+  safety.assertSafeDevStackOverrides();
+  const config = await lib.resolveConfig(process.env, root);
+  const persistedConfig = JSON.parse(await readFile(config.configFile, "utf8"));
+  for (const key of ["root", "stateRoot", "project", "ports"]) assert.deepEqual(persistedConfig[key], config[key], `Running config ${key} differs from this checkout's selected configuration.`);
+  const ownership = await safety.readStateOwnership(config);
+  const api = `http://127.0.0.1:${config.ports.api}`;
+  const web = `http://127.0.0.1:${config.ports.web}`;
+  const groups = async () => (await safety.readProcessRecords(config, ownership)).filter((entry) => ["api", "web", "worker", "cli-host"].includes(entry.name)).sort((a, b) => a.name.localeCompare(b.name));
+  const supervisor = await safety.ownedSupervisorPid(config);
+  assert(supervisor, "A verified source-stack supervisor must already be running.");
+  const baselineGroups = await groups();
+  assert.equal(baselineGroups.length, 4);
+  const initial = await until("Initial complete readiness", async () => { const body = await json(`${api}/readyz`); return ready(body) && body; });
+  const marker = `api-watch-${randomUUID()}`;
+  const expectedPackageProbe = process.env.SPACE_DEV_EXPECTED_PACKAGE_PROBE || null;
+  if (expectedPackageProbe) assert(/^dev_stack_rebuild_[A-Za-z0-9_]+$/.test(expectedPackageProbe), "Unexpected package-probe marker format.");
+  let edit;
+  let observedStart;
+  let passed = false;
+  try {
+    try {
+      edit = await editSource("apps/api/src/health-routes.ts", (text) => {
+        const updated = replaceOnce(text,
+          'async () => ({ ok: true, service: "space-api" })',
+          `async () => ({ ok: true, service: "space-api", devStackWatchProbe: ${JSON.stringify(marker)}, devStackWatchPid: process.pid${expectedPackageProbe ? ", devStackPackageProbe: __devStackRebuildProbe" : ""} })`);
+        return expectedPackageProbe ? 'import { __devStackRebuildProbe } from "@space/contracts";\n' + updated : updated;
+      }, backupRoot, root, receiptRoot);
+      await until("API source watch marker", async () => {
+        const [health, body] = await Promise.all([json(`${api}/healthz`), json(`${api}/readyz`)]);
+        if (health?.devStackWatchProbe === marker && (!expectedPackageProbe || health.devStackPackageProbe === expectedPackageProbe) && Number.isInteger(health.devStackWatchPid) && health.devStackWatchPid > 1 && ready(body) && body.apiStartedAt !== initial.apiStartedAt) {
+          observedStart = body.apiStartedAt;
+          return true;
+        }
+        return false;
+      });
+      assert.equal(await safety.ownedSupervisorPid(config), supervisor);
+      assert.deepEqual(await groups(), baselineGroups, "API watch must not restart the source-stack group leaders.");
+    } finally { await edit?.restore(); }
+    await until("API restoration watch", async () => {
+      const [health, body] = await Promise.all([json(`${api}/healthz`), json(`${api}/readyz`)]);
+      return health?.ok === true && !Object.hasOwn(health, "devStackWatchProbe") && ready(body) && body.apiStartedAt !== observedStart;
+    });
+    assert.equal(await safety.ownedSupervisorPid(config), supervisor);
+    assert.deepEqual(await groups(), baselineGroups);
+    receipts.push({ probe: "api-source-watch", markerObserved: true, restartObserved: true, reverseRestartObserved: true, sourceRestoredHash: edit.originalHash });
+    if (expectedPackageProbe) receipts.push({ probe: "shared-package-runtime-import", importedMarkerObservedOverHttp: true });
+    console.log("[dev-stack-change-probes] PASS API source watch restart and restoration, same stack supervisor and service leaders");
+    await proveHmr(web, backupRoot, evidenceRoot, receiptRoot);
+    assert.equal(await git("rev-parse", "HEAD"), sha);
+    assert.equal(await git("status", "--porcelain=v1"), baselineStatus, "Probe must leave candidate status exactly as found.");
+    passed = true;
+  } finally {
+    await writeFile(join(evidenceRoot, "hotreload-receipt.json"), JSON.stringify({ candidateSha: sha, passed, receipts }, null, 2) + "\n", { mode: 0o600 });
+    // A nonempty backup directory is intentionally retained for safe manual recovery.
+    await rmdir(backupRoot).catch(() => {});
+  }
+}
+
+if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  main().catch((error) => { console.error(`[dev-stack-change-probes] FAIL ${error.message}`); process.exitCode = 1; });
+}
diff --git a/deploy/docker/dev-stack-lib.mjs b/deploy/docker/dev-stack-lib.mjs
new file mode 100644
index 000000000..411434ebc
--- /dev/null
+++ b/deploy/docker/dev-stack-lib.mjs
@@ -0,0 +1,391 @@
+import { createHash, randomBytes } from "node:crypto";
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { chmod, lstat, mkdir, readFile, readdir, realpath, rm, stat, writeFile } from "node:fs/promises";
+import { homedir, tmpdir } from "node:os";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const here = dirname(fileURLToPath(import.meta.url));
+export const repoRoot = resolve(here, "../..");
+export const sleep = (ms) => new Promise((resolvePromise) => setTimeout(resolvePromise, ms));
+
+function parsePort(raw, fallback, name) {
+  const value = raw == null || raw === "" ? fallback : Number(raw);
+  if (!Number.isInteger(value) || value < 1024 || value > 65535) {
+    throw new Error(`${name} must be an integer port between 1024 and 65535.`);
+  }
+  return value;
+}
+
+function inside(parent, child) {
+  const rel = relative(parent, child);
+  return rel === "" || (!rel.startsWith(`..${sep}`) && rel !== ".." && !isAbsolute(rel));
+}
+
+export async function assertSafeStateRoot(stateRoot, root = repoRoot) {
+  const value = resolve(stateRoot);
+  const repo = resolve(root);
+  const home = resolve(homedir());
+  if (value === resolve(sep) || value === repo || value === home) throw new Error(`Unsafe dev-stack state directory: ${value}`);
+  if (inside(value, repo) && value !== repo) throw new Error("The dev-stack state directory may not be an ancestor of the repository.");
+  if (existsSync(value) && (await lstat(value)).isSymbolicLink()) throw new Error("The dev-stack state directory may not be a symlink.");
+  return value;
+}
+
+export function parsePinnedImages(text) {
+  const postgres = text.match(/image:\s*(pgvector\/pgvector:[^\s]+@sha256:[a-f0-9]{64})/i)?.[1];
+  const temporal = text.match(/image:\s*(temporalio\/auto-setup:[^\s]+@sha256:[a-f0-9]{64})/i)?.[1];
+  if (!postgres || !temporal) throw new Error("Could not read digest-pinned PostgreSQL and Temporal images from the launcher Compose template.");
+  return { postgres, temporal };
+}
+
+export function parseOpenCodeVersion(text) {
+  const version = text.match(/opencode-ai@([0-9]+\.[0-9]+\.[0-9]+)/)?.[1];
+  if (!version) throw new Error("Could not read the pinned opencode-ai version from Dockerfile.");
+  return version;
+}
+
+export async function resolveConfig(env = process.env, root = repoRoot) {
+  const rootHash = createHash("sha256").update(await realpath(root)).digest("hex").slice(0, 10);
+  const stateRoot = await assertSafeStateRoot(env.SPACE_DEV_STACK_DIR || join(root, ".dev-stack"), root);
+  const ports = {
+    api: parsePort(env.SPACE_DEV_API_PORT, 5910, "SPACE_DEV_API_PORT"),
+    web: parsePort(env.SPACE_DEV_WEB_PORT, 5911, "SPACE_DEV_WEB_PORT"),
+    postgres: parsePort(env.SPACE_DEV_POSTGRES_PORT, 55432, "SPACE_DEV_POSTGRES_PORT"),
+    temporal: parsePort(env.SPACE_DEV_TEMPORAL_PORT, 57233, "SPACE_DEV_TEMPORAL_PORT")
+  };
+  const seen = new Map();
+  for (const [name, value] of Object.entries(ports)) {
+    if (seen.has(value)) throw new Error(`${name} conflicts with ${seen.get(value)} on port ${value}.`);
+    seen.set(value, name);
+  }
+  for (const [name, value] of Object.entries(ports)) {
+    if (value === 4910 || value === 4911) throw new Error(`${name} port ${value} is reserved for an installed SpaceApp.`);
+  }
+  const project = env.SPACE_DEV_COMPOSE_PROJECT || `spaceapp-dev-${rootHash}`;
+  if (!/^[a-z0-9][a-z0-9_-]{2,50}$/i.test(project)) throw new Error("SPACE_DEV_COMPOSE_PROJECT contains unsupported characters.");
+  const preferredSocket = join(stateRoot, "run", "cli-host.sock");
+  const socketPath = Buffer.byteLength(preferredSocket) <= 96 ? preferredSocket : join(tmpdir(), `spaceapp-dev-${rootHash}`, "cli-host.sock");
+  if (Buffer.byteLength(socketPath) > 96) {
+    throw new Error(`Unix socket path exceeds the 96-byte limit after fallback (${Buffer.byteLength(socketPath)} bytes). Set TMPDIR to a shorter directory and retry.`);
+  }
+  return {
+    root, rootHash, stateRoot, project, ports, socketPath,
+    composeFile: join(stateRoot, "compose.yml"),
+    configFile: join(stateRoot, "config.json"),
+    ownerFile: join(stateRoot, "ownership.json"),
+    pidFile: join(stateRoot, "supervisor.pid"),
+    processFile: join(stateRoot, "process-groups.json"),
+    buildMarker: join(stateRoot, "build-marker.json"),
+    secretsDir: join(stateRoot, "secrets"),
+    binDir: join(stateRoot, "bin"),
+    vendorDir: join(stateRoot, "vendor", "opencode"),
+    providerRoot: join(stateRoot, "providers", "opencode"),
+    workspacesRoot: join(stateRoot, "workspaces"),
+    memoryRoot: join(stateRoot, "memory"),
+    memoryGraphRoot: join(stateRoot, "memory-graph"),
+    artifactRoot: join(stateRoot, "artifacts"),
+    projectsRoot: join(stateRoot, "projects"),
+    diagnosticsRoot: join(stateRoot, "diagnostics"),
+    openCodeChatRoot: join(stateRoot, "opencode-chat")
+  };
+}
+
+export function renderCompose(config, images, ownership) {
+  if (!ownership?.token) throw new Error("Dev-stack ownership token is required to render Compose resources.");
+  const ownerLabel = `com.spaceapp.dev-stack.owner: ${ownership.token}`;
+  return `services:\n  postgres:\n    image: ${images.postgres}\n    restart: unless-stopped\n    labels:\n      ${ownerLabel}\n    environment:\n      POSTGRES_DB: spaceapp_dev\n      POSTGRES_USER: spaceapp\n      POSTGRES_PASSWORD: \${SPACEAPP_DEV_POSTGRES_PASSWORD:-dev-stack-password-not-supplied}\n    ports:\n      - \"127.0.0.1:${config.ports.postgres}:5432\"\n    volumes:\n      - postgres-data:/var/lib/postgresql/data\n    healthcheck:\n      test: [\"CMD-SHELL\", \"pg_isready -U spaceapp -d spaceapp_dev\"]\n      interval: 2s\n      timeout: 3s\n      retries: 30\n  temporal:\n    image: ${images.temporal}\n    restart: unless-stopped\n    labels:\n      ${ownerLabel}\n    depends_on:\n      postgres:\n        condition: service_healthy\n    environment:\n      DB: postgres12\n      DB_PORT: 5432\n      POSTGRES_USER: spaceapp\n      POSTGRES_SEEDS: postgres\n      POSTGRES_PWD: \${SPACEAPP_DEV_POSTGRES_PASSWORD:-dev-stack-password-not-supplied}\n      DYNAMIC_CONFIG_FILE_PATH: config/dynamicconfig/docker.yaml\n    ports:\n      - \"127.0.0.1:${config.ports.temporal}:7233\"\n    healthcheck:\n      test: [\"CMD-SHELL\", \"temporal operator cluster health --address temporal:7233 >/dev/null && temporal operator namespace describe --namespace default --address temporal:7233 >/dev/null\"]\n      interval: 3s\n      timeout: 5s\n      retries: 40\nvolumes:\n  postgres-data:\n    labels:\n      ${ownerLabel}\nnetworks:\n  default:\n    labels:\n      ${ownerLabel}\n`;
+}
+
+export async function run(command, args, { capture = false, allowFailure = false, env = process.env, cwd = repoRoot } = {}) {
+  return new Promise((resolvePromise, rejectPromise) => {
+    const child = spawn(command, args, { cwd, env, stdio: capture ? ["ignore", "pipe", "pipe"] : "inherit" });
+    let stdout = "";
+    let stderr = "";
+    if (capture) {
+      child.stdout.on("data", (chunk) => { stdout += chunk.toString(); });
+      child.stderr.on("data", (chunk) => { stderr += chunk.toString(); });
+    }
+    child.once("error", rejectPromise);
+    child.once("close", (code, signal) => {
+      const result = { code: code ?? 1, signal, stdout: stdout.trim(), stderr: stderr.trim() };
+      if (!allowFailure && code !== 0) rejectPromise(new Error(`${command} ${args.join(" ")} failed (${code ?? signal}).${stderr ? `\n${stderr}` : ""}`));
+      else resolvePromise(result);
+    });
+  });
+}
+
+export function composeArgs(config, ...args) {
+  return ["compose", "-p", config.project, "-f", config.composeFile, ...args];
+}
+export const compose = (config, args, options = {}) => run("docker", composeArgs(config, ...args), options);
+
+async function privateFile(path, value) {
+  if (!existsSync(path)) await writeFile(path, `${value}\n`, { mode: 0o600, flag: "wx" });
+  await chmod(path, 0o600);
+}
+
+export async function prepareState(config) {
+  for (const path of [config.stateRoot, config.secretsDir, dirname(config.socketPath), config.binDir, config.vendorDir, config.providerRoot,
+    config.workspacesRoot, config.memoryRoot, config.memoryGraphRoot, config.artifactRoot, config.projectsRoot, config.diagnosticsRoot, config.openCodeChatRoot]) {
+    await mkdir(path, { recursive: true, mode: 0o700 });
+  }
+  await privateFile(join(config.secretsDir, "postgres-password"), randomBytes(24).toString("base64url"));
+  await privateFile(join(config.secretsDir, "session-secret"), randomBytes(32).toString("hex"));
+  await privateFile(join(config.secretsDir, "setup-token"), randomBytes(32).toString("hex"));
+  const postgresPassword = (await readFile(join(config.secretsDir, "postgres-password"), "utf8")).trim();
+  const sessionSecret = (await readFile(join(config.secretsDir, "session-secret"), "utf8")).trim();
+  const databaseUrl = `postgresql://spaceapp:${encodeURIComponent(postgresPassword)}@127.0.0.1:${config.ports.postgres}/spaceapp_dev`;
+  await writeFile(join(config.secretsDir, "database-url"), `${databaseUrl}\n`, { mode: 0o600 });
+  await chmod(join(config.secretsDir, "database-url"), 0o600);
+  return { databaseUrl, sessionSecret, postgresPassword };
+}
+
+async function buildSourceFingerprint(root) {
+  const inputs = [];
+  const visit = async (path) => {
+    if (!existsSync(path)) return;
+    const info = await stat(path);
+    if (!info.isDirectory()) {
+      inputs.push([relative(root, path), info.mtimeMs, info.size]);
+      return;
+    }
+    for (const name of (await readdir(path)).sort()) {
+      if (["node_modules", "dist", "coverage"].includes(name)) continue;
+      await visit(join(path, name));
+    }
+  };
+  await visit(join(root, "packages"));
+  await visit(join(root, "apps", "worker", "src"));
+  // Building creates excluded output directories, which changes parent directory
+  // mtimes. Hash source file identities instead, including paths to detect deletes.
+  return createHash("sha256").update(JSON.stringify(inputs)).digest("hex");
+}
+
+export async function ensureBuild(config, force = false, runner = run) {
+  if (process.env.SPACE_DEV_SKIP_BUILD === "true" && !force) return;
+  const artifacts = ["packages/contracts/dist/index.js", "packages/runtime/dist/index.js", "packages/db/dist/migrate.js", "packages/cli-host/dist/main.js", "apps/worker/dist/worker.js"].map((p) => join(config.root, p));
+  const marker = existsSync(config.buildMarker) ? JSON.parse(await readFile(config.buildMarker, "utf8")) : null;
+  const sourceFingerprint = await buildSourceFingerprint(config.root);
+  if (!force && process.env.SPACE_DEV_FORCE_BUILD !== "true" && marker && artifacts.every(existsSync) && sourceFingerprint === marker.sourceFingerprint) return;
+  const buildStartedAt = Date.now();
+  console.log(`[dev:stack] Building source workspaces before migrations... started at ${new Date(buildStartedAt).toISOString()}`);
+  await runner("npm", ["run", "build"], { cwd: config.root });
+  await writeFile(config.buildMarker, `${JSON.stringify({ sourceFingerprint, builtAt: new Date().toISOString() }, null, 2)}\n`, { mode: 0o600 });
+  console.log(`[dev:stack] Source workspace build completed at ${new Date().toISOString()} (${Math.round((Date.now() - buildStartedAt) / 1000)}s).`);
+}
+
+export async function installOpenCode(config, version, runner = run) {
+  const packageJson = join(config.vendorDir, "node_modules", "opencode-ai", "package.json");
+  let installed = null;
+  if (existsSync(packageJson)) {
+    try { installed = JSON.parse(await readFile(packageJson, "utf8")).version; } catch {}
+  }
+  if (installed !== version) {
+    await rm(config.vendorDir, { recursive: true, force: true });
+    await mkdir(config.vendorDir, { recursive: true, mode: 0o700 });
+    console.log(`[dev:stack] Installing pinned opencode-ai@${version} into dev state...`);
+    await runner("npm", ["install", "--prefix", config.vendorDir, "--no-package-lock", "--no-save", "--no-audit", "--no-fund", `opencode-ai@${version}`]);
+  }
+  const wrapper = join(config.binDir, "opencode-vscode-parity");
+  const binary = join(config.vendorDir, "node_modules", ".bin", "opencode");
+  // The API supplies installed-runtime paths to CLI panes; override them at
+  // the executable boundary so source runs never write to an installed instance.
+  const shellQuote = (value) => `'${value.replaceAll("'", "'\\''")}'`;
+  const paths = {
+    HOME: join(config.providerRoot, "home"),
+    XDG_CONFIG_HOME: join(config.providerRoot, "config"),
+    XDG_DATA_HOME: join(config.providerRoot, "data"),
+    XDG_CACHE_HOME: join(config.providerRoot, "cache"),
+    XDG_STATE_HOME: join(config.providerRoot, "state"),
+    TMPDIR: join(config.providerRoot, "tmp")
+  };
+  const exports = Object.entries(paths).map(([key, value]) => `export ${key}=${shellQuote(value)}`);
+  await writeFile(wrapper, [
+    "#!/bin/sh", "set -eu", "umask 077", ...exports,
+    'export TMP="$TMPDIR" TEMP="$TMPDIR"',
+    "unset OPENCODE_API_KEY",
+    'mkdir -p "$HOME" "$XDG_CONFIG_HOME" "$XDG_DATA_HOME" "$XDG_CACHE_HOME" "$XDG_STATE_HOME" "$TMPDIR"',
+    `exec ${shellQuote(binary)} "$@"`, ""
+  ].join("\n"), { mode: 0o700 });
+  await chmod(wrapper, 0o700);
+  return wrapper;
+}
+
+export async function waitHealthy(config, service, timeoutMs = 120_000) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const id = (await compose(config, ["ps", "-q", service], { capture: true })).stdout;
+    if (id) {
+      const status = await run("docker", ["inspect", "--format", "{{if .State.Health}}{{.State.Health.Status}}{{else}}{{.State.Status}}{{end}}", id], { capture: true, allowFailure: true });
+      if (status.stdout === "healthy") return;
+      if (["unhealthy", "exited", "dead"].includes(status.stdout)) throw new Error(`${service} became ${status.stdout}.`);
+    }
+    await sleep(1000);
+  }
+  throw new Error(`${service} did not become healthy within ${Math.round(timeoutMs / 1000)} seconds.`);
+}
+
+export async function ensureTemporalNamespace(config) {
+  const base = ["exec", "-T", "temporal", "temporal", "operator", "namespace"];
+  const described = await compose(config, [...base, "describe", "--namespace", "spaceapp-dev", "--address", "temporal:7233"], { capture: true, allowFailure: true });
+  if (described.code !== 0) await compose(config, [...base, "create", "--namespace", "spaceapp-dev", "--address", "temporal:7233"]);
+}
+
+export function sourceEnv(config, databaseUrl, sessionSecret, openCodeWrapper) {
+  // Source services need the host's executable lookup and basic OS/temp/locale
+  // settings. Do not inherit arbitrary user variables: provider credentials
+  // have many names and a denylist inevitably misses some of them.
+  const inheritedKeys = new Set(["PATH", "HOME", "TMPDIR", "TMP", "TEMP", "SYSTEMROOT", "WINDIR", "COMSPEC", "PATHEXT", "LANG", "TZ"]);
+  const env = Object.fromEntries(Object.entries(process.env).filter(([key]) => inheritedKeys.has(key) || key.startsWith("LC_")));
+  if (openCodeWrapper !== join(config.binDir, "opencode-vscode-parity")) {
+    throw new Error("OpenCode wrapper must live inside the controlled dev-stack command directory.");
+  }
+  return {
+    ...env,
+    SPACE_INSTANCE: "dev",
+    SPACE_INSTALL_ROOT: config.root,
+    SPACE_RUNTIME_STORE: "postgres",
+    SPACE_DATABASE_URL: databaseUrl,
+    SPACE_SESSION_SECRET: sessionSecret,
+    SPACE_SETUP_TOKEN_FILE: join(config.secretsDir, "setup-token"),
+    SPACE_STREAMING_SECRET_ROOT: join(config.secretsDir, "streaming"),
+    SPACE_DEV_LOGIN: "false",
+    SPACE_GOOGLE_AUTH_DISABLED: "true",
+    SPACE_PUBLIC_DISTRIBUTION: "true",
+    SPACE_OPTIONAL_MODULES: "none",
+    SPACEAPP_WORKFLOWS_ENABLED: "true",
+    SPACE_API_HOST: "127.0.0.1",
+    SPACE_API_PORT: String(config.ports.api),
+    SPACE_WEB_HOST: "127.0.0.1",
+    SPACE_WEB_PORT: String(config.ports.web),
+    SPACE_API_ORIGIN: `http://127.0.0.1:${config.ports.api}`,
+    SPACE_TEMPORAL_ADDRESS: `127.0.0.1:${config.ports.temporal}`,
+    SPACE_TEMPORAL_NAMESPACE: "spaceapp-dev",
+    SPACE_TEMPORAL_TASK_QUEUE: "space-dev-agent-turns",
+    SPACE_CLI_ENABLED: "true",
+    SPACE_CLI_HOST_SOCKET: config.socketPath,
+    SPACE_CLI_COMMAND_PATH: config.binDir,
+    SPACE_CLI_OPENCODE_COMMAND: "opencode-vscode-parity",
+    SPACE_CLI_WORKSPACE_ROOT: config.workspacesRoot,
+    SPACE_CLI_ROOT_ENABLED: "false",
+    SPACE_BROWSER_SESSIONS_ENABLED: "false",
+    SPACE_BROWSER_HOST_TRANSPORT: "in-process",
+    SPACE_MEMORY_ROOT: config.memoryRoot,
+    SPACE_MEMORY_GRAPH_ROOT: config.memoryGraphRoot,
+    SPACE_ARTIFACT_ROOT: config.artifactRoot,
+    SPACE_PROJECTS_ROOT: config.projectsRoot,
+    SPACE_APP_DIAGNOSTICS_ROOT: config.diagnosticsRoot,
+    SPACE_OPENCODE_CHAT_STATE_ROOT: config.openCodeChatRoot,
+    SPACE_ENABLE_DUMMY_TURNS: "false",
+    SPACE_ROOM_AGENT_AUTOPILOT_ENABLED: "false"
+  };
+}
+
+// The API/database is authoritative for whether the one-time setup token is
+// usable. The local secret file persists after the owner claims it and must not
+// be printed again on a normal source-stack restart.
+export async function ownerSetupBanner(config, {
+  request = fetch,
+  readSecret = readFile,
+  nowMs = Date.now()
+} = {}) {
+  const response = await request(`http://127.0.0.1:${config.ports.api}/api/setup/status`, {
+    method: "GET",
+    headers: { accept: "application/json" },
+    redirect: "error",
+    signal: AbortSignal.timeout(5000)
+  });
+  if (!response?.ok) {
+    throw new Error(`Could not verify dev-stack owner setup status (HTTP ${response?.status ?? "unknown"}); refusing to print a token.`);
+  }
+  const status = await response.json();
+  if (!status || typeof status !== "object" || typeof status.setupRequired !== "boolean"
+    || (status.expiresAt !== null && typeof status.expiresAt !== "string")) {
+    throw new Error("Invalid dev-stack owner setup status; refusing to print a token.");
+  }
+  if (!status.setupRequired) {
+    return "Owner setup already complete; sign in with the existing owner account.";
+  }
+
+  const expiresAtMs = Date.parse(status.expiresAt ?? "");
+  if (!Number.isFinite(expiresAtMs) || expiresAtMs <= nowMs) {
+    return "Owner setup token expired or unavailable; no token will be printed. Verify the setup status before attempting first-owner setup.";
+  }
+  const token = (await readSecret(join(config.secretsDir, "setup-token"), "utf8")).trim();
+  if (!/^[a-f0-9]{64}$/.test(token)) {
+    throw new Error("Invalid dev-stack owner setup token file; refusing to print its content.");
+  }
+  return `Owner setup token: ${token}`;
+}
+
+export async function waitReady(config, timeoutMs = 120_000) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    try {
+      // A server may accept a connection but never answer. Bound both
+      // headers and response-body reads, then honor the overall deadline.
+      const remainingMs = Math.max(1, deadline - Date.now());
+      const response = await fetch(`http://127.0.0.1:${config.ports.api}/readyz`, {
+        signal: AbortSignal.timeout(Math.min(5_000, remainingMs))
+      });
+      if (response.ok) {
+        const body = await response.json();
+        if (body.ok === true && body.dependencies?.database === "RUNNING" && body.dependencies?.worker === "RUNNING" && body.dependencies?.cliHost === "RUNNING") return body;
+      }
+    } catch {}
+    const remainingMs = Math.max(0, deadline - Date.now());
+    if (remainingMs > 0) await sleep(Math.min(500, remainingMs));
+  }
+  throw new Error("The source stack did not reach /readyz with database, worker and CLI host RUNNING.");
+}
+
+export function pidAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 1) return false;
+  try { process.kill(pid, 0); return true; }
+  catch (error) { if (error?.code === "ESRCH") return false; throw error; }
+}
+
+export async function readSupervisorPid(config) {
+  if (!existsSync(config.pidFile)) return null;
+  const value = Number.parseInt((await readFile(config.pidFile, "utf8")).trim(), 10);
+  return Number.isInteger(value) ? value : null;
+}
+
+function splitLines(value) {
+  return value.split(/\s+/).filter(Boolean);
+}
+
+async function dockerList(runner, args, kind) {
+  const result = await runner("docker", args, { capture: true, allowFailure: true });
+  if (result.code !== 0) throw new Error(`Docker inventory failed while listing dev-stack ${kind}; state was preserved for recovery.`);
+  return splitLines(result.stdout);
+}
+
+function sameSet(left, right) {
+  return left.length === right.length && [...left].sort().every((value, index) => value === [...right].sort()[index]);
+}
+
+export async function dockerResources(config, ownership = null, runner = run) {
+  const projectFilter = `label=com.docker.compose.project=${config.project}`;
+  const all = {
+    containers: await dockerList(runner, ["ps", "-aq", "--filter", projectFilter], "containers"),
+    volumes: await dockerList(runner, ["volume", "ls", "-q", "--filter", projectFilter], "volumes"),
+    networks: await dockerList(runner, ["network", "ls", "-q", "--filter", projectFilter], "networks")
+  };
+  if (!ownership) return all;
+
+  const ownerFilter = `label=com.spaceapp.dev-stack.owner=${ownership.token}`;
+  const owned = {
+    containers: await dockerList(runner, ["ps", "-aq", "--filter", projectFilter, "--filter", ownerFilter], "owned containers"),
+    volumes: await dockerList(runner, ["volume", "ls", "-q", "--filter", projectFilter, "--filter", ownerFilter], "owned volumes"),
+    networks: await dockerList(runner, ["network", "ls", "-q", "--filter", projectFilter, "--filter", ownerFilter], "owned networks")
+  };
+  for (const kind of ["containers", "volumes", "networks"]) {
+    if (!sameSet(all[kind], owned[kind])) {
+      throw new Error(`Refusing cleanup: Compose project ${config.project} contains ${kind} that are not proven to belong to this dev-stack state.`);
+    }
+  }
+  return owned;
+}
diff --git a/deploy/docker/dev-stack-probes.test.mjs b/deploy/docker/dev-stack-probes.test.mjs
new file mode 100644
index 000000000..bc6e0110a
--- /dev/null
+++ b/deploy/docker/dev-stack-probes.test.mjs
@@ -0,0 +1,163 @@
+import assert from "node:assert/strict";
+import { spawn } from "node:child_process";
+import { EventEmitter, once } from "node:events";
+import { existsSync } from "node:fs";
+import { chmod, mkdir, mkdtemp, readFile, rm, stat, symlink, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { PassThrough } from "node:stream";
+import test from "node:test";
+import { editSource, PipeCdp, replaceOnce, restoreSourceEdit } from "./dev-stack-hotreload.mjs";
+import { killOwnedWorkerWithPidfd } from "./dev-stack-worker-probe.mjs";
+
+async function fixture() {
+  const root = await mkdtemp(join(tmpdir(), "spaceapp-probe-test-"));
+  const backupRoot = join(root, "backup");
+  await mkdir(backupRoot);
+  const path = join(root, "source.ts");
+  await writeFile(path, "// before\r\nexport const unicode = 'こんにちは';\r\n", { mode: 0o640 });
+  await chmod(path, 0o640);
+  return { root, path, backupRoot };
+}
+
+test("source anchors fail closed on missing or ambiguous matches", () => {
+  assert.equal(replaceOnce("before", "before", "after"), "after");
+  assert.throws(() => replaceOnce("absent", "before", "after"), /exactly once/);
+  assert.throws(() => replaceOnce("before before", "before", "after"), /exactly once/);
+});
+
+test("source edits restore exact bytes and permissions across serialized receipts", async () => {
+  const { root, path, backupRoot } = await fixture();
+  try {
+    const original = await readFile(path);
+    const edit = await editSource("source.ts", text => text.replace("before", "after"), backupRoot, root);
+    assert.match(await readFile(path, "utf8"), /after/);
+    assert.equal((await stat(edit.backup)).mode & 0o777, 0o600);
+    assert.equal((await stat(path)).mode & 0o777, 0o640);
+    await restoreSourceEdit(JSON.parse(JSON.stringify(edit)));
+    assert.deepEqual(await readFile(path), original);
+    assert.equal((await stat(path)).mode & 0o777, 0o640);
+    assert.equal(existsSync(edit.backup), false);
+  } finally { await rm(root, { recursive: true, force: true }); }
+});
+
+test("restoration preserves concurrent edits and retains its recovery backup", async () => {
+  const { root, path, backupRoot } = await fixture();
+  try {
+    const original = await readFile(path);
+    const edit = await editSource("source.ts", text => text.replace("before", "after"), backupRoot, root);
+    const edited = await readFile(path);
+    await writeFile(path, "// concurrent edit\n");
+    await assert.rejects(() => edit.restore(), /Concurrent modification/);
+    assert.equal(await readFile(path, "utf8"), "// concurrent edit\n");
+    assert.deepEqual(await readFile(edit.backup), original);
+    await writeFile(path, edited);
+    await edit.restore();
+    await edit.restore();
+    assert.deepEqual(await readFile(path), original);
+  } finally { await rm(root, { recursive: true, force: true }); }
+});
+
+test("durable source receipts recover an interrupted editor without its finally block", { timeout: 5000 }, async () => {
+  const { root, path, backupRoot } = await fixture();
+  const receiptRoot = join(root, "receipts");
+  let editor;
+  try {
+    const original = await readFile(path);
+    const script = join(root, "editor.mjs");
+    await writeFile(script, `
+      import { editSource } from ${JSON.stringify(new URL("./dev-stack-hotreload.mjs", import.meta.url).href)};
+      await editSource("source.ts", text => text.replace("before", "after"), ${JSON.stringify(backupRoot)}, ${JSON.stringify(root)}, ${JSON.stringify(receiptRoot)});
+      process.send("edited");
+      setInterval(() => {}, 1000);
+    `);
+    editor = spawn(process.execPath, [script], { stdio: ["ignore", "ignore", "ignore", "ipc"] });
+    await once(editor, "message");
+    const exited = once(editor, "exit");
+    editor.kill("SIGTERM");
+    await exited;
+    assert.equal(editor.signalCode, "SIGTERM");
+    assert.match(await readFile(path, "utf8"), /after/);
+    const receiptFile = join(receiptRoot, "source.ts.json");
+    const receipt = JSON.parse(await readFile(receiptFile, "utf8"));
+    assert.equal((await stat(receiptFile)).mode & 0o777, 0o600);
+    await restoreSourceEdit(receipt);
+    assert.deepEqual(await readFile(path), original);
+    assert.equal(existsSync(receiptFile), false);
+    assert.equal(existsSync(receipt.backup), false);
+  } finally {
+    if (editor?.exitCode === null && editor?.signalCode === null) editor.kill("SIGKILL");
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test("tampered backups and non-regular source targets cannot be restored", async () => {
+  const { root, path, backupRoot } = await fixture();
+  try {
+    const edit = await editSource("source.ts", text => text.replace("before", "after"), backupRoot, root);
+    await writeFile(edit.backup, "tampered");
+    await assert.rejects(() => edit.restore(), /checksum changed/);
+    assert.match(await readFile(path, "utf8"), /after/);
+    await rm(path);
+    await symlink(edit.backup, path);
+    await assert.rejects(() => edit.restore(), /non-regular/);
+    await assert.rejects(() => editSource("source.ts", text => text + "x", backupRoot, root), /regular tracked file/);
+    await assert.rejects(() => editSource("../outside.ts", text => text, backupRoot, root), /inside its checkout/);
+  } finally { await rm(root, { recursive: true, force: true }); }
+});
+
+test("CDP pipe handles fragmented and out-of-order responses and rejects closed browsers", async () => {
+  const child = new EventEmitter();
+  child.stdio = [null, null, null, new PassThrough(), new PassThrough()];
+  const requests = [];
+  child.stdio[3].on("data", bytes => requests.push(JSON.parse(bytes.toString().replace(/\0$/, ""))));
+  const cdp = new PipeCdp(child);
+  const first = cdp.call("Browser.getVersion");
+  const second = cdp.evaluate("1 + 1", "session-id");
+  assert.equal(requests[1].sessionId, "session-id");
+  const response = JSON.stringify({ id: requests[1].id, result: { result: { value: 2 } } }) + "\0";
+  child.stdio[4].write(response.slice(0, 7));
+  child.stdio[4].write(response.slice(7) + JSON.stringify({ id: requests[0].id, result: { product: "fixture" } }) + "\0");
+  assert.equal(await second, 2);
+  assert.deepEqual(await first, { product: "fixture" });
+  const error = cdp.call("Unknown.command");
+  child.stdio[4].write(JSON.stringify({ id: requests[2].id, error: { code: -32601 } }) + "\0");
+  await assert.rejects(() => error, /CDP Unknown.command failed/);
+  const pending = cdp.call("Page.enable");
+  child.emit("exit", 1);
+  await assert.rejects(() => pending, /isolated browser closed/);
+  assert.equal(cdp.pending.size, 0);
+  await assert.rejects(() => cdp.call("Browser.close"), /already closed/);
+  child.stdio[3].destroy();
+  child.stdio[4].destroy();
+});
+
+test("worker pidfd fault injection signals only the exact owned worker", { skip: process.platform !== "linux" }, async (t) => {
+  for (const scenario of ["owned", "wrong token", "wrong group", "wrong argv"]) await t.test(scenario, async () => {
+    const root = await mkdtemp(join(tmpdir(), "spaceapp-worker-probe-"));
+    let child;
+    try {
+      await mkdir(join(root, "apps/worker/dist"), { recursive: true });
+      await writeFile(join(root, "apps/worker/dist/worker.js"), "setInterval(() => {}, 1000);\n");
+      const token = "a".repeat(48);
+      child = spawn(process.execPath, [scenario === "wrong argv" ? "./apps/worker/dist/worker.js" : "apps/worker/dist/worker.js"], {
+        cwd: root, detached: true, stdio: "ignore", env: { ...process.env, SPACE_DEV_PROCESS_TOKEN: token }
+      });
+      const exited = once(child, "exit");
+      const record = { pid: child.pid, pgid: scenario === "wrong group" ? child.pid + 1 : child.pid, sid: child.pid };
+      if (scenario === "owned") {
+        await killOwnedWorkerWithPidfd(record, token);
+        await exited;
+        assert.equal(child.signalCode, "SIGKILL");
+      } else {
+        await assert.rejects(() => killOwnedWorkerWithPidfd(record, scenario === "wrong token" ? "b".repeat(48) : token), /no fallback attempted/);
+        assert.doesNotThrow(() => process.kill(child.pid, 0));
+        child.kill("SIGKILL");
+        await exited;
+      }
+    } finally {
+      if (child?.exitCode === null && child?.signalCode === null) child.kill("SIGKILL");
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+});
diff --git a/deploy/docker/dev-stack-safety.mjs b/deploy/docker/dev-stack-safety.mjs
new file mode 100644
index 000000000..f6697295b
--- /dev/null
+++ b/deploy/docker/dev-stack-safety.mjs
@@ -0,0 +1,323 @@
+import { randomBytes } from "node:crypto";
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { chmod, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { pidAlive, run, sleep } from "./dev-stack-lib.mjs";
+
+const unsafeOverrideKeys = ["SPACE_DEV_STACK_DIR", "SPACE_DEV_COMPOSE_PROJECT"];
+const ownershipVersion = 1;
+const processRecordVersion = 1;
+const spawnedChildren = new WeakMap();
+
+export function spawnOwnedProcess(ownership, command, args, options = {}) {
+  const child = spawn(command, args, {
+    ...options,
+    env: { ...(options.env ?? process.env), SPACE_DEV_PROCESS_TOKEN: ownership.token },
+    detached: process.platform !== "win32"
+  });
+  if (Number.isInteger(child.pid) && child.pid > 1) {
+    spawnedChildren.set(child, { pid: child.pid, token: ownership.token });
+  }
+  return child;
+}
+
+export function assertSafeDevStackOverrides(env = process.env) {
+  for (const key of unsafeOverrideKeys) {
+    if (env[key] != null && env[key] !== "") {
+      throw new Error(`${key} is intentionally unsupported: dev-stack state and Compose ownership are derived from this checkout so reset cannot target unrelated resources.`);
+    }
+  }
+}
+
+function validateOwnership(config, record) {
+  if (!record || record.version !== ownershipVersion || record.rootHash !== config.rootHash || !/^[a-f0-9]{48}$/.test(record.token || "")) {
+    throw new Error("The dev-stack ownership record is missing, damaged, or belongs to another checkout; refusing destructive lifecycle operations.");
+  }
+  return record;
+}
+
+export async function readStateOwnership(config, { allowMissing = false } = {}) {
+  if (!existsSync(config.stateRoot)) return null;
+  if (!existsSync(config.ownerFile)) {
+    if (allowMissing) return null;
+    throw new Error(`Refusing to adopt pre-existing state directory ${config.stateRoot}: it was not initialized by this dev-stack.`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(await readFile(config.ownerFile, "utf8"));
+  } catch {
+    throw new Error("The dev-stack ownership record is unreadable; refusing cleanup so recovery material is preserved.");
+  }
+  return validateOwnership(config, parsed);
+}
+
+export async function claimStateOwnership(config) {
+  if (existsSync(config.stateRoot)) return readStateOwnership(config);
+
+  let created = false;
+  try {
+    await mkdir(config.stateRoot, { mode: 0o700 });
+    created = true;
+    const record = {
+      version: ownershipVersion,
+      rootHash: config.rootHash,
+      token: randomBytes(24).toString("hex")
+    };
+    await writeFile(config.ownerFile, `${JSON.stringify(record)}\n`, { mode: 0o600, flag: "wx" });
+    await chmod(config.ownerFile, 0o600);
+    return record;
+  } catch (error) {
+    if (created) await rm(config.stateRoot, { recursive: true, force: true }).catch(() => {});
+    if (error?.code === "EEXIST") return readStateOwnership(config);
+    throw error;
+  }
+}
+
+function isZombie(identity) {
+  return typeof identity?.state === "string" && identity.state.startsWith("Z");
+}
+
+async function psField(pid, field) {
+  const result = await run("ps", ["-p", String(pid), "-o", `${field}=`], { capture: true, allowFailure: true });
+  if (result.code !== 0 || !result.stdout) return null;
+  return result.stdout.trim();
+}
+
+export async function processIdentity(pid) {
+  if (!pidAlive(pid)) return null;
+  const [startedAt, args, state] = await Promise.all([
+    psField(pid, "lstart"),
+    psField(pid, "args"),
+    psField(pid, "stat")
+  ]);
+  if (!startedAt || !args || !state) return null;
+  return { startedAt, args, state };
+}
+
+export function supervisorRecordMatches(config, record, identity) {
+  if (!record || !identity || record.legacy === true || isZombie(identity)) return false;
+  if (!Number.isInteger(record.pid) || record.pid <= 1) return false;
+  if (record.rootHash !== config.rootHash || record.startedAt !== identity.startedAt) return false;
+  return /(?:^|[\\/\s])dev-stack\.mjs(?:\s|$)/.test(identity.args);
+}
+
+export async function readSupervisorRecord(config) {
+  if (!existsSync(config.pidFile)) return null;
+  const raw = (await readFile(config.pidFile, "utf8")).trim();
+  if (!raw) return null;
+  try {
+    const parsed = JSON.parse(raw);
+    if (Number.isInteger(parsed)) return { pid: parsed, legacy: true };
+    return Number.isInteger(parsed?.pid) ? parsed : null;
+  } catch {
+    const pid = Number.parseInt(raw, 10);
+    return Number.isInteger(pid) ? { pid, legacy: true } : null;
+  }
+}
+
+export async function isOwnedSupervisor(config, record = null, identityProvider = processIdentity) {
+  const candidate = record ?? await readSupervisorRecord(config);
+  if (!candidate || !pidAlive(candidate.pid)) return false;
+  const identity = await identityProvider(candidate.pid);
+  return supervisorRecordMatches(config, candidate, identity);
+}
+
+export async function ownedSupervisorPid(config, { strict = true, identityProvider = processIdentity } = {}) {
+  const record = await readSupervisorRecord(config);
+  if (!record) return null;
+  if (!pidAlive(record.pid)) {
+    await rm(config.pidFile, { force: true });
+    return null;
+  }
+  const identity = await identityProvider(record.pid);
+  if (isZombie(identity)) {
+    await rm(config.pidFile, { force: true });
+    return null;
+  }
+  if (supervisorRecordMatches(config, record, identity)) return record.pid;
+  if (strict) {
+    throw new Error(`Refusing to signal PID ${record.pid}: the pidfile does not identify this checkout's dev-stack supervisor.`);
+  }
+  return null;
+}
+
+export async function claimSupervisor(config, identityProvider = processIdentity) {
+  const existing = await readSupervisorRecord(config);
+  if (existing) {
+    if (!pidAlive(existing.pid)) {
+      await rm(config.pidFile, { force: true });
+    } else {
+      const identity = await identityProvider(existing.pid);
+      if (isZombie(identity)) {
+        await rm(config.pidFile, { force: true });
+      } else if (supervisorRecordMatches(config, existing, identity)) {
+        throw new Error(`Dev stack is already running under supervisor ${existing.pid}.`);
+      } else {
+        throw new Error("A stale or unverified dev-stack supervisor record exists. Run `npm run dev:stack -- status` (or `down`) to clear a dead record before starting again; live unowned PIDs are never signalled or replaced.");
+      }
+    }
+  }
+
+  const identity = await identityProvider(process.pid);
+  if (!identity?.startedAt || isZombie(identity)) throw new Error("Could not establish dev-stack supervisor process identity.");
+  const record = { pid: process.pid, rootHash: config.rootHash, startedAt: identity.startedAt };
+  try {
+    await writeFile(config.pidFile, `${JSON.stringify(record)}\n`, { mode: 0o600, flag: "wx" });
+  } catch (error) {
+    if (error?.code === "EEXIST") throw new Error("Another dev-stack supervisor claimed this checkout while startup was in progress.");
+    throw error;
+  }
+  return record;
+}
+
+export async function releaseSupervisor(config, pid = process.pid) {
+  const record = await readSupervisorRecord(config);
+  if (record?.pid === pid) await rm(config.pidFile, { force: true });
+}
+
+function validateProcessRecord(record) {
+  if (!record || typeof record.name !== "string" || !Number.isInteger(record.pid) || record.pid <= 1 || record.pgid !== record.pid || record.sid !== record.pid) {
+    throw new Error("Invalid persisted dev-stack process-group record; refusing to signal it.");
+  }
+  return record;
+}
+
+export async function writeProcessRecords(config, ownership, records) {
+  validateOwnership(config, ownership);
+  const normalized = records.map(validateProcessRecord);
+  const payload = {
+    version: processRecordVersion,
+    rootHash: config.rootHash,
+    token: ownership.token,
+    groups: normalized
+  };
+  const temporary = `${config.processFile}.${process.pid}.tmp`;
+  await writeFile(temporary, `${JSON.stringify(payload, null, 2)}\n`, { mode: 0o600 });
+  await chmod(temporary, 0o600);
+  await rename(temporary, config.processFile);
+}
+
+export async function readProcessRecords(config, ownership) {
+  validateOwnership(config, ownership);
+  if (!existsSync(config.processFile)) return [];
+  let parsed;
+  try {
+    parsed = JSON.parse(await readFile(config.processFile, "utf8"));
+  } catch {
+    throw new Error("The dev-stack process ownership record is unreadable; refusing to signal any process.");
+  }
+  if (parsed?.version !== processRecordVersion || parsed.rootHash !== config.rootHash || parsed.token !== ownership.token || !Array.isArray(parsed.groups)) {
+    throw new Error("The dev-stack process ownership record does not match this state; refusing to signal any process.");
+  }
+  return parsed.groups.map(validateProcessRecord);
+}
+
+export async function clearProcessRecords(config) {
+  await rm(config.processFile, { force: true });
+}
+
+async function listGroupMembers(record, runner = run) {
+  // Match the entire group that kill(-pgid) targets. Darwin's `sess` is not a
+  // session-leader PID; filtering on it can silently hide owned live members.
+  const result = await runner("ps", ["-axo", "pid=,pgid=,stat=,lstart="], {
+    capture: true, allowFailure: true, env: { ...process.env, LC_ALL: "C" }
+  });
+  if (result.code !== 0) throw new Error("Could not inventory local processes; refusing to signal a dev-stack process group.");
+  const members = [];
+  for (const line of result.stdout.split(/\r?\n/)) {
+    if (!line.trim()) continue;
+    const match = line.trim().match(/^(\d+)\s+(\d+)\s+(\S+)(?:\s+(.+))?$/);
+    if (!match) throw new Error("Could not parse local process inventory; refusing to signal a dev-stack process group.");
+    const pid = Number(match[1]);
+    const pgid = Number(match[2]);
+    const stat = match[3];
+    if (pgid !== record.pgid || stat.startsWith("Z")) continue;
+    const startedAt = match[4]?.trim();
+    if (!/^[A-Za-z?]/.test(stat) || !/^[A-Za-z]{3}\s+[A-Za-z]{3}\s+\d{1,2}\s+\d{2}:\d{2}:\d{2}\s+\d{4}$/.test(startedAt || "")) {
+      throw new Error(`Could not establish start identity for PID ${pid}; refusing to signal its process group.`);
+    }
+    members.push({ pid, stat, startedAt });
+  }
+  return members;
+}
+
+async function processHasToken(pid, token, runner = run) {
+  const result = await runner("ps", ["eww", "-p", String(pid), "-o", "command="], { capture: true, allowFailure: true });
+  if (result.code !== 0 || !result.stdout) return false;
+  return result.stdout.includes(`SPACE_DEV_PROCESS_TOKEN=${token}`);
+}
+
+async function snapshotLiveGroup(record, ownership, child, runner) {
+  const isLiveChild = () => child?.pid === record.pid && child.exitCode === null && child.signalCode === null;
+  if (!isLiveChild()) return new Map();
+  const spawned = spawnedChildren.get(child);
+  const spawnedHere = spawned?.pid === record.pid && spawned.token === ownership.token;
+  const members = await listGroupMembers(record, runner);
+  // npm rewrites process.title; Darwin ps can then omit its environment.
+  // Only our exact, still-live spawned handle supplies alternative provenance.
+  // A persisted record or another object with the same PID cannot supply it.
+  if (!members.some((member) => member.pid === child.pid) || (!spawnedHere && !await processHasToken(child.pid, ownership.token, runner)) || !isLiveChild()) {
+    return new Map();
+  }
+  // The current supervisor's live child anchors this session. Descendants may
+  // intentionally drop the token; retain their start identities before signalling.
+  // Neither persisted records nor an already-exited child grant this trust.
+  return new Map(members.map((member) => [member.pid, member.startedAt]));
+}
+
+async function verifiedGroupMembers(record, ownership, runner = run, trustedMembers = new Map()) {
+  const members = await listGroupMembers(record, runner);
+  for (const member of members) {
+    if (trustedMembers.get(member.pid) === member.startedAt) continue;
+    if (!await processHasToken(member.pid, ownership.token, runner)) {
+      throw new Error(`Refusing to signal process group ${record.pgid}: PID ${member.pid} does not carry this dev-stack ownership token.`);
+    }
+  }
+  return members;
+}
+
+async function signalVerifiedGroup(record, ownership, signal, runner, signaler, trustedMembers) {
+  const members = await verifiedGroupMembers(record, ownership, runner, trustedMembers);
+  if (!members.length) return false;
+  try {
+    if (process.platform === "win32") {
+      for (const member of members) signaler(member.pid, signal);
+    } else {
+      signaler(-record.pgid, signal);
+    }
+  } catch (error) {
+    if (error?.code !== "ESRCH") throw error;
+  }
+  return true;
+}
+
+export async function terminateOwnedProcessGroups(config, ownership, {
+  records = null,
+  liveChildren = [],
+  timeoutMs = 7000,
+  runner = run,
+  signaler = process.kill
+} = {}) {
+  validateOwnership(config, ownership);
+  const groups = (records ?? await readProcessRecords(config, ownership)).map(validateProcessRecord);
+  for (const record of groups) {
+    const child = records == null ? null : liveChildren.find((candidate) => candidate.pid === record.pid);
+    const trustedMembers = await snapshotLiveGroup(record, ownership, child, runner);
+    const members = () => verifiedGroupMembers(record, ownership, runner, trustedMembers);
+    if (!await signalVerifiedGroup(record, ownership, "SIGTERM", runner, signaler, trustedMembers)) continue;
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+      if (!(await members()).length) break;
+      await sleep(100);
+    }
+    if ((await members()).length) {
+      await signalVerifiedGroup(record, ownership, "SIGKILL", runner, signaler, trustedMembers);
+      const killDeadline = Date.now() + 2000;
+      while (Date.now() < killDeadline && (await members()).length) await sleep(50);
+      if ((await members()).length) {
+        throw new Error(`Owned process group ${record.pgid} did not terminate; process ownership state was preserved for retry.`);
+      }
+    }
+  }
+  if (records == null) await clearProcessRecords(config);
+}
diff --git a/deploy/docker/dev-stack-test-fixtures.mjs b/deploy/docker/dev-stack-test-fixtures.mjs
new file mode 100644
index 000000000..b17f54213
--- /dev/null
+++ b/deploy/docker/dev-stack-test-fixtures.mjs
@@ -0,0 +1,5 @@
+// Synthetic credentials used only by disposable dev-stack acceptance fixtures.
+export const devStackTestOwner = Object.freeze({
+  email: "dev-stack-ci@example.com",
+  password: "dev-stack-ci-password-42!"
+});
diff --git a/deploy/docker/dev-stack-verify.mjs b/deploy/docker/dev-stack-verify.mjs
new file mode 100644
index 000000000..c605e2b58
--- /dev/null
+++ b/deploy/docker/dev-stack-verify.mjs
@@ -0,0 +1,200 @@
+#!/usr/bin/env node
+import { randomUUID } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import WebSocket from "ws";
+import { devStackTestOwner } from "./dev-stack-test-fixtures.mjs";
+
+const root = resolve(dirname(fileURLToPath(import.meta.url)), "../..");
+const stateRoot = resolve(process.env.SPACE_DEV_STACK_DIR || join(root, ".dev-stack"));
+const sleep = (ms) => new Promise((resolvePromise) => setTimeout(resolvePromise, ms));
+const activeCliStatuses = new Set(["RUNNING", "READY", "ATTACHED"]);
+const failedCliStatuses = new Set(["ERROR", "EXITED", "FAILED"]);
+
+function timeoutFromEnv(name, fallback) {
+  const raw = process.env[name];
+  if (raw == null || raw === "") return fallback;
+  const value = Number(raw);
+  if (!Number.isFinite(value) || value <= 0) throw new Error(`${name} must be a positive number of milliseconds.`);
+  return value;
+}
+
+const readyTimeoutMs = timeoutFromEnv("SPACE_DEV_VERIFY_READY_TIMEOUT_MS", 420_000);
+const cliTimeoutMs = timeoutFromEnv("SPACE_DEV_VERIFY_CLI_TIMEOUT_MS", 180_000);
+
+async function waitForJson(path, timeoutMs = 120_000) {
+  const deadline = Date.now() + timeoutMs;
+  let lastError = null;
+  while (Date.now() < deadline) {
+    try {
+      return JSON.parse(await readFile(path, "utf8"));
+    } catch (error) {
+      lastError = error;
+      await sleep(250);
+    }
+  }
+  throw new Error(`Timed out waiting for source-stack bootstrap file ${path}: ${lastError instanceof Error ? lastError.message : String(lastError)}`);
+}
+
+const config = await waitForJson(join(stateRoot, "config.json"));
+const api = `http://127.0.0.1:${config.ports.api}`;
+
+function firstCookie(response) {
+  const values = typeof response.headers.getSetCookie === "function" ? response.headers.getSetCookie() : [];
+  return (values[0] || response.headers.get("set-cookie") || "").split(";", 1)[0] || "";
+}
+
+async function request(path, { method = "GET", body, cookie, csrf, csrfHeader = "x-space-csrf-token" } = {}) {
+  const headers = { accept: "application/json" };
+  if (body !== undefined) headers["content-type"] = "application/json";
+  if (cookie) headers.cookie = cookie;
+  if (csrf) headers[csrfHeader] = csrf;
+  const response = await fetch(`${api}${path}`, {
+    method,
+    headers,
+    body: body === undefined ? undefined : JSON.stringify(body)
+  });
+  const text = await response.text();
+  let payload = null;
+  try { payload = text ? JSON.parse(text) : null; } catch { payload = text; }
+  if (!response.ok) throw new Error(`${method} ${path} failed (${response.status}): ${text.slice(0, 800)}`);
+  return { response, payload };
+}
+
+async function waitReady() {
+  const deadline = Date.now() + readyTimeoutMs;
+  while (Date.now() < deadline) {
+    try {
+      const { payload } = await request("/readyz");
+      if (payload?.ok === true && payload.dependencies?.database === "RUNNING" && payload.dependencies?.worker === "RUNNING" && payload.dependencies?.cliHost === "RUNNING") return payload;
+    } catch {}
+    await sleep(500);
+  }
+  throw new Error(`Timed out waiting ${readyTimeoutMs}ms for real source-stack readiness.`);
+}
+
+const ready = await waitReady();
+console.log(`[dev-stack-verify] PASS readiness database=${ready.dependencies.database} worker=${ready.dependencies.worker} cliHost=${ready.dependencies.cliHost}`);
+
+const setupToken = (await readFile(join(stateRoot, "secrets", "setup-token"), "utf8")).trim();
+const { email, password } = devStackTestOwner;
+const claimed = await request("/api/setup/claim", {
+  method: "POST",
+  body: { token: setupToken, email, password }
+});
+const starterRoomId = claimed.payload?.starterRoomId;
+if (typeof starterRoomId !== "string" || !starterRoomId.startsWith("room:")) throw new Error("Owner setup did not return the Getting Started room id.");
+if (!firstCookie(claimed.response)) throw new Error("Owner setup succeeded without returning a session cookie.");
+console.log(`[dev-stack-verify] PASS owner setup starterRoom=${starterRoomId}`);
+
+const login = await request("/api/auth/login", {
+  method: "POST",
+  body: { email, password }
+});
+const cookie = firstCookie(login.response);
+if (!cookie || login.payload?.isAuthenticated !== true || login.payload?.user?.role !== "ADMIN") {
+  throw new Error("The owner created by setup could not sign in with its configured credentials.");
+}
+console.log("[dev-stack-verify] PASS owner credentials sign in through /api/auth/login");
+
+const csrfResponse = await request("/api/auth/csrf", { cookie });
+const csrf = csrfResponse.payload?.csrfToken;
+const csrfHeader = csrfResponse.payload?.headerName || "x-space-csrf-token";
+if (typeof csrf !== "string" || !csrf) throw new Error("Authenticated owner session did not return a CSRF token.");
+
+const roomsResponse = await request("/api/rooms", { cookie });
+const rooms = Array.isArray(roomsResponse.payload) ? roomsResponse.payload : (roomsResponse.payload?.data ?? []);
+const starterRoom = rooms.find((candidate) => candidate?.id === starterRoomId);
+if (!starterRoom || typeof starterRoom.name !== "string" || !starterRoom.name.trim()) {
+  throw new Error("Could not resolve the Getting Started room name required by the room update contract.");
+}
+
+await request(`/api/rooms/${encodeURIComponent(starterRoomId)}`, {
+  method: "PATCH",
+  cookie,
+  csrf,
+  csrfHeader,
+  body: { name: starterRoom.name, projectPath: root }
+});
+console.log("[dev-stack-verify] PASS starter room points at the source checkout");
+
+const panesResponse = await request(`/api/panes?roomId=${encodeURIComponent(starterRoomId)}`, { cookie });
+const payload = panesResponse.payload;
+const panes = Array.isArray(payload) ? payload : (payload?.data ?? payload?.panes ?? []);
+const pane = panes.find((candidate) => candidate?.terminalRuntimeId === "cli:opencode" || (candidate?.mode === "TERMINAL" && /OpenCode/i.test(candidate?.title || "")));
+if (!pane?.id) throw new Error("Getting Started does not contain an OpenCode terminal pane.");
+
+const started = await request(`/api/panes/${encodeURIComponent(pane.id)}/cli/session`, {
+  method: "POST",
+  cookie,
+  csrf,
+  csrfHeader,
+  body: { runtimeId: "cli:opencode" }
+});
+console.log(`[dev-stack-verify] OpenCode start returned status=${started.payload?.session?.status ?? started.payload?.status ?? "unknown"}`);
+
+const sessionView = await request(`/api/panes/${encodeURIComponent(pane.id)}/cli/session`, { cookie });
+const sessionId = sessionView.payload?.session?.sessionId ?? started.payload?.session?.sessionId;
+const ticket = sessionView.payload?.websocket?.token;
+if (typeof sessionId !== "string" || !sessionId || typeof ticket !== "string" || !ticket) {
+  throw new Error("OpenCode session did not expose the one-time terminal WebSocket ticket required to attach the UI transport.");
+}
+
+const wsUrl = `${api.replace(/^http/, "ws")}/api/panes/${encodeURIComponent(pane.id)}/cli/terminal` +
+  `?sessionId=${encodeURIComponent(sessionId)}&token=${encodeURIComponent(ticket)}` +
+  `&clientId=${encodeURIComponent(randomUUID())}&initialCols=120&initialRows=32`;
+let terminalOutput = "";
+let socketError = null;
+let socketClosed = null;
+const socket = new WebSocket(wsUrl, { headers: { cookie } });
+socket.on("message", (data) => {
+  let message = null;
+  try { message = JSON.parse(data.toString()); } catch { return; }
+  if (message?.type === "error") {
+    socketError = new Error(`OpenCode terminal server error: ${message.message || message.code || "unknown error"}`);
+    return;
+  }
+  if (message?.type !== "output" || typeof message.data !== "string" || message.data.length === 0) return;
+  if (terminalOutput.length < 200_000) terminalOutput += message.data.slice(0, 200_000 - terminalOutput.length);
+});
+socket.on("error", (error) => { socketError = error; });
+socket.on("close", (code, reason) => {
+  socketClosed = `code=${code}${reason?.length ? ` reason=${reason.toString()}` : ""}`;
+});
+
+await new Promise((resolvePromise, rejectPromise) => {
+  socket.once("open", resolvePromise);
+  socket.once("error", rejectPromise);
+});
+console.log(`[dev-stack-verify] terminal transport attached session=${sessionId}`);
+
+let session = null;
+const deadline = Date.now() + cliTimeoutMs;
+try {
+  while (Date.now() < deadline) {
+    const current = await request(`/api/panes/${encodeURIComponent(pane.id)}/cli/session`, { cookie });
+    session = current.payload?.session ?? current.payload;
+    if (failedCliStatuses.has(session?.status)) {
+      throw new Error(`OpenCode pane entered ${session.status}: ${session.statusReason || "no reason"}`);
+    }
+    if (activeCliStatuses.has(session?.status) && terminalOutput.length > 0) break;
+    if (socketError) throw new Error(`OpenCode terminal WebSocket failed: ${socketError.message}`);
+    if (socketClosed) throw new Error(`OpenCode terminal WebSocket closed before activation (${socketClosed}).`);
+    await sleep(500);
+  }
+
+  if (!session || !activeCliStatuses.has(session.status)) {
+    throw new Error(`OpenCode pane did not become active within ${cliTimeoutMs}ms; last status=${session?.status ?? "missing"}.`);
+  }
+  if (terminalOutput.length === 0) {
+    throw new Error(`OpenCode pane reached ${session.status} but emitted no terminal output within ${cliTimeoutMs}ms.`);
+  }
+  console.log(`[dev-stack-verify] PASS OpenCode pane active status=${session.status} terminalBytes=${terminalOutput.length}`);
+} finally {
+  try { socket.close(); } catch {}
+}
+
+const finalReady = await request("/readyz");
+if (finalReady.payload?.ok !== true) throw new Error("Stack lost readiness after starting OpenCode.");
+console.log("[dev-stack-verify] PASS source-stack acceptance");
diff --git a/deploy/docker/dev-stack-worker-probe.mjs b/deploy/docker/dev-stack-worker-probe.mjs
new file mode 100644
index 000000000..60d085d87
--- /dev/null
+++ b/deploy/docker/dev-stack-worker-probe.mjs
@@ -0,0 +1,233 @@
+#!/usr/bin/env node
+// Inject one verified worker failure in opted-in Linux CI, then exercise normal restart.
+import assert from "node:assert/strict";
+import { spawn, execFile } from "node:child_process";
+import { lstat, mkdir, readFile, rm, stat, writeFile } from "node:fs/promises";
+import { connect } from "node:net";
+import { join, resolve } from "node:path";
+import { pathToFileURL, fileURLToPath } from "node:url";
+import { devStackTestOwner } from "./dev-stack-test-fixtures.mjs";
+import { promisify } from "node:util";
+
+const exec = promisify(execFile);
+const pause = (ms) => new Promise((done) => setTimeout(done, ms));
+const arg = process.argv.indexOf("--repo");
+const root = arg >= 0 && process.argv[arg + 1] ? resolve(process.argv[arg + 1]) : null;
+
+async function until(label, action, timeoutMs = 90_000) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const result = await action();
+    if (result) return result;
+    await pause(200);
+  }
+  throw new Error(`${label} did not reach its asserted condition within ${timeoutMs}ms.`);
+}
+
+async function optionalText(path) {
+  try { return await readFile(path, "utf8"); }
+  catch (error) { if (error.code === "ENOENT") return null; throw error; }
+}
+
+function ready(body) {
+  return body?.ok === true && ["database", "worker", "cliHost"].every((key) => body.dependencies?.[key] === "RUNNING");
+}
+
+async function request(base, path, { method = "GET", body, cookie } = {}) {
+  const response = await fetch(base + path, {
+    method, signal: AbortSignal.timeout(5_000), cache: "no-store",
+    headers: { accept: "application/json", ...(body ? { "content-type": "application/json" } : {}), ...(cookie ? { cookie } : {}) },
+    body: body ? JSON.stringify(body) : undefined
+  });
+  assert(response.ok, `Local fixture request ${method} ${path} failed with HTTP ${response.status}.`);
+  return { response, payload: await response.json() };
+}
+
+async function readiness(base) {
+  try { const { payload } = await request(base, "/readyz"); return ready(payload) && payload; }
+  catch { return false; }
+}
+
+async function loginAndRooms(base) {
+  const { response, payload } = await request(base, "/api/auth/login", {
+    method: "POST", body: devStackTestOwner
+  });
+  assert.equal(payload.isAuthenticated, true);
+  assert.equal(payload.user?.role, "ADMIN");
+  assert.equal(typeof payload.user?.id, "string");
+  const cookies = response.headers.getSetCookie?.() || [];
+  const cookie = (cookies[0] || response.headers.get("set-cookie") || "").split(";", 1)[0];
+  assert(cookie, "Ordinary owner login must return a session cookie.");
+  const rooms = (await request(base, "/api/rooms", { cookie })).payload;
+  const list = Array.isArray(rooms) ? rooms : rooms?.data;
+  assert(Array.isArray(list) && list.length > 0);
+  return { ownerId: payload.user.id, roomIds: list.map((room) => room.id).sort() };
+}
+
+async function liveMembers(groupIds) {
+  const result = await exec("ps", ["-axo", "pid=,pgid=,stat="], { timeout: 5_000 });
+  return result.stdout.split(/\r?\n/).filter(Boolean).map((line) => {
+    const match = line.trim().match(/^(\d+)\s+(\d+)\s+(\S+)$/);
+    assert(match, "Unexpected process inventory format; refusing to infer cleanup.");
+    return { pid: Number(match[1]), pgid: Number(match[2]), state: match[3] };
+  }).filter((entry) => groupIds.has(entry.pgid) && !entry.state.startsWith("Z"));
+}
+
+async function portClosed(port) {
+  return new Promise((resolvePromise, reject) => {
+    const socket = connect({ host: "127.0.0.1", port });
+    socket.setTimeout(2_000);
+    socket.once("connect", () => { socket.destroy(); resolvePromise(false); });
+    socket.once("error", (error) => { socket.destroy(); error.code === "ECONNREFUSED" ? resolvePromise(true) : reject(new Error("Cannot establish whether the owned loopback API port closed.")); });
+    socket.once("timeout", () => { socket.destroy(); reject(new Error("API port connection timed out; a silent hang is not proof of shutdown.")); });
+  });
+}
+
+export async function killOwnedWorkerWithPidfd(record, token) {
+  // pidfd anchors the exact process even if its numeric PID is reused between checks.
+  // Token travels over stdin, never a shell argument or a printed environment.
+  const code = `import json, os, signal, sys
+data = json.load(sys.stdin)
+pid = data['pid']
+if not hasattr(os, 'pidfd_open') or not hasattr(signal, 'pidfd_send_signal'):
+    raise SystemExit('Linux pidfd support is required; no broad-kill fallback is permitted')
+fd = os.pidfd_open(pid, 0)
+try:
+    env = open('/proc/%d/environ' % pid, 'rb').read().split(b'\\0')
+    command = open('/proc/%d/cmdline' % pid, 'rb').read().split(b'\\0')
+    expected = ('SPACE_DEV_PROCESS_TOKEN=' + data['token']).encode()
+    if expected not in env or len(command) < 2 or command[1] != b'apps/worker/dist/worker.js':
+        raise SystemExit('Recorded worker identity does not match this owned source stack')
+    if os.getpgid(pid) != data['pgid'] or os.getsid(pid) != data['sid']:
+        raise SystemExit('Recorded worker process group/session no longer matches')
+    signal.pidfd_send_signal(fd, signal.SIGKILL, None, 0)
+finally:
+    os.close(fd)
+`;
+  await new Promise((resolvePromise, reject) => {
+    const child = spawn("python3", ["-c", code], { stdio: ["pipe", "ignore", "pipe"] });
+    const timer = setTimeout(() => { child.kill("SIGKILL"); reject(new Error("Owned-worker pidfd helper timed out; no fallback attempted.")); }, 10_000);
+    let stderr = "";
+    child.stderr.on("data", (chunk) => { if (stderr.length < 2_000) stderr += chunk.toString(); });
+    child.once("error", (error) => { clearTimeout(timer); reject(error); });
+    child.once("close", (code) => { clearTimeout(timer); code === 0 ? resolvePromise() : reject(new Error(`Owned-worker pidfd injection failed (exit ${code}); no fallback attempted. ${stderr.trim()}`)); });
+    child.stdin.on("error", () => {});
+    child.stdin.end(JSON.stringify({ pid: record.pid, pgid: record.pgid, sid: record.sid, token }));
+  });
+}
+
+async function main() {
+  assert(root, "Pass --repo with the disposable checkout path.");
+  assert.equal(process.env.GITHUB_ACTIONS, "true");
+  assert.equal(process.env.RUNNER_OS, "Linux");
+  assert.equal(process.env.SPACE_DEV_ACCEPTANCE_MUTATIONS, "1");
+  assert(process.env.RUNNER_TEMP);
+  const initialExitFile = process.env.SPACE_DEV_INITIAL_EXIT_FILE;
+  assert(initialExitFile, "The initial npm-launcher exit-status witness is required.");
+  assert.equal(await optionalText(initialExitFile), null, "Initial stack has already exited; do not inject a fault into a failed setup.");
+  const log = resolve(process.env.SPACE_DEV_STACK_LOG || join(process.env.RUNNER_TEMP, "dev-stack.log"));
+  const evidenceRoot = resolve(process.env.SPACE_DEV_EVIDENCE_DIR || join(process.env.RUNNER_TEMP, "dev-stack-acceptance-evidence"));
+  await mkdir(evidenceRoot, { recursive: true, mode: 0o700 });
+  const git = async (...args) => (await exec("git", args, { cwd: root })).stdout.trim();
+  const sha = await git("rev-parse", "HEAD");
+  const baselineStatus = await git("status", "--porcelain=v1");
+  const lib = await import(pathToFileURL(join(root, "deploy/docker/dev-stack-lib.mjs")).href);
+  const safety = await import(pathToFileURL(join(root, "deploy/docker/dev-stack-safety.mjs")).href);
+  safety.assertSafeDevStackOverrides();
+  const config = await lib.resolveConfig(process.env, root);
+  const persistedConfig = JSON.parse(await readFile(config.configFile, "utf8"));
+  for (const key of ["root", "stateRoot", "project", "ports"]) assert.deepEqual(persistedConfig[key], config[key], `Running config ${key} differs from this checkout's selected configuration.`);
+  assert((await lstat(config.stateRoot)).isDirectory());
+  assert(!(await lstat(config.stateRoot)).isSymbolicLink());
+  const ownership = await safety.readStateOwnership(config);
+  const supervisor = await safety.ownedSupervisorPid(config);
+  assert(supervisor, "A verified live source supervisor is required.");
+  const records = await safety.readProcessRecords(config, ownership);
+  const workers = records.filter((entry) => entry.name === "worker");
+  assert.equal(workers.length, 1);
+  const worker = workers[0];
+  const groupIds = new Set(records.map((entry) => entry.pgid));
+  const api = `http://127.0.0.1:${config.ports.api}`;
+  const initialReady = await until("Initial complete readiness", () => readiness(api));
+  const owner = await loginAndRooms(api);
+  const resources = await lib.dockerResources(config, ownership);
+  assert(resources.containers.length >= 2 && resources.volumes.length > 0);
+  const logOffset = (await stat(log)).size;
+  const receipt = { candidateSha: sha, passed: false, injected: false, clearFailureObserved: false, nonzeroExitObserved: false, failFastCleanupObserved: false, explicitRestartReady: false, originalOwnerAndRoomsPreserved: false };
+  let recovery;
+  let recoveryError;
+  try {
+    await killOwnedWorkerWithPidfd(worker, ownership.token);
+    receipt.injected = true;
+    const suffix = async () => (await readFile(log)).subarray(logOffset).toString("utf8");
+    await until("Explicit new worker-failure diagnostic", async () => (await suffix()).includes("worker exited unexpectedly (SIGKILL); stopping the stack."));
+    receipt.clearFailureObserved = true;
+    const exitStatus = await until("Nonzero original npm-launcher exit witness", async () => {
+      const raw = await optionalText(initialExitFile);
+      if (raw === null) return false;
+      assert(/^[0-9]+\s*$/.test(raw), "Invalid launcher exit witness.");
+      assert.notEqual(Number(raw), 0, "A worker crash must not terminate the launcher successfully.");
+      return { code: Number(raw) };
+    });
+    receipt.nonzeroExitObserved = true;
+    receipt.launcherExitCode = exitStatus.code;
+    await until("Whole owned source stack stopped", async () => {
+      if (await safety.ownedSupervisorPid(config, { strict: false })) return false;
+      if ((await liveMembers(groupIds)).length) return false;
+      const remaining = await lib.dockerResources(config, ownership);
+      if (remaining.containers.length || remaining.networks.length) return false;
+      assert.deepEqual([...remaining.volumes].sort(), [...resources.volumes].sort(), "Fail-fast down must preserve owned persistent volumes for an explicit restart.");
+      return portClosed(config.ports.api);
+    });
+    receipt.failFastCleanupObserved = true;
+    console.log("[dev-stack-worker-probe] PASS owned worker SIGKILL produced a clear failure, nonzero exit, and complete fail-fast shutdown");
+
+    const recoveryExit = join(process.env.RUNNER_TEMP, "dev-stack-recovery.exit");
+    await rm(recoveryExit, { force: true });
+    const recoveryOffset = (await stat(log)).size;
+    // Same documented command; no reset, dev-login, reused auth session, or alternate environment.
+    recovery = spawn("bash", ["-c", 'set +e; npm run dev:stack >>"$1" 2>&1; code=$?; printf "%s\\n" "$code" >"$2.tmp"; mv "$2.tmp" "$2"; exit "$code"', "dev-stack-recovery", log, recoveryExit], { cwd: root, detached: true, stdio: "ignore", env: process.env });
+    recovery.once("error", (error) => { recoveryError = error; });
+    assert(Number.isInteger(recovery.pid) && recovery.pid > 1, "Could not launch the ordinary recovery command.");
+    await writeFile(join(process.env.RUNNER_TEMP, "dev-stack-recovery-shell.pid"), `${recovery.pid}\n`, { mode: 0o600 });
+    const afterReady = await until("Explicit normal restart readiness", async () => {
+      assert(!recoveryError, "The ordinary recovery launcher could not start.");
+      assert.equal(await optionalText(recoveryExit), null, "Recovered launcher exited before reaching readiness; inspect the redacted stack log.");
+      const body = await readiness(api);
+      if (!body) return false;
+      const newRecords = await safety.readProcessRecords(config, ownership);
+      const newWorker = newRecords.find((entry) => entry.name === "worker");
+      if (!newWorker || newWorker.pid === worker.pid || !await safety.ownedSupervisorPid(config)) return false;
+      const output = (await readFile(log)).subarray(recoveryOffset).toString("utf8");
+      return output.includes('"service":"space-worker"') && output.includes('"status":"running"') && body;
+    }, 420_000);
+    assert.notEqual(await safety.ownedSupervisorPid(config), supervisor);
+    assert.notEqual(afterReady.apiStartedAt, initialReady.apiStartedAt);
+    assert.equal((await safety.readStateOwnership(config)).token, ownership.token);
+    receipt.explicitRestartReady = true;
+    // Assert the real second boot does not advertise the now-consumed setup
+    // secret. Restrict inspection to the recovery log suffix: the original
+    // first-owner boot legitimately printed its one-time token.
+    const restartOutput = await until("Claimed-owner startup banner", async () => {
+      const text = (await readFile(log)).subarray(recoveryOffset).toString("utf8");
+      return text.includes("Owner setup already complete; sign in with the existing owner account.") && text;
+    });
+    assert(!restartOutput.includes("Owner setup token: "), "Recovered stack printed a consumed owner setup token.");
+    receipt.claimedOwnerTokenSuppressed = true;
+    assert.deepEqual(await loginAndRooms(api), owner, "The same owner credentials and room IDs must survive ordinary restart.");
+    receipt.originalOwnerAndRoomsPreserved = true;
+    assert.equal(await git("rev-parse", "HEAD"), sha);
+    assert.equal(await git("status", "--porcelain=v1"), baselineStatus);
+    receipt.passed = true;
+    console.log("[dev-stack-worker-probe] PASS explicit normal restart, ready dependencies, original owner login and room identities");
+  } finally {
+    await writeFile(join(evidenceRoot, "worker-recovery-receipt.json"), JSON.stringify(receipt, null, 2) + "\n", { mode: 0o600 });
+    // Keep recovery services available for the workflow's existing always-down/reset.
+    // With stdio detached and a recorded shell PID, they do not keep this probe alive.
+    recovery?.unref();
+  }
+}
+
+if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  main().catch((error) => { console.error(`[dev-stack-worker-probe] FAIL ${error.message}`); process.exitCode = 1; });
+}
diff --git a/deploy/docker/dev-stack.mjs b/deploy/docker/dev-stack.mjs
new file mode 100755
index 000000000..37b3e5c6d
--- /dev/null
+++ b/deploy/docker/dev-stack.mjs
@@ -0,0 +1,453 @@
+#!/usr/bin/env node
+import { existsSync } from "node:fs";
+import { chmod, mkdir, readFile, readdir, rename, rm, rmdir, stat, writeFile } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+  compose,
+  dockerResources,
+  ensureBuild,
+  ensureTemporalNamespace,
+  installOpenCode,
+  ownerSetupBanner,
+  parseOpenCodeVersion,
+  parsePinnedImages,
+  prepareState,
+  renderCompose,
+  resolveConfig,
+  run,
+  sleep,
+  sourceEnv,
+  waitHealthy,
+  waitReady
+} from "./dev-stack-lib.mjs";
+import {
+  assertSafeDevStackOverrides,
+  claimStateOwnership,
+  claimSupervisor,
+  clearProcessRecords,
+  ownedSupervisorPid,
+  readStateOwnership,
+  releaseSupervisor,
+  spawnOwnedProcess,
+  terminateOwnedProcessGroups,
+  writeProcessRecords
+} from "./dev-stack-safety.mjs";
+
+const scriptPath = fileURLToPath(import.meta.url);
+
+function prefixStream(stream, label, target) {
+  let pending = "";
+  stream.on("data", (chunk) => {
+    pending += chunk.toString();
+    const lines = pending.split(/\r?\n/);
+    pending = lines.pop() || "";
+    for (const line of lines) target.write(`[${label}] ${line}\n`);
+  });
+  stream.on("end", () => { if (pending) target.write(`[${label}] ${pending}\n`); });
+}
+
+export function spawnService(config, name, command, args, env, ownership, onUnexpectedExit) {
+  const child = spawnOwnedProcess(ownership, command, args, {
+    cwd: config.root,
+    env,
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  child.once("error", (error) => onUnexpectedExit(name, child, null, error));
+  if (!Number.isInteger(child.pid) || child.pid <= 1) throw new Error(`Could not establish a process-group leader for ${name}.`);
+  prefixStream(child.stdout, name, process.stdout);
+  prefixStream(child.stderr, name, process.stderr);
+  child.once("exit", (code, signal) => onUnexpectedExit(name, child, code, signal));
+  return {
+    child,
+    record: { name, pid: child.pid, pgid: child.pid, sid: child.pid }
+  };
+}
+
+export async function ensureDarwinNodePtySpawnHelpers(root, platform = process.platform) {
+  if (platform !== "darwin") return [];
+  const prebuilds = join(root, "node_modules", "node-pty", "prebuilds");
+  if (!existsSync(prebuilds)) return [];
+
+  const repaired = [];
+  for (const entry of await readdir(prebuilds, { withFileTypes: true })) {
+    if (!entry.isDirectory() || !entry.name.startsWith("darwin-")) continue;
+    const helper = join(prebuilds, entry.name, "spawn-helper");
+    if (!existsSync(helper)) continue;
+    const info = await stat(helper);
+    const currentMode = info.mode & 0o777;
+    const desiredMode = currentMode | 0o111;
+    if (currentMode === desiredMode) continue;
+    await chmod(helper, desiredMode);
+    repaired.push(helper);
+  }
+  return repaired;
+}
+
+// Four service groups can each use 7s graceful + 2s forced termination, then
+// Docker stops the dependent containers. Include bounded VM/CLI overhead too;
+// 15s could expire while a healthy Colima teardown was still making progress.
+async function waitSupervisorExit(config, pid, timeoutMs = 90_000) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (await ownedSupervisorPid(config, { strict: false }) !== pid) return;
+    await sleep(100);
+  }
+  throw new Error(`Dev-stack supervisor ${pid} did not stop cleanly.`);
+}
+
+async function waitServiceHealthyWithDiagnostics(config, service, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  let lastStatus = "missing";
+  while (Date.now() < deadline) {
+    const id = (await compose(config, ["ps", "-q", service], { capture: true })).stdout;
+    if (id) {
+      const status = await run("docker", ["inspect", "--format", "{{if .State.Health}}{{.State.Health.Status}}{{else}}{{.State.Status}}{{end}}", id], {
+        capture: true,
+        allowFailure: true
+      });
+      lastStatus = status.stdout || `inspect-exit-${status.code}`;
+      if (lastStatus === "healthy") return;
+      if (["exited", "dead"].includes(lastStatus)) break;
+    }
+    await sleep(1000);
+  }
+
+  const logs = await compose(config, ["logs", "--no-color", "--tail", "200", service], { capture: true, allowFailure: true });
+  const diagnostic = [logs.stdout, logs.stderr].filter(Boolean).join("\n");
+  if (diagnostic) process.stderr.write(`[dev:stack] ${service} diagnostic logs:\n${diagnostic}\n`);
+  throw new Error(`${service} did not become healthy within ${Math.round(timeoutMs / 1000)} seconds; last status=${lastStatus}.`);
+}
+
+async function ownershipForCleanup(config) {
+  if (existsSync(config.stateRoot)) return readStateOwnership(config);
+  const resources = await dockerResources(config);
+  if (resources.containers.length || resources.volumes.length || resources.networks.length) {
+    throw new Error(`Dev-stack Docker resources exist for ${config.project}, but the state ownership record is missing; refusing cleanup because ownership cannot be proven.`);
+  }
+  return null;
+}
+
+async function stopDockerResources(config, ownership, { removeVolumes = false } = {}) {
+  const before = await dockerResources(config, ownership);
+  const hasRuntimeResources = before.containers.length || before.networks.length || (removeVolumes && before.volumes.length);
+  if (hasRuntimeResources) {
+    if (existsSync(config.composeFile)) {
+      const args = ["down"];
+      if (removeVolumes) args.push("-v");
+      args.push("--remove-orphans");
+      await compose(config, args);
+    } else {
+      if (before.containers.length) await run("docker", ["rm", "-f", ...before.containers]);
+      if (before.networks.length) await run("docker", ["network", "rm", ...before.networks]);
+      if (removeVolumes && before.volumes.length) await run("docker", ["volume", "rm", ...before.volumes]);
+    }
+  }
+
+  const after = await dockerResources(config, ownership);
+  if (after.containers.length || after.networks.length || (removeVolumes && after.volumes.length)) {
+    throw new Error(`Cleanup left owned Docker resources behind; state preserved for retry: ${JSON.stringify(after)}`);
+  }
+  return after;
+}
+
+async function removeOwnedState(config, ownership) {
+  if (!existsSync(config.stateRoot)) return;
+  const current = await readStateOwnership(config);
+  if (current.token !== ownership.token) throw new Error("Dev-stack state ownership changed during reset; refusing deletion.");
+  const quarantine = `${config.stateRoot}.reset-${ownership.token.slice(0, 12)}`;
+  if (existsSync(quarantine)) throw new Error(`Cannot reset while recovery directory already exists: ${quarantine}`);
+  await rename(config.stateRoot, quarantine);
+  try {
+    await rm(quarantine, { recursive: true, force: true });
+  } catch (error) {
+    try { await rename(quarantine, config.stateRoot); }
+    catch {
+      throw new Error(`State deletion failed and recovery data remains at ${quarantine}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    throw new Error(`State deletion failed; ownership data was restored for retry: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+export async function down(config) {
+  const ownership = await ownershipForCleanup(config);
+  if (!ownership) return;
+  const pid = await ownedSupervisorPid(config);
+  if (pid && pid !== process.pid) {
+    process.kill(pid, "SIGTERM");
+    await waitSupervisorExit(config, pid);
+  }
+  await terminateOwnedProcessGroups(config, ownership);
+  await stopDockerResources(config, ownership);
+}
+
+export async function reset(config) {
+  const ownership = await ownershipForCleanup(config);
+  if (!ownership) {
+    console.log("[dev:stack] Reset complete; no owned state or Docker resources exist.");
+    return;
+  }
+  await down(config);
+  await terminateOwnedProcessGroups(config, ownership);
+  await stopDockerResources(config, ownership, { removeVolumes: true });
+  await removeOwnedState(config, ownership);
+  const tmpSocketRoot = dirname(config.socketPath);
+  if (!tmpSocketRoot.startsWith(config.stateRoot) && tmpSocketRoot.includes(`spaceapp-dev-${config.rootHash}`)) {
+    await rm(config.socketPath, { force: true }).catch(() => {});
+    await rmdir(tmpSocketRoot).catch((error) => {
+      if (error?.code !== "ENOENT" && error?.code !== "ENOTEMPTY") throw error;
+    });
+  }
+  console.log("[dev:stack] Reset complete; owned containers, volumes, processes and state were removed.");
+}
+
+export async function status(config) {
+  const stateExists = existsSync(config.stateRoot);
+  const ownership = stateExists ? await readStateOwnership(config, { allowMissing: true }) : null;
+  const pid = ownership ? await ownedSupervisorPid(config, { strict: false }) : null;
+  const resources = await dockerResources(config, ownership);
+  const noDockerResources = !resources.containers.length && !resources.volumes.length && !resources.networks.length;
+  const payload = {
+    running: Boolean(pid),
+    supervisorPid: pid,
+    project: config.project,
+    stateRoot: config.stateRoot,
+    ownershipVerified: Boolean(ownership) || (!stateExists && noDockerResources),
+    ports: config.ports,
+    docker: resources
+  };
+  console.log(JSON.stringify(payload, null, 2));
+  return payload;
+}
+
+export async function rebuild(config) {
+  const ownership = existsSync(config.stateRoot) ? await readStateOwnership(config) : null;
+  const pid = ownership ? await ownedSupervisorPid(config) : null;
+  if (!pid) {
+    await ensureBuild(config, true);
+    console.log("[dev:stack] Rebuilt source workspaces; no running supervisor to restart.");
+    return;
+  }
+  process.kill(pid, "SIGHUP");
+  console.log(`[dev:stack] Rebuild requested from supervisor ${pid}.`);
+}
+
+export async function start(config) {
+  await run("docker", ["compose", "version"]);
+  const ownership = await claimStateOwnership(config);
+  await claimSupervisor(config);
+
+  let children = new Map();
+  let stopping = false;
+  let shutdownPromise = null;
+  let reloadChain = Promise.resolve();
+  let processRecordWrite = Promise.resolve();
+
+  const persistChildren = async () => {
+    const records = [...children.values()].map((entry) => entry.record);
+    processRecordWrite = processRecordWrite.then(() => writeProcessRecords(config, ownership, records));
+    await processRecordWrite;
+  };
+
+  const runCommand = async (name, command, args, options = {}) => {
+    if (stopping) throw new Error(`Refusing to run ${name} while the dev stack is stopping.`);
+    // Builds, migrations and npm installs can spawn children of their own.
+    // Track the transient group so shutdown owns the whole command tree.
+    const child = spawnOwnedProcess(ownership, command, args, {
+      cwd: config.root,
+      env: options.env,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const completed = new Promise((resolvePromise, rejectPromise) => {
+      child.once("error", rejectPromise);
+      child.once("close", (code, signal) => {
+        if (code === 0) resolvePromise();
+        else rejectPromise(new Error(`${command} ${args.join(" ")} failed (${code ?? signal}).`));
+      });
+    });
+    if (!Number.isInteger(child.pid) || child.pid <= 1) {
+      await completed;
+      throw new Error(`Could not establish a process-group leader for ${name}.`);
+    }
+    prefixStream(child.stdout, name, process.stdout);
+    prefixStream(child.stderr, name, process.stderr);
+    const entry = { child, record: { name, pid: child.pid, pgid: child.pid, sid: child.pid } };
+    children.set(name, entry);
+    await Promise.all([persistChildren(), completed]);
+    if (children.get(name) === entry) {
+      children.delete(name);
+      await persistChildren();
+    }
+    if (stopping) throw new Error(`${name} cancelled while the dev stack is stopping.`);
+  };
+  const runBuild = (command, args, options) => runCommand("build", command, args, options);
+
+  const stopChildren = async () => {
+    const snapshot = [...children.values()];
+    children = new Map();
+    const records = snapshot.map((entry) => entry.record);
+    await processRecordWrite;
+    if (records.length) {
+      await terminateOwnedProcessGroups(config, ownership, { records, liveChildren: snapshot.map((entry) => entry.child) });
+      await clearProcessRecords(config);
+    }
+    try { await rm(config.socketPath, { force: true }); } catch {}
+  };
+
+  const shutdown = (reason) => {
+    if (shutdownPromise) return shutdownPromise;
+    stopping = true;
+    shutdownPromise = (async () => {
+      console.log(`[dev:stack] Stopping (${reason})...`);
+      let failure = null;
+      try { await stopChildren(); }
+      catch (error) { failure = error; }
+      try { await stopDockerResources(config, ownership); }
+      catch (error) { failure ??= error; }
+      try { await releaseSupervisor(config); }
+      catch (error) { failure ??= error; }
+      if (failure) throw failure;
+    })();
+    return shutdownPromise;
+  };
+
+  const finishShutdown = (reason, preferredCode = 0) => {
+    void shutdown(reason).then(
+      () => process.exit(process.exitCode || preferredCode),
+      (error) => {
+        process.stderr.write(`[dev:stack] cleanup failed: ${error instanceof Error ? error.message : String(error)}\n`);
+        process.exit(1);
+      }
+    );
+  };
+
+  const unexpectedExit = (name, child, code, signal) => {
+    if (stopping || child !== children.get(name)?.child) return;
+    console.error(`[dev:stack] ${name} exited unexpectedly (${code ?? signal}); stopping the stack.`);
+    process.exitCode = 1;
+    finishShutdown("child-failure", 1);
+  };
+
+  const addChild = async (name, command, args, env) => {
+    if (stopping) throw new Error(`Refusing to start ${name} while the dev stack is stopping.`);
+    const entry = spawnService(config, name, command, args, env, ownership, unexpectedExit);
+    children.set(name, entry);
+    await persistChildren();
+  };
+
+  const spawnChildren = async (forceBuild = false, state) => {
+    await ensureBuild(config, forceBuild, runBuild);
+    const repairedHelpers = await ensureDarwinNodePtySpawnHelpers(config.root);
+    if (repairedHelpers.length) {
+      console.log(`[dev:stack] Repaired execute permission on ${repairedHelpers.length} node-pty macOS spawn helper(s).`);
+    }
+    const openCodeWrapper = await installOpenCode(config, state.openCodeVersion,
+      (command, args, options) => runCommand("opencode-install", command, args, options));
+    const env = sourceEnv(config, state.databaseUrl, state.sessionSecret, openCodeWrapper);
+    await addChild("cli-host", process.execPath, ["packages/cli-host/dist/main.js"], env);
+    await addChild("worker", process.execPath, ["apps/worker/dist/worker.js"], env);
+    await addChild("api", "npm", ["exec", "--", "tsx", "watch", "apps/api/src/server.ts"], env);
+    await addChild("web", "npm", ["run", "dev", "-w", "@space/web", "--", "--host", "127.0.0.1", "--port", String(config.ports.web)], env);
+  };
+
+  let runtimeState = null;
+  const reload = () => {
+    reloadChain = reloadChain.then(async () => {
+      if (stopping) return;
+      console.log("[dev:stack] Rebuilding workspaces and restarting source services...");
+      await stopChildren();
+      if (stopping) return;
+      await spawnChildren(true, runtimeState);
+      if (stopping) {
+        await stopChildren();
+        return;
+      }
+      await waitReady(config);
+      console.log("[dev:stack] Rebuild complete; source services are ready.");
+    }).catch((error) => {
+      console.error(`[dev:stack] rebuild failed: ${error instanceof Error ? error.message : String(error)}`);
+      process.exitCode = 1;
+      finishShutdown("rebuild-failure", 1);
+    });
+  };
+
+  // Keep handlers installed throughout asynchronous cleanup: a concurrent down
+  // or reset must join the same shutdown, not restore the default fatal signal.
+  process.on("SIGINT", () => finishShutdown("SIGINT"));
+  process.on("SIGTERM", () => finishShutdown("SIGTERM"));
+  process.on("SIGHUP", reload);
+
+  try {
+    await terminateOwnedProcessGroups(config, ownership);
+    await dockerResources(config, ownership);
+
+    const composeTemplate = await readFile(resolve(config.root, "packages/run-spaceapp/templates/compose.yml"), "utf8");
+    const dockerfile = await readFile(resolve(config.root, "Dockerfile"), "utf8");
+    const images = parsePinnedImages(composeTemplate);
+    const openCodeVersion = parseOpenCodeVersion(dockerfile);
+    const { databaseUrl, sessionSecret, postgresPassword } = await prepareState(config);
+    runtimeState = { databaseUrl, sessionSecret, openCodeVersion };
+
+    await mkdir(dirname(config.composeFile), { recursive: true, mode: 0o700 });
+    await writeFile(config.composeFile, renderCompose(config, images, ownership), { mode: 0o600 });
+    await writeFile(config.configFile, `${JSON.stringify({
+      root: config.root,
+      stateRoot: config.stateRoot,
+      project: config.project,
+      ports: config.ports,
+      socketPath: config.socketPath,
+      openCodeVersion
+    }, null, 2)}\n`, { mode: 0o600 });
+
+    console.log(`[dev:stack] Starting digest-pinned PostgreSQL and Temporal (${config.project})...`);
+    await compose(config, ["up", "-d", "postgres", "temporal"], {
+      env: { ...process.env, SPACEAPP_DEV_POSTGRES_PASSWORD: postgresPassword }
+    });
+    await Promise.all([
+      waitHealthy(config, "postgres"),
+      waitServiceHealthyWithDiagnostics(config, "temporal", 240_000)
+    ]);
+    await ensureTemporalNamespace(config);
+    await ensureBuild(config, false, runBuild);
+    console.log("[dev:stack] Applying database migrations...");
+    await runCommand("migrations", "npm", ["run", "db:migrate"], { env: { ...process.env, SPACE_DATABASE_URL: databaseUrl } });
+    await spawnChildren(false, runtimeState);
+    await waitReady(config);
+    const setupBanner = await ownerSetupBanner(config);
+    console.log("\n============================================================");
+    console.log("SpaceApp dev stack is READY");
+    console.log(`Web:   http://127.0.0.1:${config.ports.web}`);
+    console.log(`API:   http://127.0.0.1:${config.ports.api}`);
+    console.log(setupBanner);
+    console.log("Package changes: npm run dev:stack -- rebuild");
+    console.log("Stop: npm run dev:stack -- down | Reset: npm run dev:stack -- reset");
+    console.log("============================================================\n");
+    await new Promise(() => {});
+  } catch (error) {
+    process.exitCode = 1;
+    try { await shutdown("startup-failure"); }
+    catch (cleanupError) {
+      process.stderr.write(`[dev:stack] cleanup failed after startup error: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}\n`);
+    }
+    throw error;
+  }
+}
+
+async function main() {
+  const command = process.argv[2] || "up";
+  assertSafeDevStackOverrides();
+  const config = await resolveConfig();
+  if (["up", "start"].includes(command)) return start(config);
+  if (["down", "stop"].includes(command)) return down(config);
+  if (command === "reset") return reset(config);
+  if (command === "status") return status(config);
+  if (command === "rebuild") return rebuild(config);
+  throw new Error(`Unknown dev:stack command ${JSON.stringify(command)}. Use up, down, reset, status, or rebuild.`);
+}
+
+if (process.argv[1] && resolve(process.argv[1]) === scriptPath) {
+  main().catch((error) => {
+    process.stderr.write(`[dev:stack] ERROR: ${error instanceof Error ? error.message : String(error)}\n`);
+    process.exitCode = 1;
+  });
+}
diff --git a/deploy/docker/dev-stack.test.mjs b/deploy/docker/dev-stack.test.mjs
new file mode 100644
index 000000000..e330d5bb9
--- /dev/null
+++ b/deploy/docker/dev-stack.test.mjs
@@ -0,0 +1,964 @@
+import assert from "node:assert/strict";
+import { execFile, spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { createServer } from "node:http";
+import { chmod, mkdir, mkdtemp, readFile, readdir, rm, stat, symlink, utimes, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import { promisify } from "node:util";
+import {
+  assertSafeStateRoot,
+  dockerResources,
+  ensureBuild,
+  installOpenCode,
+  ownerSetupBanner,
+  waitReady,
+  parseOpenCodeVersion,
+  parsePinnedImages,
+  prepareState,
+  renderCompose,
+  resolveConfig,
+  run,
+  sleep,
+  sourceEnv
+} from "./dev-stack-lib.mjs";
+import { ensureDarwinNodePtySpawnHelpers, reset, spawnService } from "./dev-stack.mjs";
+import {
+  assertSafeDevStackOverrides,
+  claimStateOwnership,
+  claimSupervisor,
+  ownedSupervisorPid,
+  readStateOwnership,
+  releaseSupervisor,
+  spawnOwnedProcess,
+  supervisorRecordMatches,
+  terminateOwnedProcessGroups,
+  writeProcessRecords
+} from "./dev-stack-safety.mjs";
+
+const ownership = (rootHash) => ({ version: 1, rootHash, token: "a".repeat(48) });
+
+test("captured commands wait for inherited output streams to close", async () => {
+  const delayedOutput = 'setTimeout(() => { process.stdout.write("complete output"); process.stderr.write("complete error"); }, 100)';
+  const script = `
+    require("node:child_process").spawn(process.execPath, ["-e", ${JSON.stringify(delayedOutput)}], { stdio: ["ignore", process.stdout, process.stderr] });
+    process.exit(0);
+  `;
+  const result = await run(process.execPath, ["-e", script], { capture: true });
+  assert.equal(result.stdout, "complete output");
+  assert.match(result.stderr, /complete error$/);
+});
+
+test("build markers ignore generated-directory timestamps but detect source changes and deletions", async () => {
+  const root = await mkdtemp(join(tmpdir(), "spaceapp-build-marker-"));
+  const config = { root, buildMarker: join(root, "build.json") };
+  const source = join(root, "packages", "contracts", "src", "index.ts");
+  const artifacts = ["packages/contracts/dist/index.js", "packages/runtime/dist/index.js", "packages/db/dist/migrate.js", "packages/cli-host/dist/main.js", "apps/worker/dist/worker.js"];
+  let builds = 0;
+  try {
+    await mkdir(join(root, "packages", "contracts", "src"), { recursive: true });
+    await mkdir(join(root, "apps", "worker", "src"), { recursive: true });
+    await writeFile(source, "export const value = 1;\n");
+    const runner = async () => {
+      builds += 1;
+      for (const artifact of artifacts) {
+        const target = join(root, artifact);
+        await mkdir(join(target, ".."), { recursive: true });
+        await writeFile(target, "// built\n");
+      }
+      const future = new Date(Date.now() + 2000);
+      await utimes(join(root, "packages"), future, future);
+    };
+    await ensureBuild(config, false, runner);
+    await ensureBuild(config, false, runner);
+    assert.equal(builds, 1, "startup must not rebuild solely because dist directories were created");
+
+    await writeFile(source, "export const value = 22;\n");
+    await ensureBuild(config, false, runner);
+    assert.equal(builds, 2);
+    await rm(source);
+    await ensureBuild(config, false, runner);
+    assert.equal(builds, 3, "source deletion must invalidate the marker");
+    await rm(join(root, artifacts[0]));
+    await ensureBuild(config, false, runner);
+    assert.equal(builds, 4, "missing artifacts must trigger a build");
+    await ensureBuild(config, true, runner);
+    assert.equal(builds, 5, "explicit rebuild must remain unconditional");
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test("startup build ownership covers cancellation, success, and failure", { skip: process.platform === "win32" }, async (t) => {
+  for (const mode of ["cancel", "renamed-cancel", "slow-down", "repeated-stop", "success", "failure", "spawn-failure"]) await t.test(mode, async () => {
+    const delayedDocker = ["slow-down", "repeated-stop"].includes(mode);
+    const cancel = mode.endsWith("cancel") || delayedDocker;
+    const root = await mkdtemp(join(tmpdir(), "spaceapp-build-cancel-"));
+    const config = await resolveConfig({}, root);
+    const bin = join(root, "fake-bin");
+    const familyFile = join(root, "build-family.json");
+    const migrationFile = join(root, "migration-started");
+    const dockerStopping = join(root, "docker-stopping");
+    const dockerStopped = join(root, "docker-stopped");
+    let supervisor;
+    let downCaller;
+    let unrelated;
+    let family;
+    let output = "";
+    try {
+      await mkdir(bin);
+      await mkdir(join(root, "packages", "run-spaceapp", "templates"), { recursive: true });
+      await writeFile(join(root, "packages", "run-spaceapp", "templates", "compose.yml"), `services:\n  postgres:\n    image: pgvector/pgvector:test@sha256:${"a".repeat(64)}\n  temporal:\n    image: temporalio/auto-setup:test@sha256:${"b".repeat(64)}\n`);
+      await writeFile(join(root, "Dockerfile"), "RUN npm install opencode-ai@1.18.4\n");
+      await writeFile(join(bin, "docker"), `#!${process.execPath}
+        const args = process.argv.slice(2);
+        const fs = require("node:fs");
+        if (${delayedDocker} && args[0] === "ps" && !fs.existsSync(${JSON.stringify(dockerStopped)})) console.log("fixture-container");
+        else if (${delayedDocker} && args[0] === "compose" && args.includes("down")) {
+          fs.appendFileSync(${JSON.stringify(dockerStopping)}, "down\\n");
+          setTimeout(() => fs.writeFileSync(${JSON.stringify(dockerStopped)}, "stopped"), ${mode === "slow-down" ? 16100 : 300});
+        }
+        else if (args[0] === "inspect") console.log("healthy");
+        else if (args[0] === "compose" && args.includes("ps")) console.log("fixture-service");
+      `, { mode: 0o700 });
+      await writeFile(join(bin, "npm"), `#!${process.execPath}
+        const fs = require("node:fs");
+        if (process.argv[3] === "build") {
+          if (${!cancel}) {
+            fs.writeFileSync(${JSON.stringify(familyFile)}, JSON.stringify({ leader: process.pid }));
+            process.exit(${mode === "failure" ? 2 : 0});
+          }
+          process.title = "npm run build";
+          const descendant = require("node:child_process").spawn(process.execPath, ["-e", "setInterval(() => {}, 1000)"], { env: {}, stdio: ["ignore", "inherit", "inherit"] });
+          fs.writeFileSync(${JSON.stringify(familyFile)}, JSON.stringify({ leader: process.pid, descendant: descendant.pid }));
+          setInterval(() => {}, 1000);
+        } else if (process.argv[3] === "db:migrate") {
+          fs.writeFileSync(${JSON.stringify(migrationFile)}, fs.readFileSync(${JSON.stringify(config.processFile)}, "utf8"));
+          process.exit(2); // Stop the fixture before launching real services.
+        }
+      `, { mode: 0o700 });
+      if (mode === "renamed-cancel") {
+        // Darwin ps can stop at process.title's NUL padding before reaching
+        // the environment. Model that output on every test platform.
+        await writeFile(join(bin, "ps"), `#!${process.execPath}
+          const fs = require("node:fs");
+          const args = process.argv.slice(2);
+          const family = fs.existsSync(${JSON.stringify(familyFile)}) ? JSON.parse(fs.readFileSync(${JSON.stringify(familyFile)}, "utf8")) : {};
+          if (args[0] === "eww" && Number(args[args.indexOf("-p") + 1]) === family.leader) {
+            console.log("npm run build");
+          } else {
+            const result = require("node:child_process").spawnSync("/bin/ps", args, { encoding: "utf8" });
+            process.stdout.write(result.stdout || "");
+            process.stderr.write(result.stderr || "");
+            process.exit(result.status ?? 1);
+          }
+        `, { mode: 0o700 });
+      }
+      if (mode === "spawn-failure") {
+        await writeFile(join(bin, "npm"), "#!/spaceapp-test-nonexistent-interpreter\n", { mode: 0o700 });
+      }
+      const launcher = join(root, "dev-stack.mjs");
+      await writeFile(launcher, `
+        import { start } from ${JSON.stringify(new URL("./dev-stack.mjs", import.meta.url).href)};
+        import { resolveConfig } from ${JSON.stringify(new URL("./dev-stack-lib.mjs", import.meta.url).href)};
+        start(await resolveConfig({}, ${JSON.stringify(root)})).catch(error => { console.error(error.message); process.exitCode = 1; });
+      `);
+      unrelated = spawn(process.execPath, ["-e", "setInterval(() => {}, 1000)"], { detached: true, stdio: "ignore" });
+      supervisor = spawn(process.execPath, [launcher], {
+        detached: true,
+        env: { ...process.env, PATH: `${bin}:${process.env.PATH || ""}` },
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      supervisor.stdout.on("data", chunk => { output += chunk.toString(); });
+      supervisor.stderr.on("data", chunk => { output += chunk.toString(); });
+      const startedDeadline = Date.now() + 10000;
+      while (!existsSync(familyFile) && Date.now() < startedDeadline && supervisor.exitCode === null) await sleep(25);
+      assert.equal(existsSync(familyFile), mode !== "spawn-failure", output);
+      if (existsSync(familyFile)) family = JSON.parse(await readFile(familyFile, "utf8"));
+      if (delayedDocker) {
+        const downLauncher = join(root, "down.mjs");
+        await writeFile(downLauncher, `
+          import { down } from ${JSON.stringify(new URL("./dev-stack.mjs", import.meta.url).href)};
+          import { resolveConfig } from ${JSON.stringify(new URL("./dev-stack-lib.mjs", import.meta.url).href)};
+          down(await resolveConfig({}, ${JSON.stringify(root)})).catch(error => { console.error(error.message); process.exitCode = 1; });
+        `);
+        downCaller = spawn(process.execPath, [downLauncher], { env: { ...process.env, PATH: `${bin}:${process.env.PATH || ""}` }, stdio: ["ignore", "pipe", "pipe"] });
+        downCaller.stdout.on("data", chunk => { output += chunk.toString(); });
+        downCaller.stderr.on("data", chunk => { output += chunk.toString(); });
+        const stoppingDeadline = Date.now() + 10000;
+        while (!existsSync(dockerStopping) && Date.now() < stoppingDeadline) await sleep(25);
+        assert.equal(existsSync(dockerStopping), true, output);
+        if (mode === "repeated-stop") {
+          supervisor.kill("SIGTERM");
+          supervisor.kill("SIGINT");
+          await sleep(25);
+          supervisor.kill("SIGINT");
+        }
+      } else if (cancel) supervisor.kill("SIGTERM");
+      const stoppedDeadline = Date.now() + (delayedDocker ? 25000 : 10000);
+      while (supervisor.exitCode === null && supervisor.signalCode === null && Date.now() < stoppedDeadline) await sleep(25);
+      assert.notEqual(supervisor.exitCode ?? supervisor.signalCode, null, output);
+      if (downCaller) {
+        while (downCaller.exitCode === null && downCaller.signalCode === null && Date.now() < stoppedDeadline) await sleep(25);
+        assert.equal(downCaller.exitCode, 0, output);
+        assert.equal(supervisor.signalCode, null, "Repeated stop signals must not interrupt the supervisor's cleanup.");
+        assert.equal(await readFile(dockerStopping, "utf8"), "down\n", "Only the supervisor should run Docker teardown while it is alive.");
+      }
+      for (const pid of [family?.leader, family?.descendant].filter(Number.isInteger)) {
+        const result = await run("ps", ["-p", String(pid), "-o", "stat="], { capture: true, allowFailure: true });
+        assert.ok(result.code !== 0 || result.stdout.startsWith("Z"), `build PID ${pid} survived cancellation: ${result.stdout}`);
+      }
+      assert.equal(existsSync(migrationFile), mode === "success", "only successful builds may advance startup to migrations");
+      assert.equal(existsSync(config.buildMarker), mode === "success", "only successful builds may write a success marker");
+      if (mode === "success") {
+        assert.deepEqual(JSON.parse(await readFile(migrationFile, "utf8")).groups.map(record => record.name), ["migrations"], "completed builds must be untracked while migrations own their command group");
+      }
+      if (existsSync(config.processFile)) {
+        assert.deepEqual(JSON.parse(await readFile(config.processFile, "utf8")).groups, [], "terminated builds must leave no tracked groups");
+      }
+      assert.equal(existsSync(config.pidFile), false);
+      assert.doesNotThrow(() => process.kill(unrelated.pid, 0), "an unrelated process must remain alive");
+    } finally {
+      if (downCaller?.exitCode === null && downCaller?.signalCode === null) downCaller.kill("SIGKILL");
+      for (const pid of [supervisor?.pid, family?.leader, unrelated?.pid]) {
+        if (Number.isInteger(pid)) try { process.kill(-pid, "SIGKILL"); } catch {}
+      }
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+});
+
+test("down and reset terminate in-progress migrations and OpenCode installs", { skip: process.platform === "win32" }, async (t) => {
+  for (const phase of ["db:migrate", "opencode-install"]) await t.test(phase, async () => {
+    const root = await mkdtemp(join(tmpdir(), "spaceapp-startup-command-"));
+    const config = await resolveConfig({}, root);
+    const bin = join(root, "fake-bin");
+    const familyFile = join(root, "command-family.json");
+    let supervisor;
+    let downCaller;
+    let unrelated;
+    let family;
+    let output = "";
+    try {
+      await mkdir(bin);
+      await mkdir(join(root, "packages", "run-spaceapp", "templates"), { recursive: true });
+      await writeFile(join(root, "packages", "run-spaceapp", "templates", "compose.yml"), `services:\n  postgres:\n    image: pgvector/pgvector:test@sha256:${"a".repeat(64)}\n  temporal:\n    image: temporalio/auto-setup:test@sha256:${"b".repeat(64)}\n`);
+      await writeFile(join(root, "Dockerfile"), "RUN npm install opencode-ai@1.18.4\n");
+      await writeFile(join(bin, "docker"), `#!${process.execPath}
+        const args = process.argv.slice(2);
+        if (args[0] === "inspect") console.log("healthy");
+        else if (args[0] === "compose" && args.includes("ps")) console.log("fixture-service");
+      `, { mode: 0o700 });
+      await writeFile(join(bin, "npm"), `#!${process.execPath}
+        const args = process.argv.slice(2);
+        const phase = args[0] === "install" ? "opencode-install" : args[1];
+        if (phase === ${JSON.stringify(phase)}) {
+          process.title = "npm " + args.slice(0, 2).join(" ");
+          const descendant = require("node:child_process").spawn(process.execPath, ["-e", "setInterval(() => {}, 1000)"], { env: {}, stdio: ["ignore", "inherit", "inherit"] });
+          require("node:fs").writeFileSync(${JSON.stringify(familyFile)}, JSON.stringify({ leader: process.pid, descendant: descendant.pid }));
+          setInterval(() => {}, 1000);
+        }
+      `, { mode: 0o700 });
+      const launcher = join(root, "dev-stack.mjs");
+      const lifecycle = join(root, "lifecycle.mjs");
+      const libUrl = new URL("./dev-stack-lib.mjs", import.meta.url).href;
+      const stackUrl = new URL("./dev-stack.mjs", import.meta.url).href;
+      await writeFile(launcher, `
+        import { start } from ${JSON.stringify(stackUrl)};
+        import { resolveConfig } from ${JSON.stringify(libUrl)};
+        start(await resolveConfig({}, ${JSON.stringify(root)})).catch(error => { console.error(error.message); process.exitCode = 1; });
+      `);
+      await writeFile(lifecycle, `
+        import { down, reset } from ${JSON.stringify(stackUrl)};
+        import { resolveConfig } from ${JSON.stringify(libUrl)};
+        const command = process.argv[2] === "reset" ? reset : down;
+        command(await resolveConfig({}, ${JSON.stringify(root)})).catch(error => { console.error(error.message); process.exitCode = 1; });
+      `);
+      const env = { ...process.env, PATH: `${bin}:${process.env.PATH || ""}` };
+      unrelated = spawn(process.execPath, ["-e", "setInterval(() => {}, 1000)"], { detached: true, stdio: "ignore" });
+      supervisor = spawn(process.execPath, [launcher], { detached: true, env, stdio: ["ignore", "pipe", "pipe"] });
+      supervisor.stdout.on("data", chunk => { output += chunk.toString(); });
+      supervisor.stderr.on("data", chunk => { output += chunk.toString(); });
+      const startedDeadline = Date.now() + 10000;
+      while (!existsSync(familyFile) && Date.now() < startedDeadline && supervisor.exitCode === null) await sleep(25);
+      assert.equal(existsSync(familyFile), true, output);
+      family = JSON.parse(await readFile(familyFile, "utf8"));
+      downCaller = spawn(process.execPath, [lifecycle, "down"], { env, stdio: ["ignore", "pipe", "pipe"] });
+      downCaller.stdout.on("data", chunk => { output += chunk.toString(); });
+      downCaller.stderr.on("data", chunk => { output += chunk.toString(); });
+      const stoppedDeadline = Date.now() + 10000;
+      while ((downCaller.exitCode === null && downCaller.signalCode === null || supervisor.exitCode === null && supervisor.signalCode === null) && Date.now() < stoppedDeadline) await sleep(25);
+      assert.equal(downCaller.exitCode, 0, output);
+      assert.notEqual(supervisor.exitCode, null, output);
+      const survivors = [];
+      for (const pid of [family.leader, family.descendant]) {
+        const result = await run("ps", ["-p", String(pid), "-o", "stat="], { capture: true, allowFailure: true });
+        if (result.code === 0 && !result.stdout.startsWith("Z")) survivors.push({ pid, state: result.stdout });
+      }
+      assert.deepEqual(survivors, [], `${phase} processes survived down: ${JSON.stringify(survivors)}`);
+      assert.equal(existsSync(config.pidFile), false);
+      assert.equal(existsSync(config.processFile), false);
+      await run(process.execPath, [lifecycle, "reset"], { env, capture: true });
+      assert.equal(existsSync(config.stateRoot), false);
+      assert.doesNotThrow(() => process.kill(unrelated.pid, 0), "an unrelated process must remain alive");
+    } finally {
+      if (downCaller?.exitCode === null && downCaller?.signalCode === null) downCaller.kill("SIGKILL");
+      for (const pid of [supervisor?.pid, family?.leader, unrelated?.pid]) {
+        if (Number.isInteger(pid)) try { process.kill(-pid, "SIGKILL"); } catch {}
+      }
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+});
+
+test("owner setup banner only reveals a live, unclaimed token", async () => {
+  const config = { ports: { api: 5910 }, secretsDir: "/test/secrets" };
+  const token = "a".repeat(64);
+  const nowMs = Date.parse("2026-10-19T00:00:00Z");
+  let status = { setupRequired: true, expiresAt: "2026-10-19T00:15:00Z" };
+  let reads = 0;
+  const readSecret = async (path, encoding) => {
+    reads++;
+    assert.equal(path, join(config.secretsDir, "setup-token"));
+    assert.equal(encoding, "utf8");
+    return `${token}\n`;
+  };
+  const request = async (url, options) => {
+    assert.equal(url, "http://127.0.0.1:5910/api/setup/status");
+    assert.equal(options.method, "GET");
+    assert.equal(options.redirect, "error");
+    assert.equal(options.headers.accept, "application/json");
+    assert.ok(options.signal instanceof AbortSignal);
+    return { ok: true, status: 200, json: async () => status };
+  };
+  const options = { request, readSecret, nowMs };
+
+  assert.equal(await ownerSetupBanner(config, options), `Owner setup token: ${token}`);
+  assert.equal(reads, 1);
+
+  status = { setupRequired: false, expiresAt: null };
+  const claimed = await ownerSetupBanner(config, options);
+  assert.match(claimed, /Owner setup already complete/);
+  assert.doesNotMatch(claimed, /[a-f0-9]{64}/);
+  assert.equal(reads, 1, "claimed owner must never cause a secret read");
+
+  status = { setupRequired: true, expiresAt: "2026-10-18T23:59:59Z" };
+  assert.match(await ownerSetupBanner(config, options), /expired or unavailable/);
+  assert.equal(reads, 1, "expired setup token must not be read");
+
+  status = { setupRequired: true, expiresAt: null };
+  assert.match(await ownerSetupBanner(config, options), /expired or unavailable/);
+  assert.equal(reads, 1, "missing expiry must not disclose a token");
+
+  status = { setupRequired: true, expiresAt: "2026-10-19T00:15:00Z" };
+  await assert.rejects(() => ownerSetupBanner(config, {
+    request,
+    nowMs,
+    readSecret: async () => "unsafe\\nvalue"
+  }), /Invalid dev-stack owner setup token file/);
+});
+
+test("owner setup banner fails closed on unverifiable API status", async () => {
+  const config = { ports: { api: 5910 }, secretsDir: "/test/secrets" };
+  const readSecret = async () => {
+    assert.fail("unverified owner status must not read local token");
+  };
+  for (const [name, response] of [
+    ["unauthorized response", { ok: false, status: 503 }],
+    ["missing field", { ok: true, json: async () => ({ expiresAt: null }) }],
+    ["invalid expiry type", { ok: true, json: async () => ({ setupRequired: true, expiresAt: 123 }) }],
+    ["malformed payload", { ok: true, json: async () => null }]
+  ]) {
+    await assert.rejects(
+      () => ownerSetupBanner(config, { readSecret, request: async () => response }),
+      /status|token/,
+      name
+    );
+  }
+});
+
+test("readiness returns on deadline when HTTP headers or body never finish", { timeout: 7000 }, async () => {
+  for (const stallAfterHeaders of [false, true]) {
+    const server = createServer((_request, response) => {
+      if (stallAfterHeaders) {
+        response.writeHead(200, { "content-type": "application/json" });
+        response.flushHeaders();
+      }
+      // Deliberately never send a response body or end the connection.
+    });
+    await new Promise((resolvePromise, rejectPromise) => {
+      server.once("error", rejectPromise);
+      server.listen(0, "127.0.0.1", resolvePromise);
+    });
+    try {
+      const startedAt = Date.now();
+      await assert.rejects(
+        () => waitReady({ ports: { api: server.address().port } }, 150),
+        /did not reach \/readyz/,
+        stallAfterHeaders ? "stalled response body" : "stalled response headers"
+      );
+      assert.ok(Date.now() - startedAt < 2500, "readiness must honor an overall deadline");
+    } finally {
+      server.closeAllConnections();
+      await new Promise((resolvePromise, rejectPromise) => {
+        server.close((error) => error ? rejectPromise(error) : resolvePromise());
+      });
+    }
+  }
+});
+
+test("source stack derives third-party pins from canonical files", () => {
+  const images = parsePinnedImages(`
+services:
+  postgres:
+    image: pgvector/pgvector:0.8.3-pg17-trixie@sha256:${"a".repeat(64)}
+  temporal:
+    image: temporalio/auto-setup:1.29.1@sha256:${"b".repeat(64)}
+`);
+  assert.equal(images.postgres, `pgvector/pgvector:0.8.3-pg17-trixie@sha256:${"a".repeat(64)}`);
+  assert.equal(images.temporal, `temporalio/auto-setup:1.29.1@sha256:${"b".repeat(64)}`);
+  assert.equal(parseOpenCodeVersion("RUN npm install --global opencode-ai@1.18.4"), "1.18.4");
+  assert.throws(() => parsePinnedImages("services: {}"), /digest-pinned/);
+  assert.throws(() => parseOpenCodeVersion("RUN npm install opencode-ai@latest"), /pinned/);
+});
+
+test("OpenCode wrapper isolates writable state and preserves literal checkout paths", async () => {
+  const root = await mkdtemp(join(tmpdir(), "spaceapp-opencode-$literal-'quote-"));
+  try {
+    const config = await resolveConfig({}, root);
+    await mkdir(config.binDir, { recursive: true });
+    await mkdir(join(config.vendorDir, "node_modules", "opencode-ai"), { recursive: true });
+    await mkdir(join(config.vendorDir, "node_modules", ".bin"), { recursive: true });
+    await writeFile(join(config.vendorDir, "node_modules", "opencode-ai", "package.json"), JSON.stringify({ version: "1.18.4" }));
+    const keys = ["HOME", "XDG_CONFIG_HOME", "XDG_DATA_HOME", "XDG_CACHE_HOME", "XDG_STATE_HOME", "TMPDIR", "TMP", "TEMP"];
+    await writeFile(join(config.vendorDir, "node_modules", ".bin", "opencode"),
+      `#!${process.execPath}\nconsole.log(JSON.stringify({paths:Object.fromEntries(${JSON.stringify(keys)}.map(k=>[k,process.env[k]])),key:process.env.OPENCODE_API_KEY,args:process.argv.slice(2)}));\n`, { mode: 0o700 });
+    const wrapper = await installOpenCode(config, "1.18.4");
+    const { stdout } = await promisify(execFile)(wrapper, ["argument with spaces", "$literal"], {
+      env: { ...process.env, ...Object.fromEntries(keys.map((key) => [key, "/proc/spaceapp-unwritable"])), OPENCODE_API_KEY: "parent-key" }
+    });
+    const result = JSON.parse(stdout);
+    const dirs = ["home", "config", "data", "cache", "state", "tmp", "tmp", "tmp"];
+    for (const [index, key] of keys.entries()) {
+      assert.equal(result.paths[key], join(config.providerRoot, dirs[index]));
+      assert.equal((await stat(result.paths[key])).isDirectory(), true);
+    }
+    assert.equal(result.key, undefined);
+    assert.deepEqual(result.args, ["argument with spaces", "$literal"]);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test("reset removes only the state directory it initialized when Docker inventory is empty", async () => {
+  const root = await mkdtemp(join(tmpdir(), "spaceapp-reset-empty-"));
+  const oldPath = process.env.PATH;
+  try {
+    const bin = join(root, "fake-bin");
+    await mkdir(bin);
+    await writeFile(join(bin, "docker"), "#!/bin/sh\nexit 0\n", { mode: 0o700 });
+    process.env.PATH = `${bin}:${oldPath || ""}`;
+    const config = await resolveConfig({}, root);
+    await claimStateOwnership(config);
+    await reset(config);
+    assert.equal(existsSync(config.stateRoot), false);
+  } finally {
+    if (oldPath === undefined) delete process.env.PATH;
+    else process.env.PATH = oldPath;
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test("streaming credentials stay private inside owned state and reset preserves an installed instance", async () => {
+  const root = await mkdtemp(join(tmpdir(), "spaceapp-streaming-isolation-"));
+  const installedRoot = join(root, "installed-streaming");
+  const oldPath = process.env.PATH;
+  const oldStreamingRoot = process.env.SPACE_STREAMING_SECRET_ROOT;
+  try {
+    await mkdir(installedRoot, { mode: 0o755 });
+    const sentinel = join(installedRoot, "keep.json");
+    await writeFile(sentinel, "installed instance\n", { mode: 0o600 });
+    const installedMode = (await stat(installedRoot)).mode & 0o777;
+    process.env.SPACE_STREAMING_SECRET_ROOT = installedRoot;
+    const config = await resolveConfig({}, root);
+    const env = sourceEnv(config, "postgresql://unused", "test-session-secret", join(config.binDir, "opencode-vscode-parity"));
+    assert.equal(env.SPACE_STREAMING_SECRET_ROOT, join(config.secretsDir, "streaming"));
+    await claimStateOwnership(config);
+    await prepareState(config);
+    await run(process.execPath, ["--import", "tsx", "--input-type=module", "-e", `
+      import { StreamingCredentialStore } from "./packages/streaming/src/credential-store.ts";
+      const store = new StreamingCredentialStore(process.env.SPACE_STREAMING_SECRET_ROOT);
+      await store.writeCredential("dev-stack-probe", { probe: "owned test data" });
+    `], { env, capture: true });
+    const streamingRoot = env.SPACE_STREAMING_SECRET_ROOT;
+    const credentials = join(streamingRoot, "credentials");
+    assert.equal((await stat(streamingRoot)).mode & 0o777, 0o700);
+    assert.equal((await stat(credentials)).mode & 0o777, 0o700);
+    const files = await readdir(credentials);
+    assert.equal(files.length, 1);
+    assert.equal((await stat(join(credentials, files[0]))).mode & 0o777, 0o600);
+
+    const bin = join(root, "fake-bin");
+    await mkdir(bin);
+    await writeFile(join(bin, "docker"), "#!/bin/sh\nexit 0\n", { mode: 0o700 });
+    process.env.PATH = `${bin}:${oldPath || ""}`;
+    await reset(config);
+    assert.equal(existsSync(config.stateRoot), false);
+    assert.equal(await readFile(sentinel, "utf8"), "installed instance\n");
+    assert.equal((await stat(installedRoot)).mode & 0o777, installedMode);
+    assert.deepEqual(await readdir(installedRoot), ["keep.json"]);
+  } finally {
+    if (oldPath === undefined) delete process.env.PATH;
+    else process.env.PATH = oldPath;
+    if (oldStreamingRoot === undefined) delete process.env.SPACE_STREAMING_SECRET_ROOT;
+    else process.env.SPACE_STREAMING_SECRET_ROOT = oldStreamingRoot;
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test("defaults isolate installed SpaceApp and bind Docker ports to loopback", async () => {
+  const root = await mkdtemp(join(tmpdir(), "spaceapp-dev-test-"));
+  try {
+    const config = await resolveConfig({}, root);
+    assert.notEqual(config.ports.api, 4910);
+    assert.notEqual(config.ports.web, 4911);
+    assert.match(config.project, /^spaceapp-dev-[a-f0-9]{10}$/);
+    const compose = renderCompose(config, {
+      postgres: `pgvector/pgvector:0.8.3@sha256:${"c".repeat(64)}`,
+      temporal: `temporalio/auto-setup:1.29.1@sha256:${"d".repeat(64)}`
+    }, ownership(config.rootHash));
+    for (const port of [config.ports.postgres, config.ports.temporal]) assert.match(compose, new RegExp(`127\\.0\\.0\\.1:${port}:`));
+    assert.match(compose, /POSTGRES_PASSWORD: \$\{SPACEAPP_DEV_POSTGRES_PASSWORD/);
+    assert.match(compose, /POSTGRES_PWD: \$\{SPACEAPP_DEV_POSTGRES_PASSWORD/);
+    assert.doesNotMatch(compose, /\/run\/secrets\/postgres-password|secrets:\s*\[postgres-password\]/);
+    assert.match(compose, /condition: service_healthy/);
+    assert.match(compose, /temporal operator cluster health --address temporal:7233/);
+    assert.equal((compose.match(/com\.spaceapp\.dev-stack\.owner:/g) || []).length, 4);
+
+    const wrapper = join(config.binDir, "opencode-vscode-parity");
+    const oldComposePassword = process.env.SPACEAPP_DEV_POSTGRES_PASSWORD;
+    const oldProcessToken = process.env.SPACE_DEV_PROCESS_TOKEN;
+    process.env.SPACEAPP_DEV_POSTGRES_PASSWORD = "compose-only-secret";
+    process.env.SPACE_DEV_PROCESS_TOKEN = "caller-supplied-token";
+    try {
+      const env = sourceEnv(config, "postgresql://spaceapp:test@127.0.0.1:55432/spaceapp_dev", "session-secret-with-enough-length", wrapper);
+      assert.equal(env.SPACE_CLI_COMMAND_PATH, config.binDir);
+      assert.equal(env.SPACE_CLI_OPENCODE_COMMAND, "opencode-vscode-parity");
+      assert.equal(env.SPACE_DEV_LOGIN, "false");
+      assert.equal(env.SPACE_API_HOST, "127.0.0.1");
+      assert.equal(env.SPACE_WEB_HOST, "127.0.0.1");
+      assert.equal(env.SPACEAPP_DEV_POSTGRES_PASSWORD, undefined);
+      assert.equal(env.SPACE_DEV_PROCESS_TOKEN, undefined);
+      assert.throws(() => sourceEnv(config, "postgresql://x", "session-secret-with-enough-length", "/tmp/opencode-vscode-parity"), /controlled dev-stack command directory/);
+    } finally {
+      if (oldComposePassword === undefined) delete process.env.SPACEAPP_DEV_POSTGRES_PASSWORD;
+      else process.env.SPACEAPP_DEV_POSTGRES_PASSWORD = oldComposePassword;
+      if (oldProcessToken === undefined) delete process.env.SPACE_DEV_PROCESS_TOKEN;
+      else process.env.SPACE_DEV_PROCESS_TOKEN = oldProcessToken;
+    }
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test("source services do not inherit provider or cloud credentials", async () => {
+  const root = await mkdtemp(join(tmpdir(), "spaceapp-source-env-"));
+  const keys = ["AI_GATEWAY_API_KEY", "VERCEL_AI_GATEWAY_API_KEY", "QWEN_API_KEY", "KIMI_API_KEY", "XAI_API_KEY", "AUTOHAND_API_KEY", "AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY", "CUSTOM_PROVIDER_CREDENTIAL"];
+  const original = Object.fromEntries(keys.map((key) => [key, process.env[key]]));
+  try {
+    for (const key of keys) process.env[key] = `sentinel-${key}`;
+    const config = await resolveConfig({}, root);
+    const env = sourceEnv(config, "postgresql://unused", "test-session-secret", join(config.binDir, "opencode-vscode-parity"));
+    for (const key of keys) assert.equal(env[key], undefined, `${key} must not cross into source services`);
+    assert.equal(env.PATH, process.env.PATH);
+    assert.equal(env.HOME, process.env.HOME);
+    assert.equal(env.SPACE_MEMORY_ROOT, config.memoryRoot);
+  } finally {
+    for (const key of keys) {
+      if (original[key] === undefined) delete process.env[key];
+      else process.env[key] = original[key];
+    }
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test("rejects an overlong UTF-8 TMPDIR socket fallback before startup", async () => {
+  const base = await mkdtemp(join(tmpdir(), "spaceapp-socket-path-"));
+  const checkout = join(base, `checkout-${"é".repeat(35)}`);
+  const deepTmp = join(base, `temporary-${"é".repeat(35)}`);
+  const oldTmpdir = process.env.TMPDIR;
+  try {
+    await mkdir(checkout, { recursive: true });
+    await mkdir(deepTmp, { recursive: true });
+    process.env.TMPDIR = deepTmp;
+    assert.ok(Buffer.byteLength(join(checkout, "run", "cli-host.sock")) > 96);
+    await assert.rejects(() => resolveConfig({}, checkout), /Unix socket path exceeds the 96-byte limit after fallback/);
+  } finally {
+    if (oldTmpdir === undefined) delete process.env.TMPDIR;
+    else process.env.TMPDIR = oldTmpdir;
+    await rm(base, { recursive: true, force: true });
+  }
+});
+
+test("spawn failure is handled before PID validation can interrupt cleanup", async () => {
+  const failures = [];
+  assert.throws(() => spawnService(
+    { root: process.cwd() },
+    "missing-service",
+    join(tmpdir(), `no-such-spaceapp-command-${process.pid}`),
+    [],
+    {},
+    ownership("a".repeat(10)),
+    (...args) => failures.push(args)
+  ), /Could not establish a process-group leader/);
+  await new Promise((resolvePromise) => setImmediate(resolvePromise));
+  assert.equal(failures.length, 1);
+  assert.equal(failures[0][0], "missing-service");
+  assert.equal(failures[0][2], null);
+  assert.equal(failures[0][3].code, "ENOENT");
+});
+
+test("unsafe state roots and installed-instance ports fail closed", async () => {
+  const root = await mkdtemp(join(tmpdir(), "spaceapp-dev-root-"));
+  try {
+    await assert.rejects(() => assertSafeStateRoot(root, root), /Unsafe dev-stack state directory/);
+    const target = join(root, "real-state");
+    const link = join(root, ".dev-stack-link");
+    await mkdir(target);
+    await symlink(target, link);
+    await assert.rejects(() => assertSafeStateRoot(link, join(root, "checkout")), /may not be a symlink/);
+    await assert.rejects(() => resolveConfig({ SPACE_DEV_API_PORT: "4910" }, root), /reserved for an installed SpaceApp/);
+    await assert.rejects(() => resolveConfig({ SPACE_DEV_WEB_PORT: "4911" }, root), /reserved for an installed SpaceApp/);
+    await assert.rejects(() => resolveConfig({ SPACE_DEV_POSTGRES_PORT: "4910" }, root), /postgres port 4910 is reserved/);
+    await assert.rejects(() => resolveConfig({ SPACE_DEV_TEMPORAL_PORT: "4911" }, root), /temporal port 4911 is reserved/);
+    await assert.rejects(() => resolveConfig({ SPACE_DEV_API_PORT: "6000", SPACE_DEV_WEB_PORT: "6000" }, root), /conflicts/);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test("destructive ownership selectors cannot be overridden", () => {
+  assert.doesNotThrow(() => assertSafeDevStackOverrides({}));
+  assert.throws(() => assertSafeDevStackOverrides({ SPACE_DEV_STACK_DIR: "/tmp/shared" }), /SPACE_DEV_STACK_DIR/);
+  assert.throws(() => assertSafeDevStackOverrides({ SPACE_DEV_COMPOSE_PROJECT: "someone-elses-project" }), /SPACE_DEV_COMPOSE_PROJECT/);
+});
+
+test("state ownership never adopts a pre-existing or corrupt directory", async () => {
+  const root = await mkdtemp(join(tmpdir(), "spaceapp-state-owner-"));
+  const config = await resolveConfig({}, root);
+  try {
+    const owner = await claimStateOwnership(config);
+    assert.equal(owner.rootHash, config.rootHash);
+    assert.match(owner.token, /^[a-f0-9]{48}$/);
+    assert.deepEqual(await readStateOwnership(config), owner);
+
+    await writeFile(config.ownerFile, "not-json\n", { mode: 0o600 });
+    await assert.rejects(() => readStateOwnership(config), /unreadable/);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+
+  const preexistingRoot = await mkdtemp(join(tmpdir(), "spaceapp-state-preexisting-"));
+  const preexistingConfig = await resolveConfig({}, preexistingRoot);
+  try {
+    await mkdir(preexistingConfig.stateRoot, { mode: 0o700 });
+    await assert.rejects(() => claimStateOwnership(preexistingConfig), /Refusing to adopt pre-existing state directory/);
+    await writeFile(join(preexistingConfig.stateRoot, "keep-me"), "foreign\n");
+    await assert.rejects(() => claimStateOwnership(preexistingConfig), /Refusing to adopt pre-existing state directory/);
+    assert.equal(await readFile(join(preexistingConfig.stateRoot, "keep-me"), "utf8"), "foreign\n");
+  } finally {
+    await rm(preexistingRoot, { recursive: true, force: true });
+  }
+});
+
+test("docker inventory fails closed and rejects same-project resources without the ownership label", async () => {
+  const config = { project: "spaceapp-dev-test" };
+  const owner = { token: "b".repeat(48) };
+  const failingRunner = async () => ({ code: 1, stdout: "", stderr: "daemon unavailable" });
+  await assert.rejects(() => dockerResources(config, owner, failingRunner), /Docker inventory failed/);
+
+  const collisionRunner = async (_command, args) => {
+    const owned = args.some((arg) => String(arg).includes("com.spaceapp.dev-stack.owner="));
+    const kind = args[0] === "ps" ? "container" : args[0] === "volume" ? "volume" : "network";
+    return { code: 0, stdout: owned ? "" : `${kind}-1`, stderr: "" };
+  };
+  await assert.rejects(() => dockerResources(config, owner, collisionRunner), /not proven to belong/);
+
+  const cleanRunner = async (_command, args) => {
+    const kind = args[0] === "ps" ? "container" : args[0] === "volume" ? "volume" : "network";
+    return { code: 0, stdout: `${kind}-1`, stderr: "" };
+  };
+  assert.deepEqual(await dockerResources(config, owner, cleanRunner), {
+    containers: ["container-1"],
+    volumes: ["volume-1"],
+    networks: ["network-1"]
+  });
+});
+
+test("supervisor identity rejects PID reuse and atomically claims a checkout", async () => {
+  const root = await mkdtemp(join(tmpdir(), "spaceapp-supervisor-test-"));
+  const config = {
+    rootHash: "0123456789",
+    pidFile: join(root, "supervisor.pid")
+  };
+  const ownedIdentity = async () => ({ startedAt: "Sun Oct 18 07:40:00 2026", args: "node deploy/docker/dev-stack.mjs" });
+  try {
+    const record = await claimSupervisor(config, ownedIdentity);
+    assert.equal(record.pid, process.pid);
+    assert.equal(JSON.parse(await readFile(config.pidFile, "utf8")).rootHash, config.rootHash);
+    assert.equal(supervisorRecordMatches(config, record, await ownedIdentity()), true);
+    await assert.rejects(() => claimSupervisor(config, ownedIdentity), /already running/);
+
+    const reusedIdentity = async () => ({ startedAt: "Sun Oct 18 07:41:00 2026", args: "node unrelated-tool.mjs" });
+    await assert.rejects(() => ownedSupervisorPid(config, { identityProvider: reusedIdentity }), /Refusing to signal PID/);
+
+    await releaseSupervisor(config, process.pid);
+    await writeFile(config.pidFile, `${process.pid}\n`, { mode: 0o600 });
+    await assert.rejects(() => claimSupervisor(config, ownedIdentity), /stale or unverified/);
+  } finally {
+    await releaseSupervisor(config, process.pid).catch(() => {});
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test("persisted process-group ownership cleans descendants after the leader exits", { skip: process.platform === "win32" }, async () => {
+  const root = await mkdtemp(join(tmpdir(), "spaceapp-process-owner-"));
+  const config = {
+    rootHash: "abcdef0123",
+    processFile: join(root, "process-groups.json")
+  };
+  const owner = ownership(config.rootHash);
+  const childPidFile = join(root, "child.pid");
+  const childScript = "setInterval(() => {}, 1000)";
+  const leaderScript = `
+    const { spawn } = require("node:child_process");
+    const fs = require("node:fs");
+    const child = spawn(process.execPath, ["-e", ${JSON.stringify(childScript)}], { stdio: "ignore", env: process.env });
+    fs.writeFileSync(${JSON.stringify(childPidFile)}, String(child.pid));
+    setTimeout(() => process.exit(0), 50);
+  `;
+  const leader = spawn(process.execPath, ["-e", leaderScript], {
+    detached: true,
+    stdio: "ignore",
+    env: { ...process.env, SPACE_DEV_PROCESS_TOKEN: owner.token }
+  });
+  leader.unref();
+  const record = { name: "orphan-probe", pid: leader.pid, pgid: leader.pid, sid: leader.pid };
+  try {
+    await writeProcessRecords(config, owner, [record]);
+    const deadline = Date.now() + 3000;
+    while (Date.now() < deadline) {
+      if (existsSync(childPidFile)) {
+        const leaderStatus = await run("ps", ["-p", String(leader.pid), "-o", "stat="], { capture: true, allowFailure: true });
+        if (leaderStatus.code !== 0 || leaderStatus.stdout.startsWith("Z")) break;
+      }
+      await sleep(50);
+    }
+    assert.equal(existsSync(childPidFile), true);
+    const childPid = Number(await readFile(childPidFile, "utf8"));
+    assert.ok(Number.isInteger(childPid) && childPid > 1);
+
+    await terminateOwnedProcessGroups(config, owner, { timeoutMs: 1500 });
+    const groupStatus = await run("ps", ["-axo", "pid=,pgid=,stat="], { capture: true });
+    assert.equal(groupStatus.code, 0);
+    const liveMembers = groupStatus.stdout.split(/\r?\n/).filter((line) => {
+      const match = line.trim().match(/^(\d+)\s+(\d+)\s+(\S+)/);
+      return match && Number(match[2]) === record.pgid && !match[3].startsWith("Z");
+    });
+    assert.deepEqual(liveMembers, []);
+    assert.equal(existsSync(config.processFile), false);
+  } finally {
+    try { process.kill(-leader.pid, "SIGKILL"); } catch {}
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test("registered renamed children clean sanitized descendants without relaxing persisted recovery", { skip: process.platform === "win32" }, async () => {
+  const root = await mkdtemp(join(tmpdir(), "spaceapp-sanitized-descendant-"));
+  const config = { rootHash: "abcdef0123", processFile: join(root, "process-groups.json") };
+  const owner = ownership(config.rootHash);
+  const readyFile = join(root, "descendant.json");
+  const descendantScript = `
+    process.on("SIGTERM", () => {});
+    require("node:fs").writeFileSync(${JSON.stringify(readyFile)}, JSON.stringify({ pid: process.pid, token: process.env.SPACE_DEV_PROCESS_TOKEN }));
+    setInterval(() => {}, 1000);
+  `;
+  const leader = spawnOwnedProcess(owner, process.execPath, ["-e", `
+    process.title = "npm exec tsx watch";
+    require("node:child_process").spawn(process.execPath, ["-e", ${JSON.stringify(descendantScript)}], { stdio: "ignore", env: {} });
+    setInterval(() => {}, 1000);
+  `], { stdio: "ignore" });
+  const unrelated = spawn(process.execPath, ["-e", "setInterval(() => {}, 1000)"], { detached: true, stdio: "ignore" });
+  const record = { name: "sanitized-probe", pid: leader.pid, pgid: leader.pid, sid: leader.pid };
+  const runner = (command, args, options) => args[0] === "eww" && Number(args[args.indexOf("-p") + 1]) === leader.pid
+    ? Promise.resolve({ code: 0, stdout: "npm exec tsx watch", stderr: "" })
+    : run(command, args, options);
+  try {
+    await writeProcessRecords(config, owner, [record]);
+    const deadline = Date.now() + 3000;
+    while (!existsSync(readyFile) && Date.now() < deadline) await sleep(20);
+    const descendant = JSON.parse(await readFile(readyFile, "utf8"));
+    assert.equal(descendant.token, undefined);
+    assert.equal(leader.exitCode, null);
+
+    await assert.rejects(() => terminateOwnedProcessGroups(config, owner, { runner }), /does not carry this dev-stack ownership token/);
+    await assert.rejects(() => terminateOwnedProcessGroups(config, owner, { liveChildren: [leader], runner }), /does not carry this dev-stack ownership token/);
+    await assert.rejects(() => terminateOwnedProcessGroups(config, owner, { records: [record], runner }), /does not carry this dev-stack ownership token/);
+    assert.equal(existsSync(config.processFile), true);
+
+    await terminateOwnedProcessGroups(config, owner, { records: [record], liveChildren: [leader], runner, timeoutMs: 100 });
+    const status = await run("ps", ["-p", String(descendant.pid), "-o", "stat="], { capture: true, allowFailure: true });
+    assert.ok(status.code !== 0 || status.stdout.startsWith("Z"));
+    assert.notEqual(leader.signalCode, null);
+    assert.doesNotThrow(() => process.kill(unrelated.pid, 0), "an unrelated process must remain alive");
+  } finally {
+    try { process.kill(-leader.pid, "SIGKILL"); } catch {}
+    try { process.kill(-unrelated.pid, "SIGKILL"); } catch {}
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test("spawn registration rejects spoofed handles, other tokens, reused identities, and exit races", { skip: process.platform === "win32" }, async (t) => {
+  const config = { rootHash: "abcdef0123" };
+  const owner = ownership(config.rootHash);
+  const startedAt = "Sun Oct 18 07:40:00 2026";
+  for (const scenario of ["spoofed handle", "other token", "reused identity", "exit during snapshot"]) await t.test(scenario, async () => {
+    const leader = spawnOwnedProcess(owner, process.execPath, ["-e", "setInterval(() => {}, 1000)"], { stdio: "ignore" });
+    const record = { name: "registered-probe", pid: leader.pid, pgid: leader.pid, sid: leader.pid };
+    const signals = [];
+    let inventories = 0;
+    try {
+      const runner = async (_command, args) => {
+        if (args[0] !== "-axo") return { code: 0, stdout: "npm", stderr: "" };
+        inventories += 1;
+        if (scenario === "exit during snapshot" && inventories === 1) {
+          const exited = new Promise(resolvePromise => leader.once("exit", resolvePromise));
+          leader.kill("SIGTERM");
+          await exited;
+        }
+        const identity = scenario === "reused identity" && inventories > 1 ? "Sun Oct 18 07:41:00 2026" : startedAt;
+        return { code: 0, stdout: `${leader.pid} ${leader.pid} S ${identity}\n`, stderr: "" };
+      };
+      const child = scenario === "spoofed handle" ? { pid: leader.pid, exitCode: null, signalCode: null } : leader;
+      const candidateOwner = scenario === "other token" ? { ...owner, token: "b".repeat(48) } : owner;
+      await assert.rejects(() => terminateOwnedProcessGroups(config, candidateOwner, {
+        records: [record], liveChildren: [child], runner, timeoutMs: 0,
+        signaler: (...args) => signals.push(args)
+      }), /does not carry this dev-stack ownership token/);
+      assert.deepEqual(signals, []);
+    } finally {
+      try { process.kill(-leader.pid, "SIGKILL"); } catch {}
+    }
+  });
+});
+
+test("live group snapshots fail closed on stale leaders and changed process identities", { skip: process.platform === "win32" }, async (t) => {
+  const config = { rootHash: "abcdef0123" };
+  const owner = ownership(config.rootHash);
+  const record = { name: "identity-probe", pid: 4100, pgid: 4100, sid: 4100 };
+  const startedAt = "Sun Oct 18 07:40:00 2026";
+
+  for (const scenario of ["exited leader", "different child", "leader exits during snapshot", "missing leader", "wrong leader token", "reused descendant", "new unverified descendant", "missing start identity"]) {
+    await t.test(scenario, async () => {
+      const child = { pid: scenario === "different child" ? 4200 : record.pid, exitCode: scenario === "exited leader" ? 0 : null, signalCode: null };
+      const signals = [];
+      let terminated = false;
+      const runner = async (_command, args) => {
+        if (args[0] === "-axo") {
+          const leader = scenario === "missing leader" || terminated ? "" : `4100 4100 S ${startedAt}\n`;
+          const childStart = terminated && scenario === "reused descendant" ? "Sun Oct 18 07:41:00 2026" : startedAt;
+          const descendant = `4101 4100 S${scenario === "missing start identity" ? "" : ` ${childStart}`}\n`;
+          const newcomer = terminated && scenario === "new unverified descendant" ? `4102 4100 S ${startedAt}\n` : "";
+          return { code: 0, stdout: leader + descendant + newcomer, stderr: "" };
+        }
+        const pid = Number(args[args.indexOf("-p") + 1]);
+        if (pid === record.pid) {
+          if (scenario === "leader exits during snapshot") child.signalCode = "SIGTERM";
+          return { code: 0, stdout: scenario === "wrong leader token" ? "node unrelated" : `node SPACE_DEV_PROCESS_TOKEN=${owner.token}`, stderr: "" };
+        }
+        return { code: 0, stdout: "node sanitized-child", stderr: "" };
+      };
+      await assert.rejects(() => terminateOwnedProcessGroups(config, owner, {
+        records: [record], liveChildren: [child], runner, timeoutMs: 0,
+        signaler: (pid, signal) => { signals.push([pid, signal]); terminated = true; child.signalCode = signal; }
+      }), /does not carry this dev-stack ownership token|Could not establish start identity/);
+      const expected = ["reused descendant", "new unverified descendant"].includes(scenario) ? [[-record.pgid, "SIGTERM"]] : [];
+      assert.deepEqual(signals, expected);
+    });
+  }
+});
+
+test("process-group cleanup does not depend on Darwin sess values", async (t) => {
+  for (const sess of ["0", "ffffffff8100abcd"]) {
+    await t.test(`sess=${sess}`, async () => {
+      const root = await mkdtemp(join(tmpdir(), "spaceapp-darwin-group-"));
+      const config = { rootHash: "abcdef0123", processFile: join(root, "process-groups.json") };
+      const owner = ownership(config.rootHash);
+      const record = { name: "darwin-probe", pid: 4100, pgid: 4100, sid: 4100 };
+      const signals = [];
+      let stopped = false;
+      try {
+        await writeProcessRecords(config, owner, [record]);
+        const runner = async (_command, args) => {
+          if (args[0] !== "-axo") return { code: 0, stdout: `node SPACE_DEV_PROCESS_TOKEN=${owner.token}`, stderr: "" };
+          const fields = args[1].split(",").map((field) => field.replace(/=$/, ""));
+          const rows = stopped ? [] : [4100, 4101].map((pid) => ({ pid, pgid: 4100, sess, stat: "S", lstart: "Sun Oct 18 07:40:00 2026" }));
+          return { code: 0, stdout: rows.map((row) => fields.map((field) => row[field]).join(" ")).join("\n"), stderr: "" };
+        };
+        await terminateOwnedProcessGroups(config, owner, {
+          runner, timeoutMs: 0,
+          signaler: (pid, signal) => { signals.push([pid, signal]); stopped = true; }
+        });
+        assert.deepEqual(signals, process.platform === "win32" ? [[4100, "SIGTERM"], [4101, "SIGTERM"]] : [[-4100, "SIGTERM"]]);
+        assert.equal(existsSync(config.processFile), false);
+      } finally {
+        await rm(root, { recursive: true, force: true });
+      }
+    });
+  }
+});
+
+test("malformed process inventory preserves recovery records without signalling", async (t) => {
+  for (const stdout of ["unparseable process", "4100 4100 0 S Sun Oct 18 07:40:00 2026", "4100 4100 broken-sess S Sun Oct 18 07:40:00 2026", "4100 4100 S"]) {
+    await t.test(stdout, async () => {
+      const root = await mkdtemp(join(tmpdir(), "spaceapp-malformed-group-"));
+      const config = { rootHash: "abcdef0123", processFile: join(root, "process-groups.json") };
+      const owner = ownership(config.rootHash);
+      const record = { name: "malformed-probe", pid: 4100, pgid: 4100, sid: 4100 };
+      const signals = [];
+      try {
+        await writeProcessRecords(config, owner, [record]);
+        await assert.rejects(() => terminateOwnedProcessGroups(config, owner, {
+          runner: async () => ({ code: 0, stdout, stderr: "" }),
+          signaler: (...args) => signals.push(args)
+        }), /Could not parse local process inventory|Could not establish start identity/);
+        assert.deepEqual(signals, []);
+        assert.equal(existsSync(config.processFile), true);
+      } finally {
+        await rm(root, { recursive: true, force: true });
+      }
+    });
+  }
+});
+
+test("macOS source stack repairs node-pty spawn-helper execute permissions", async () => {
+  const root = await mkdtemp(join(tmpdir(), "spaceapp-pty-helper-"));
+  const helper = join(root, "node_modules", "node-pty", "prebuilds", "darwin-x64", "spawn-helper");
+  try {
+    await mkdir(join(root, "node_modules", "node-pty", "prebuilds", "darwin-x64"), { recursive: true });
+    await writeFile(helper, "#!/bin/sh\nexit 0\n", { mode: 0o644 });
+    await chmod(helper, 0o644);
+
+    const repaired = await ensureDarwinNodePtySpawnHelpers(root, "darwin");
+    assert.deepEqual(repaired, [helper]);
+    assert.equal((await stat(helper)).mode & 0o111, 0o111);
+    assert.deepEqual(await ensureDarwinNodePtySpawnHelpers(root, "darwin"), []);
+
+    await chmod(helper, 0o644);
+    assert.deepEqual(await ensureDarwinNodePtySpawnHelpers(root, "linux"), []);
+    assert.equal((await stat(helper)).mode & 0o111, 0);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
diff --git a/package.json b/package.json
index b488fbbcb..df26ec4bc 100644
--- a/package.json
+++ b/package.json
@@ -46,6 +46,9 @@
     "dev:api": "npm run dev -w @space/api",
     "dev:web": "npm run dev -w @space/web",
     "dev:worker": "npm run dev -w @space/worker",
+    "dev:stack": "node deploy/docker/dev-stack.mjs",
+    "verify:dev-stack": "node deploy/docker/dev-stack-verify.mjs",
+    "test:dev-stack": "node --test deploy/docker/dev-stack.test.mjs deploy/docker/dev-stack-probes.test.mjs",
     "db:migrate": "npm run migrate -w @space/db",
     "build": "npm run build -w @space/contracts && npm run build -w @space/icons && npm run build -w @space/streaming && npm run build -w @space/opencode-control && npm run build -w @space/memory-graph && npm run build -w @space/browser-host && npm run build -w @space/cli-host && npm run build -w @space/codex-app-server && npm run build -w @space/runtime && npm run build -w @space/db && npm run build -w @space/gateway && node scripts/build-demo-projects.mjs && npm run build -w @space/api && npm run build -w @space/worker && npm run build -w @space/web && node scripts/fix-build-permissions.mjs",
     "public:export:verify": "node scripts/public-export.mjs --verify",
diff --git a/packages/runtime/src/shared-state.ts b/packages/runtime/src/shared-state.ts
index 2b195634c..faf9fd6af 100644
--- a/packages/runtime/src/shared-state.ts
+++ b/packages/runtime/src/shared-state.ts
@@ -16,7 +16,7 @@ import {
   type UpdateCodexGoalTaskInput
 } from "@space/contracts";
 import { createCanonicalMemoryReader, type CanonicalMemoryReaderOptions } from "./canonical-memory-reader.js";
-import { monthOfMemoryFile, spaceMemoryIndexPath, spaceMemoryMonthlyPath } from "./space-memory-files.js";
+import { monthOfMemoryFile, spaceMemoryDirectory, spaceMemoryIndexPath, spaceMemoryMonthlyPath } from "./space-memory-files.js";
 import { nowIso, redactMemoryText } from "./store.js";
 
 const execFileAsync = promisify(execFile);
@@ -53,7 +53,7 @@ function athensMonthFor(date: Date): string {
 }
 
 export function defaultCanonicalSpaceMemoryPaths(date = new Date()): CanonicalSpaceMemoryPaths {
-  return resolveCanonicalSpaceMemoryPaths({}, date);
+  return resolveCanonicalSpaceMemoryPaths(process.env, date);
 }
 
 /**
@@ -66,10 +66,11 @@ export function resolveCanonicalSpaceMemoryPaths(
   env: Record<string, string | undefined>,
   date = new Date()
 ): Required<CanonicalSpaceMemoryPaths> {
+  const memoryDirectory = spaceMemoryDirectory(env);
   const monthlyPath = env.SPACE_MEMORY_MONTHLY_PATH || env.SPACE_GEMINI_MEMORY_MONTHLY_PATH ||
-    spaceMemoryMonthlyPath(athensMonthFor(date));
+    spaceMemoryMonthlyPath(athensMonthFor(date), memoryDirectory);
   return {
-    indexPath: env.SPACE_MEMORY_INDEX_PATH || env.SPACE_GEMINI_MEMORY_INDEX_PATH || spaceMemoryIndexPath(),
+    indexPath: env.SPACE_MEMORY_INDEX_PATH || env.SPACE_GEMINI_MEMORY_INDEX_PATH || spaceMemoryIndexPath(memoryDirectory),
     monthlyPath,
     lockPath: env.SPACE_MEMORY_LOCK_PATH || env.SPACE_GEMINI_MEMORY_LOCK_PATH || `${monthlyPath}.lock`
   };
diff --git a/packages/runtime/src/space-memory-files.ts b/packages/runtime/src/space-memory-files.ts
index 93669cd2a..4b0a169d6 100644
--- a/packages/runtime/src/space-memory-files.ts
+++ b/packages/runtime/src/space-memory-files.ts
@@ -19,6 +19,11 @@ export const MEMORY_CORE_FILE_PATTERN = /^(?:space|gemini)\.md$/;
 /** Core and domain reference files that recall searches beside the monthly files. */
 export const MEMORY_REFERENCE_FILE_PATTERN = /^(?:space|gemini|(?:space|gemini)_core(?:_[a-z_]+)?|agent_task_policies)\.md$/;
 
+/** Resolve the canonical memory directory for this process (source stacks set SPACE_MEMORY_ROOT). */
+export function spaceMemoryDirectory(env: Record<string, string | undefined> = process.env): string {
+  return env.SPACE_MEMORY_ROOT || SPACE_MEMORY_DIRECTORY;
+}
+
 export const isMonthlyMemoryFile = (name: string) => MONTHLY_MEMORY_FILE_PATTERN.test(name);
 export const isMemoryIndexFile = (name: string) => MEMORY_INDEX_FILE_PATTERN.test(name);
 export const isMemoryCoreFile = (name: string) => MEMORY_CORE_FILE_PATTERN.test(name);
@@ -29,19 +34,19 @@ export function monthOfMemoryFile(path: string): string | null {
 }
 
 /** True until the index has been renamed to space_memory.md. */
-export function usesLegacyMemoryFiles(directory = SPACE_MEMORY_DIRECTORY): boolean {
+export function usesLegacyMemoryFiles(directory = spaceMemoryDirectory()): boolean {
   return !existsSync(join(directory, SPACE_MEMORY_INDEX_FILENAME));
 }
 
 /** The agent core rules file: space.md once renamed, gemini.md until then. */
-export function spaceAgentCorePath(directory = SPACE_MEMORY_DIRECTORY): string {
+export function spaceAgentCorePath(directory = spaceMemoryDirectory()): string {
   return join(directory, existsSync(join(directory, "space.md")) ? "space.md" : "gemini.md");
 }
 
-export function spaceMemoryIndexPath(directory = SPACE_MEMORY_DIRECTORY): string {
+export function spaceMemoryIndexPath(directory = spaceMemoryDirectory()): string {
   return join(directory, usesLegacyMemoryFiles(directory) ? LEGACY_MEMORY_INDEX_FILENAME : SPACE_MEMORY_INDEX_FILENAME);
 }
 
-export function spaceMemoryMonthlyPath(month: string, directory = SPACE_MEMORY_DIRECTORY): string {
+export function spaceMemoryMonthlyPath(month: string, directory = spaceMemoryDirectory()): string {
   return join(directory, `${usesLegacyMemoryFiles(directory) ? "gemini_history" : "space_memory"}_${month}.md`);
 }
diff --git a/packages/runtime/tests/shared-state.test.ts b/packages/runtime/tests/shared-state.test.ts
index 4574afbdc..1b6d9781f 100644
--- a/packages/runtime/tests/shared-state.test.ts
+++ b/packages/runtime/tests/shared-state.test.ts
@@ -2,13 +2,13 @@ import { mkdtemp, readFile, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { describe, expect, it } from "vitest";
-import { createCanonicalSpaceMemoryBridge, resolveCanonicalSpaceMemoryPaths } from "../src/shared-state.js";
-import { usesLegacyMemoryFiles } from "../src/space-memory-files.js";
+import { createCanonicalSpaceMemoryBridge, defaultCanonicalSpaceMemoryPaths, resolveCanonicalSpaceMemoryPaths } from "../src/shared-state.js";
+import { SPACE_MEMORY_DIRECTORY, usesLegacyMemoryFiles } from "../src/space-memory-files.js";
 
 describe("canonical Space Memory paths", () => {
   it("uses the Athens calendar month and one shared default lock", () => {
     const paths = resolveCanonicalSpaceMemoryPaths({}, new Date("2026-06-30T22:30:00.000Z"));
-    const name = usesLegacyMemoryFiles() ? "gemini_history" : "space_memory";
+    const name = usesLegacyMemoryFiles(SPACE_MEMORY_DIRECTORY) ? "gemini_history" : "space_memory";
 
     expect(paths).toEqual({
       indexPath: `/opt/spaceapp/docs/${name}.md`,
@@ -29,6 +29,31 @@ describe("canonical Space Memory paths", () => {
     });
   });
 
+  it("keeps source-stack canonical reads and writes under SPACE_MEMORY_ROOT", () => {
+    const root = "/tmp/owned-source-stack/memory";
+    const paths = resolveCanonicalSpaceMemoryPaths({ SPACE_MEMORY_ROOT: root }, new Date("2026-06-30T22:30:00.000Z"));
+    expect(paths).toEqual({
+      indexPath: `${root}/gemini_history.md`,
+      monthlyPath: `${root}/gemini_history_2026-07.md`,
+      lockPath: `${root}/gemini_history_2026-07.md.lock`
+    });
+  });
+
+  it("uses the process root for default canonical paths", () => {
+    const previousRoot = process.env.SPACE_MEMORY_ROOT;
+    process.env.SPACE_MEMORY_ROOT = "/tmp/owned-process-memory";
+    try {
+      expect(defaultCanonicalSpaceMemoryPaths(new Date("2026-06-30T22:30:00.000Z"))).toEqual({
+        indexPath: "/tmp/owned-process-memory/gemini_history.md",
+        monthlyPath: "/tmp/owned-process-memory/gemini_history_2026-07.md",
+        lockPath: "/tmp/owned-process-memory/gemini_history_2026-07.md.lock"
+      });
+    } finally {
+      if (previousRoot === undefined) delete process.env.SPACE_MEMORY_ROOT;
+      else process.env.SPACE_MEMORY_ROOT = previousRoot;
+    }
+  });
+
   it("writes a stable marker that matches the returned canonical memory id", async () => {
     const rootDir = await mkdtemp(join(tmpdir(), "space-canonical-memory-"));
     const monthlyPath = join(rootDir, "gemini_history_2026-07.md");
diff --git a/packages/runtime/tests/space-memory-files.test.ts b/packages/runtime/tests/space-memory-files.test.ts
index 422e2161b..2b0ead93d 100644
--- a/packages/runtime/tests/space-memory-files.test.ts
+++ b/packages/runtime/tests/space-memory-files.test.ts
@@ -8,6 +8,7 @@ import {
   isMonthlyMemoryFile,
   monthOfMemoryFile,
   spaceAgentCorePath,
+  spaceMemoryDirectory,
   spaceMemoryIndexPath,
   spaceMemoryMonthlyPath,
   usesLegacyMemoryFiles
@@ -23,6 +24,22 @@ async function directory() {
 const query = { page: 1, pageSize: 25, sortOrder: "desc" as const, searchMode: "keyword" as const };
 
 describe("Space Memory files", () => {
+  it("resolves process helpers from an owned Space Memory root", async () => {
+    const root = await directory();
+    const previousRoot = process.env.SPACE_MEMORY_ROOT;
+    await writeFile(join(root, "gemini_history.md"), "# History\n");
+    await writeFile(join(root, "gemini.md"), "# Core\n");
+    process.env.SPACE_MEMORY_ROOT = root;
+    try {
+      expect(spaceMemoryDirectory()).toBe(root);
+      expect(spaceMemoryIndexPath()).toBe(join(root, "gemini_history.md"));
+      expect(spaceAgentCorePath()).toBe(join(root, "gemini.md"));
+    } finally {
+      if (previousRoot === undefined) delete process.env.SPACE_MEMORY_ROOT;
+      else process.env.SPACE_MEMORY_ROOT = previousRoot;
+    }
+  });
+
   it("keeps the legacy gemini_history files until the index is renamed", async () => {
     const root = await directory();
     await writeFile(join(root, "gemini_history.md"), "# History\n");