archctx 0.1.0 → 0.1.2

package/bin/archctx.mjs

@@ -1,4 +1,4 @@
-#!/usr/bin/env bun
+#!/usr/bin/env node
 // @bun
 import { createRequire } from "node:module";
 var __defProp = Object.defineProperty;
@@ -667,7 +667,7 @@ function productVersionManifest() {
     }
   };
 }
-var ARCHCONTEXT_PRODUCT_NAME = "archctx", ARCHCONTEXT_PRODUCT_VERSION = "0.1.0", ARCHCONTEXT_PACKAGE_MANAGER = "bun@1.3.10", ARCHCONTEXT_NODE_RANGE = ">=24 <26", LOCAL_RUNTIME_RPC_SCHEMA_VERSION = "archcontext.runtime-rpc/v1", ARCHCONTEXT_SCHEMA_SET_VERSION = "2026-06-20.fg1";
+var ARCHCONTEXT_PRODUCT_NAME = "archctx", ARCHCONTEXT_PRODUCT_VERSION = "0.1.2", ARCHCONTEXT_PACKAGE_MANAGER = "bun@1.3.10", ARCHCONTEXT_NODE_RANGE = ">=24 <26", LOCAL_RUNTIME_RPC_SCHEMA_VERSION = "archcontext.runtime-rpc/v1", ARCHCONTEXT_SCHEMA_SET_VERSION = "2026-06-20.fg1";
 // packages/contracts/src/index.ts
 var init_src = __esm(() => {
   init_control_plane_routes();
@@ -1288,7 +1288,7 @@ __export(exports_src, {
   DevicePrivateKeyStore: () => DevicePrivateKeyStore
 });
 import {
-  createHash as createHash5,
+  createHash as createHash7,
   createPrivateKey,
   generateKeyPairSync,
   randomBytes as randomBytes3,
@@ -1296,7 +1296,7 @@ import {
 } from "node:crypto";
 function createPkceAuthorizationRequest(input) {
   const codeVerifier = input.verifier ?? randomBytes3(32).toString("base64url");
-  const codeChallenge = createHash5("sha256").update(codeVerifier).digest("base64url");
+  const codeChallenge = createHash7("sha256").update(codeVerifier).digest("base64url");
   const url = new URL("/oauth/authorize", input.issuer);
   url.searchParams.set("response_type", "code");
   url.searchParams.set("client_id", input.clientId);
@@ -4262,12 +4262,12 @@ __export(exports_src3, {
   assertLocalAttestationV1: () => assertLocalAttestationV1,
   assertAttestationV2: () => assertAttestationV22
 });
-import { createHash as createHash6, sign as sign3, verify as verify2 } from "node:crypto";
+import { createHash as createHash8, sign as sign3, verify as verify2 } from "node:crypto";
 function publicKeyFingerprint2(publicKey) {
   if (publicKey.type !== "public")
     throw new Error("public-key-required");
   const der = publicKey.export({ format: "der", type: "spki" });
-  return `sha256:${createHash6("sha256").update(der).digest("hex")}`;
+  return `sha256:${createHash8("sha256").update(der).digest("hex")}`;
 }
 function createReviewChallenge(input) {
   const nonce = digestJson({ repo: input.repository, headSha: input.headSha, expiresAt: input.expiresAt });
@@ -4708,7 +4708,7 @@ function deviceIntegritySignals2(input) {
 function signAttestation(input) {
   const unsigned = unsignedPayload2({
     schemaVersion: "archcontext.attestation/v1",
-    attestationId: `att_${createHash6("sha256").update(input.challenge.challengeId + input.reviewDigest + input.trustLevel).digest("hex").slice(0, 16)}`,
+    attestationId: `att_${createHash8("sha256").update(input.challenge.challengeId + input.reviewDigest + input.trustLevel).digest("hex").slice(0, 16)}`,
     challengeId: input.challenge.challengeId,
     repository: input.challenge.repository,
     headSha: input.challenge.headSha,
@@ -5109,7 +5109,7 @@ var init_src7 = __esm(() => {
 
 // packages/surfaces/cli/src/main.ts
 import { spawn } from "child_process";
-import { accessSync, chmodSync as chmodSync3, closeSync as closeSync6, constants, existsSync as existsSync10, mkdirSync as mkdirSync8, openSync as openSync6, readFileSync as readFileSync9, rmSync as rmSync8, statSync as statSync6, writeFileSync as writeFileSync5 } from "fs";
+import { accessSync, chmodSync as chmodSync5, closeSync as closeSync7, constants, existsSync as existsSync11, mkdirSync as mkdirSync9, openSync as openSync7, readFileSync as readFileSync11, rmSync as rmSync9, statSync as statSync6, writeFileSync as writeFileSync7 } from "fs";
 import { dirname as dirname9, join as join8, resolve as resolve14 } from "path";
 import { fileURLToPath } from "url";
 
@@ -5134,6 +5134,18 @@ var DEFAULT_IGNORES = new Set([
   ".archcontext/.local",
   ".DS_Store"
 ]);
+function repositoryFingerprint(root) {
+  const normalized = canonicalRepositoryRoot(root);
+  return `repo.${createHash2("sha256").update(normalized).digest("hex").slice(0, 16)}`;
+}
+function canonicalRepositoryRoot(root) {
+  const resolved = resolve(root);
+  try {
+    return realpathSync.native(resolved);
+  } catch {
+    return resolved;
+  }
+}
 function computeWorktreeDigest(root, options = {}) {
   const ignore = new Set([...DEFAULT_IGNORES, ...options.ignore ?? []]);
   const files = listRepoFiles(root, ignore);
@@ -5198,11 +5210,11 @@ var DEFAULT_IGNORES2 = new Set([
   ".archcontext/.local",
   ".DS_Store"
 ]);
-function repositoryFingerprint(root) {
-  const normalized = canonicalRepositoryRoot(root);
+function repositoryFingerprint2(root) {
+  const normalized = canonicalRepositoryRoot2(root);
   return `repo.${createHash3("sha256").update(normalized).digest("hex").slice(0, 16)}`;
 }
-function canonicalRepositoryRoot(root) {
+function canonicalRepositoryRoot2(root) {
   const resolved = resolve2(root);
   try {
     return realpathSync2.native(resolved);
@@ -5341,9 +5353,9 @@ function computeReviewWorktreeDigest(input) {
   });
 }
 function bindRepository(root, headSha) {
-  const canonicalRoot = canonicalRepositoryRoot(root);
+  const canonicalRoot = canonicalRepositoryRoot2(root);
   return {
-    repositoryId: repositoryFingerprint(canonicalRoot),
+    repositoryId: repositoryFingerprint2(canonicalRoot),
     root: canonicalRoot,
     headSha,
     worktreeDigest: computeWorktreeDigest2(canonicalRoot)
@@ -6524,18 +6536,621 @@ function listFiles(root) {
 }
 
 // packages/local-runtime/local-store-sqlite/src/index.ts
-import { dirname as dirname2, join as join2, resolve as resolve6 } from "node:path";
+import { execFileSync as execFileSync2 } from "node:child_process";
+import { createHash as createHash5, randomUUID } from "node:crypto";
+import { chmodSync, closeSync as closeSync3, existsSync as existsSync3, fsyncSync as fsyncSync2, lstatSync as lstatSync2, mkdirSync as mkdirSync2, openSync as openSync3, readFileSync as readFileSync5, realpathSync as realpathSync4, renameSync as renameSync2, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { createRequire as createRequire2 } from "node:module";
+import { homedir } from "node:os";
+import { dirname as dirname2, isAbsolute as isAbsolute3, join as join2, relative as relative4, resolve as resolve6 } from "node:path";
+var runtimeRequire = createRequire2(import.meta.url);
+var SQLITE_SIDECAR_SUFFIXES = ["", "-wal", "-shm"];
+var LEGACY_MIGRATION_MARKER_FILE = "runtime.sqlite.migration.json";
+var LEGACY_MIGRATION_LOCK_FILE = "runtime.sqlite.migration.lock";
+var REQUIRED_LOCAL_STORE_TABLES = [
+  "schema_migrations",
+  "repository_sessions",
+  "snapshots",
+  "task_states",
+  "observed_evidence",
+  "review_results",
+  "landscapes",
+  "cross_repo_edges",
+  "changeset_journal"
+];
+var SQLITE_PRAGMAS = [
+  "PRAGMA journal_mode = WAL",
+  "PRAGMA foreign_keys = ON",
+  "PRAGMA busy_timeout = 5000"
+];
+var LOCAL_SQLITE_MIGRATIONS = [
+  {
+    id: "0001_runtime_state",
+    statements: [
+      `CREATE TABLE IF NOT EXISTS schema_migrations (
+        id TEXT PRIMARY KEY,
+        applied_at TEXT NOT NULL
+      )`,
+      `CREATE TABLE IF NOT EXISTS repository_sessions (
+        repository_id TEXT PRIMARY KEY,
+        root TEXT NOT NULL,
+        head_sha TEXT NOT NULL,
+        worktree_digest TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      )`,
+      `CREATE TABLE IF NOT EXISTS snapshots (
+        id TEXT PRIMARY KEY,
+        repository_id TEXT NOT NULL,
+        head_sha TEXT NOT NULL,
+        worktree_digest TEXT NOT NULL,
+        state TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        committed_at TEXT
+      )`,
+      `CREATE TABLE IF NOT EXISTS task_states (
+        task_session_id TEXT PRIMARY KEY,
+        payload_json TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      )`,
+      `CREATE TABLE IF NOT EXISTS observed_evidence (
+        id TEXT PRIMARY KEY,
+        repository_id TEXT NOT NULL,
+        head_sha TEXT NOT NULL,
+        selector_json TEXT NOT NULL,
+        summary TEXT NOT NULL,
+        confidence TEXT NOT NULL,
+        created_at TEXT NOT NULL
+      )`,
+      `CREATE TABLE IF NOT EXISTS review_results (
+        review_id TEXT PRIMARY KEY,
+        task_session_id TEXT NOT NULL,
+        payload_json TEXT NOT NULL,
+        created_at TEXT NOT NULL
+      )`
+    ]
+  },
+  {
+    id: "0002_indexes",
+    statements: [
+      "CREATE INDEX IF NOT EXISTS idx_snapshots_repository ON snapshots(repository_id, head_sha)",
+      "CREATE INDEX IF NOT EXISTS idx_evidence_repository ON observed_evidence(repository_id, head_sha)",
+      "CREATE INDEX IF NOT EXISTS idx_reviews_task ON review_results(task_session_id)"
+    ]
+  },
+  {
+    id: "0003_landscape_state",
+    statements: [
+      `CREATE TABLE IF NOT EXISTS landscapes (
+        id TEXT PRIMARY KEY,
+        digest TEXT NOT NULL,
+        metadata_json TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      )`,
+      `CREATE TABLE IF NOT EXISTS cross_repo_edges (
+        id TEXT PRIMARY KEY,
+        landscape_id TEXT NOT NULL,
+        from_repository_id TEXT NOT NULL,
+        from_node_id TEXT NOT NULL,
+        to_repository_id TEXT NOT NULL,
+        to_node_id TEXT NOT NULL,
+        via_kind TEXT NOT NULL,
+        via_id TEXT NOT NULL,
+        metadata_json TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      )`,
+      "CREATE INDEX IF NOT EXISTS idx_cross_repo_edges_from ON cross_repo_edges(from_repository_id, from_node_id)",
+      "CREATE INDEX IF NOT EXISTS idx_cross_repo_edges_to ON cross_repo_edges(to_repository_id, to_node_id)"
+    ]
+  },
+  {
+    id: "0004_changeset_journal",
+    statements: [
+      `CREATE TABLE IF NOT EXISTS changeset_journal (
+        journal_id TEXT PRIMARY KEY,
+        changeset_id TEXT NOT NULL,
+        root TEXT NOT NULL,
+        status TEXT NOT NULL,
+        metadata_json TEXT NOT NULL,
+        files_json TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        completed_at TEXT
+      )`,
+      "CREATE INDEX IF NOT EXISTS idx_changeset_journal_status ON changeset_journal(status)"
+    ]
+  }
+];
+var ARCHCONTEXT_STATE_DIR_ENV = "ARCHCONTEXT_STATE_DIR";
+var ARCHCONTEXT_LOCAL_STORE_PATH_ENV = "ARCHCONTEXT_LOCAL_STORE_PATH";
+function defaultArchContextStateRoot(env = process.env, platform = process.platform, home = homedir()) {
+  const override = env[ARCHCONTEXT_STATE_DIR_ENV];
+  if (override)
+    return { path: resolve6(override), source: "environment" };
+  if (platform === "darwin")
+    return { path: join2(home, "Library", "Application Support", "ArchContext"), source: "os-user-data" };
+  if (platform === "win32")
+    return { path: join2(env.LOCALAPPDATA ?? join2(home, "AppData", "Local"), "ArchContext"), source: "os-user-data" };
+  return { path: join2(env.XDG_DATA_HOME ?? join2(home, ".local", "share"), "archcontext"), source: "os-user-data" };
+}
+function runtimeStatePaths(root = process.cwd(), env = process.env) {
+  const repositoryRoot = readGitPath(root, ["rev-parse", "--show-toplevel"]) ?? root;
+  const canonicalRepositoryRoot3 = canonicalPath(repositoryRoot);
+  const gitCommonDir = readGitPath(canonicalRepositoryRoot3, ["rev-parse", "--git-common-dir"]);
+  const repositoryAnchor = canonicalPath(gitCommonDir ? resolveMaybeRelative(canonicalRepositoryRoot3, gitCommonDir) : canonicalRepositoryRoot3);
+  const workspaceAnchor = canonicalRepositoryRoot3;
+  const storageRepositoryId = stableStorageId("repo", repositoryAnchor);
+  const storageWorkspaceId = stableStorageId("ws", workspaceAnchor);
+  const stateRoot = defaultArchContextStateRoot(env);
+  const repositoryStateDir = join2(stateRoot.path, "repositories", storageRepositoryId);
+  const workspaceStateDir = join2(repositoryStateDir, "worktrees", storageWorkspaceId);
+  const legacyControlDir = resolve6(canonicalRepositoryRoot3, ".archcontext", ".local");
+  return {
+    schemaVersion: "archcontext.runtime-state-paths/v1",
+    stateRoot: stateRoot.path,
+    source: stateRoot.source,
+    repositoryRoot: canonicalRepositoryRoot3,
+    repositoryAnchor,
+    workspaceAnchor,
+    storageRepositoryId,
+    storageWorkspaceId,
+    repositoryId: storageRepositoryId,
+    workspaceId: storageWorkspaceId,
+    repositoryStateDir,
+    workspaceStateDir,
+    sharedCacheDir: join2(repositoryStateDir, "shared", "cache"),
+    localStorePath: env[ARCHCONTEXT_LOCAL_STORE_PATH_ENV] ?? join2(workspaceStateDir, "runtime.sqlite"),
+    daemonConnectionPath: join2(workspaceStateDir, "archctxd.json"),
+    daemonLockPath: join2(workspaceStateDir, "archctxd.lock"),
+    daemonLogPath: join2(workspaceStateDir, "archctxd.log"),
+    developerReviewRunStateDir: join2(workspaceStateDir, "developer-review-runs"),
+    legacyControlDir,
+    legacyLocalStorePath: join2(legacyControlDir, "runtime.sqlite")
+  };
+}
 function defaultLocalStorePath(root = process.cwd()) {
-  return process.env.ARCHCONTEXT_LOCAL_STORE_PATH ?? resolve6(root, ".archcontext/.local/runtime.sqlite");
+  return runtimeStatePaths(root).localStorePath;
+}
+function inspectLegacyLocalStoreMigration(root = process.cwd(), env = process.env) {
+  const paths = runtimeStatePaths(root, env);
+  if (env[ARCHCONTEXT_LOCAL_STORE_PATH_ENV]) {
+    return legacyMigrationResult(false, "explicit-local-store-override", paths, [], {
+      status: "explicit-local-store-override"
+    });
+  }
+  const legacyExists = existsSync3(paths.legacyLocalStorePath);
+  const targetExists = existsSync3(paths.localStorePath);
+  if (targetExists) {
+    const target = safeCurrentLocalStoreCheck(paths.localStorePath);
+    return legacyMigrationResult(false, "target-exists", paths, [], {
+      status: target.ok ? "target-current" : "target-incomplete",
+      integrityCheck: target.ok ? { target: target.result } : { target: "failed", error: target.error }
+    });
+  }
+  if (!legacyExists) {
+    return legacyMigrationResult(false, "legacy-missing", paths, [], {
+      status: "legacy-missing"
+    });
+  }
+  const source = safeTrustedLegacyLocalStoreSourceCheck(paths);
+  if (!source.ok) {
+    return legacyMigrationResult(false, undefined, paths, [], {
+      status: "legacy-invalid",
+      integrityCheck: { legacy: "failed", error: source.error }
+    });
+  }
+  const legacy = safeSqliteIntegrityCheck(paths.legacyLocalStorePath);
+  return legacyMigrationResult(false, undefined, paths, [], {
+    status: legacy.ok ? "pending" : "legacy-invalid",
+    integrityCheck: legacy.ok ? { legacy: legacy.result } : { legacy: "failed", error: legacy.error }
+  });
+}
+function migrateLegacyLocalStoreIfNeeded(root = process.cwd(), env = process.env) {
+  const paths = runtimeStatePaths(root, env);
+  if (env[ARCHCONTEXT_LOCAL_STORE_PATH_ENV]) {
+    return legacyMigrationResult(false, "explicit-local-store-override", paths, [], {
+      status: "explicit-local-store-override"
+    });
+  }
+  ensurePrivateDir(dirname2(paths.localStorePath));
+  const legacyExists = existsSync3(paths.legacyLocalStorePath);
+  const integrityCheck = {};
+  const quarantinedFiles = [];
+  const targetExists = existsSync3(paths.localStorePath);
+  if (targetExists) {
+    try {
+      integrityCheck.target = assertCurrentLocalStore(paths.localStorePath);
+      return legacyMigrationResult(false, "target-exists", paths, [], {
+        status: "target-current",
+        integrityCheck
+      });
+    } catch (error) {
+      integrityCheck.target = "failed";
+      integrityCheck.error = error instanceof Error ? error.message : String(error);
+      if (!legacyExists) {
+        throw new Error(`ArchContext runtime state target is not a valid SQLite database and no legacy store is available: ${paths.localStorePath}`);
+      }
+    }
+  }
+  if (!legacyExists) {
+    return legacyMigrationResult(false, "legacy-missing", paths, [], {
+      status: "legacy-missing",
+      integrityCheck
+    });
+  }
+  assertTrustedLegacyLocalStoreSource(paths);
+  const lock = acquireLegacyMigrationLock(paths);
+  const stagingDir = join2(paths.workspaceStateDir, `.runtime.sqlite.migration-${process.pid}-${randomUUID()}`);
+  const stagingPath = join2(stagingDir, "runtime.sqlite");
+  try {
+    if (targetExists)
+      quarantinedFiles.push(...quarantineExistingLocalStore(paths));
+    ensurePrivateDir(stagingDir);
+    integrityCheck.legacy = vacuumLegacySqliteInto(paths.legacyLocalStorePath, stagingPath);
+    makePrivateFile(stagingPath);
+    migrateSqliteDatabaseSync(stagingPath);
+    compactSqliteDatabase(stagingPath);
+    integrityCheck.staging = assertCurrentLocalStore(stagingPath);
+    publishStagedLocalStore(stagingPath, paths.localStorePath);
+    integrityCheck.target = assertCurrentLocalStore(paths.localStorePath);
+    const markerPath = writeLegacyMigrationMarker(paths, integrityCheck, quarantinedFiles);
+    return legacyMigrationResult(true, undefined, paths, [paths.localStorePath], {
+      status: quarantinedFiles.length > 0 ? "target-quarantined-and-migrated" : "migrated",
+      integrityCheck,
+      markerPath,
+      quarantinedFiles
+    });
+  } catch (error) {
+    throw new Error(`ArchContext legacy SQLite migration failed: ${error instanceof Error ? error.message : String(error)}`);
+  } finally {
+    rmSync2(stagingDir, { recursive: true, force: true });
+    releaseLegacyMigrationLock(lock);
+  }
+}
+function openSqliteDatabaseSync(databasePath) {
+  if (databasePath !== ":memory:")
+    ensurePrivateDir(dirname2(databasePath));
+  try {
+    const nodeSqlite = runtimeRequire("node:sqlite");
+    const db2 = new nodeSqlite.DatabaseSync(databasePath);
+    return {
+      exec: (sql) => db2.exec(sql),
+      prepare: (sql) => db2.prepare(sql),
+      close: () => db2.close()
+    };
+  } catch (error) {
+    if (error.code !== "ERR_UNKNOWN_BUILTIN_MODULE" && error.code !== "MODULE_NOT_FOUND") {
+      throw error;
+    }
+  }
+  const bunSqlite = runtimeRequire("bun:sqlite");
+  const db = new bunSqlite.Database(databasePath);
+  return {
+    exec: (sql) => db.exec(sql),
+    prepare: (sql) => db.query(sql),
+    close: () => db.close()
+  };
+}
+function legacyMigrationResult(migrated, skippedReason, paths, copiedFiles, details) {
+  return {
+    schemaVersion: "archcontext.legacy-local-store-migration/v1",
+    status: details.status,
+    migrated,
+    skippedReason,
+    legacyLocalStorePath: paths.legacyLocalStorePath,
+    targetLocalStorePath: paths.localStorePath,
+    markerPath: details.markerPath ?? legacyMigrationMarkerPath(paths),
+    lockPath: legacyMigrationLockPath(paths),
+    integrityCheck: details.integrityCheck ?? {},
+    copiedFiles,
+    quarantinedFiles: details.quarantinedFiles ?? []
+  };
+}
+function safeSqliteIntegrityCheck(path) {
+  try {
+    return { ok: true, result: assertSqliteIntegrity(path) };
+  } catch (error) {
+    return { ok: false, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+function safeCurrentLocalStoreCheck(path) {
+  try {
+    return { ok: true, result: assertCurrentLocalStore(path) };
+  } catch (error) {
+    return { ok: false, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+function safeTrustedLegacyLocalStoreSourceCheck(paths) {
+  try {
+    assertTrustedLegacyLocalStoreSource(paths);
+    return { ok: true };
+  } catch (error) {
+    return { ok: false, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+function assertSqliteIntegrity(path) {
+  const db = openSqliteDatabaseSync(path);
+  try {
+    db.exec("PRAGMA busy_timeout = 5000");
+    const row = db.prepare("PRAGMA integrity_check").get();
+    const result = firstSqliteColumn(row);
+    if (result !== "ok")
+      throw new Error(`SQLite integrity_check failed for ${path}: ${result}`);
+    return result;
+  } finally {
+    db.close();
+  }
+}
+function assertCurrentLocalStore(path) {
+  const db = openSqliteDatabaseSync(path);
+  try {
+    db.exec("PRAGMA busy_timeout = 5000");
+    const integrity = sqliteIntegrityCheckOpenDatabase(db, path);
+    assertCurrentLocalStoreSchema(db, path);
+    return integrity;
+  } finally {
+    db.close();
+  }
+}
+function assertCurrentLocalStoreSchema(db, path) {
+  const tables = new Set(db.prepare("SELECT name FROM sqlite_master WHERE type = 'table'").all().map((row) => String(row.name)));
+  const missingTables = REQUIRED_LOCAL_STORE_TABLES.filter((table) => !tables.has(table));
+  if (missingTables.length > 0) {
+    throw new Error(`SQLite local store schema incomplete for ${path}: missing tables ${missingTables.join(", ")}`);
+  }
+  const migrations = new Set(db.prepare("SELECT id FROM schema_migrations").all().map((row) => String(row.id)));
+  const missingMigrations = LOCAL_SQLITE_MIGRATIONS.map((migration) => migration.id).filter((id) => !migrations.has(id));
+  if (missingMigrations.length > 0) {
+    throw new Error(`SQLite local store schema incomplete for ${path}: missing migrations ${missingMigrations.join(", ")}`);
+  }
+}
+function assertTrustedLegacyLocalStoreSource(paths) {
+  const stat = lstatSync2(paths.legacyLocalStorePath);
+  if (stat.isSymbolicLink()) {
+    throw new Error(`Legacy SQLite source must not be a symbolic link: ${paths.legacyLocalStorePath}`);
+  }
+  if (!stat.isFile()) {
+    throw new Error(`Legacy SQLite source must be a regular file: ${paths.legacyLocalStorePath}`);
+  }
+  const sourceRealPath = realpathSync4.native(paths.legacyLocalStorePath);
+  if (!isPathInsideOrSame(sourceRealPath, paths.repositoryRoot)) {
+    throw new Error(`Legacy SQLite source must stay inside the repository root: ${paths.legacyLocalStorePath}`);
+  }
+}
+function vacuumLegacySqliteInto(sourcePath, targetPath) {
+  const db = openSqliteDatabaseSync(sourcePath);
+  try {
+    db.exec("PRAGMA busy_timeout = 5000");
+    db.exec("PRAGMA wal_checkpoint(TRUNCATE)");
+    const integrity = sqliteIntegrityCheckOpenDatabase(db, sourcePath);
+    db.exec(`VACUUM INTO ${sqliteStringLiteral(targetPath)}`);
+    return integrity;
+  } finally {
+    db.close();
+  }
+}
+function migrateSqliteDatabaseSync(databasePath) {
+  const db = openSqliteDatabaseSync(databasePath);
+  try {
+    for (const pragma of SQLITE_PRAGMAS)
+      db.exec(pragma);
+    for (const migration of LOCAL_SQLITE_MIGRATIONS) {
+      for (const statement of migration.statements)
+        db.exec(statement);
+      db.prepare("INSERT OR IGNORE INTO schema_migrations (id, applied_at) VALUES (?, ?)").run(migration.id, nowIso());
+    }
+  } finally {
+    db.close();
+  }
+}
+function compactSqliteDatabase(databasePath) {
+  const db = openSqliteDatabaseSync(databasePath);
+  try {
+    db.exec("PRAGMA busy_timeout = 5000");
+    db.exec("PRAGMA wal_checkpoint(TRUNCATE)");
+    db.exec("PRAGMA journal_mode = DELETE");
+  } finally {
+    db.close();
+  }
+  for (const suffix of ["-wal", "-shm"])
+    rmSync2(`${databasePath}${suffix}`, { force: true });
+}
+function sqliteIntegrityCheckOpenDatabase(db, path) {
+  const row = db.prepare("PRAGMA integrity_check").get();
+  const result = firstSqliteColumn(row);
+  if (result !== "ok")
+    throw new Error(`SQLite integrity_check failed for ${path}: ${result}`);
+  return result;
+}
+function firstSqliteColumn(row) {
+  const value = row ? Object.values(row)[0] : undefined;
+  return typeof value === "string" ? value : String(value ?? "");
+}
+function sqliteStringLiteral(value) {
+  return `'${value.replace(/'/g, "''")}'`;
+}
+function publishStagedLocalStore(stagingPath, targetPath) {
+  for (const suffix of SQLITE_SIDECAR_SUFFIXES) {
+    const path = `${targetPath}${suffix}`;
+    if (existsSync3(path))
+      throw new Error(`Cannot publish migrated SQLite over existing target file: ${path}`);
+  }
+  renameSync2(stagingPath, targetPath);
+  makePrivateFile(targetPath);
+  fsyncDirectory2(dirname2(targetPath));
+}
+function writeLegacyMigrationMarker(paths, integrityCheck, quarantinedFiles) {
+  const markerPath = legacyMigrationMarkerPath(paths);
+  writePrivateJson(markerPath, {
+    schemaVersion: "archcontext.legacy-local-store-migration-marker/v1",
+    migratedAt: nowIso(),
+    legacyLocalStorePath: paths.legacyLocalStorePath,
+    targetLocalStorePath: paths.localStorePath,
+    integrityCheck,
+    quarantinedFiles
+  });
+  return markerPath;
+}
+function acquireLegacyMigrationLock(paths) {
+  const lockPath = legacyMigrationLockPath(paths);
+  ensurePrivateDir(dirname2(lockPath));
+  try {
+    const fd = openSync3(lockPath, "wx", 384);
+    writeFileSync2(fd, JSON.stringify({
+      schemaVersion: "archcontext.legacy-local-store-migration-lock/v1",
+      pid: process.pid,
+      root: paths.repositoryRoot,
+      targetLocalStorePath: paths.localStorePath,
+      startedAt: nowIso()
+    }, null, 2), "utf8");
+    fsyncSync2(fd);
+    return { fd, path: lockPath };
+  } catch (error) {
+    const code = error.code;
+    if (code === "EEXIST" && isStaleMigrationLock(lockPath)) {
+      rmSync2(lockPath, { force: true });
+      return acquireLegacyMigrationLock(paths);
+    }
+    if (code === "EEXIST")
+      throw new Error(`Legacy SQLite migration already in progress; lock=${lockPath}`);
+    throw error;
+  }
+}
+function releaseLegacyMigrationLock(lock) {
+  closeSync3(lock.fd);
+  rmSync2(lock.path, { force: true });
+}
+function isStaleMigrationLock(lockPath) {
+  try {
+    const parsed = JSON.parse(readFileSync5(lockPath, "utf8"));
+    if (typeof parsed.pid !== "number" || parsed.pid <= 0)
+      return true;
+    return !isProcessAlive(parsed.pid);
+  } catch {
+    return true;
+  }
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code !== "ESRCH";
+  }
+}
+function quarantineExistingLocalStore(paths) {
+  const quarantineDir = join2(paths.workspaceStateDir, "quarantine", `runtime.sqlite-${Date.now()}-${randomUUID()}`);
+  ensurePrivateDir(quarantineDir);
+  const quarantinedFiles = [];
+  for (const suffix of SQLITE_SIDECAR_SUFFIXES) {
+    const source = `${paths.localStorePath}${suffix}`;
+    if (!existsSync3(source))
+      continue;
+    const target = join2(quarantineDir, `runtime.sqlite${suffix}`);
+    renameSync2(source, target);
+    quarantinedFiles.push(target);
+  }
+  const markerPath = legacyMigrationMarkerPath(paths);
+  if (existsSync3(markerPath)) {
+    const target = join2(quarantineDir, LEGACY_MIGRATION_MARKER_FILE);
+    renameSync2(markerPath, target);
+    quarantinedFiles.push(target);
+  }
+  fsyncDirectory2(quarantineDir);
+  fsyncDirectory2(dirname2(paths.localStorePath));
+  return quarantinedFiles;
+}
+function legacyMigrationMarkerPath(paths) {
+  return join2(paths.workspaceStateDir, LEGACY_MIGRATION_MARKER_FILE);
+}
+function legacyMigrationLockPath(paths) {
+  return join2(paths.workspaceStateDir, LEGACY_MIGRATION_LOCK_FILE);
+}
+function writePrivateJson(path, value) {
+  ensurePrivateDir(dirname2(path));
+  const fd = openSync3(path, "w", 384);
+  try {
+    writeFileSync2(fd, JSON.stringify(value, null, 2), "utf8");
+    fsyncSync2(fd);
+  } finally {
+    closeSync3(fd);
+  }
+  makePrivateFile(path);
+  fsyncDirectory2(dirname2(path));
+}
+function ensurePrivateDir(path) {
+  mkdirSync2(path, { recursive: true, mode: 448 });
+  if (process.platform !== "win32") {
+    try {
+      chmodSync(path, 448);
+    } catch {}
+  }
+}
+function makePrivateFile(path) {
+  if (process.platform !== "win32") {
+    try {
+      chmodSync(path, 384);
+    } catch {}
+  }
+}
+function readGitPath(root, args) {
+  try {
+    const value = execFileSync2("git", args, {
+      cwd: root,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    return value.length > 0 ? value : undefined;
+  } catch {
+    return;
+  }
+}
+function resolveMaybeRelative(base, path) {
+  return isAbsolute3(path) ? resolve6(path) : resolve6(base, path);
+}
+function canonicalPath(path) {
+  const resolved = resolve6(path);
+  try {
+    return realpathSync4.native(resolved);
+  } catch {
+    return resolved;
+  }
+}
+function isPathInsideOrSame(path, parent) {
+  const child = resolve6(path);
+  const base = resolve6(parent);
+  const fromBase = relative4(base, child);
+  return fromBase === "" || !!fromBase && !fromBase.startsWith("..") && !isAbsolute3(fromBase);
+}
+function stableStorageId(prefix, value) {
+  return `${prefix}.${createHash5("sha256").update(value).digest("hex").slice(0, 16)}`;
+}
+function nowIso() {
+  return new Date().toISOString();
+}
+function fsyncDirectory2(path) {
+  try {
+    const fd = openSync3(path, "r");
+    try {
+      fsyncSync2(fd);
+    } finally {
+      closeSync3(fd);
+    }
+  } catch (error) {
+    if (!isIgnorableDirectoryFsyncError2(error))
+      throw error;
+  }
+}
+function isIgnorableDirectoryFsyncError2(error) {
+  const code = error.code;
+  return code === "EINVAL" || code === "EISDIR" || process.platform === "win32" && code === "EPERM";
 }
 
 // packages/local-runtime/git-adapter/src/index.ts
-import { execFileSync as execFileSync2, spawnSync } from "node:child_process";
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, mkdtempSync, rmSync as rmSync2 } from "node:fs";
+import { execFileSync as execFileSync3, spawnSync } from "node:child_process";
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, mkdtempSync, rmSync as rmSync3 } from "node:fs";
 import { dirname as dirname3, join as join3, resolve as resolve7 } from "node:path";
 function findRepositoryRoot(start) {
   try {
-    return resolve7(execFileSync2("git", ["rev-parse", "--show-toplevel"], {
+    return resolve7(execFileSync3("git", ["rev-parse", "--show-toplevel"], {
       cwd: start,
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"]
@@ -6543,7 +7158,7 @@ function findRepositoryRoot(start) {
   } catch {
     let cursor = resolve7(start);
     while (cursor !== "/") {
-      if (existsSync3(resolve7(cursor, ".git")))
+      if (existsSync4(resolve7(cursor, ".git")))
         return cursor;
       cursor = resolve7(cursor, "..");
     }
@@ -6552,7 +7167,7 @@ function findRepositoryRoot(start) {
 }
 function readHeadSha(root) {
   try {
-    return execFileSync2("git", ["rev-parse", "HEAD"], {
+    return execFileSync3("git", ["rev-parse", "HEAD"], {
       cwd: root,
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"]
@@ -6564,7 +7179,7 @@ function readHeadSha(root) {
 
 // packages/local-runtime/runtime-daemon/src/index.ts
 import { randomBytes } from "node:crypto";
-import { chmodSync, closeSync as closeSync4, existsSync as existsSync7, mkdirSync as mkdirSync6, mkdtempSync as mkdtempSync3, openSync as openSync4, readdirSync as readdirSync5, readFileSync as readFileSync6, rmSync as rmSync6, statSync as statSync4, writeFileSync as writeFileSync3 } from "node:fs";
+import { chmodSync as chmodSync3, closeSync as closeSync5, existsSync as existsSync8, mkdirSync as mkdirSync7, mkdtempSync as mkdtempSync3, openSync as openSync5, readdirSync as readdirSync5, readFileSync as readFileSync8, rmSync as rmSync7, statSync as statSync4, writeFileSync as writeFileSync5 } from "node:fs";
 import { createServer } from "node:http";
 import { tmpdir as tmpdir2 } from "node:os";
 import { dirname as dirname7, join as join6, resolve as resolve11 } from "node:path";
@@ -6599,13 +7214,13 @@ async function prepareTask(input) {
 init_src();
 
 // packages/local-runtime/git-adapter/src/index.ts
-import { execFileSync as execFileSync3, spawnSync as spawnSync2 } from "node:child_process";
-import { existsSync as existsSync4, mkdirSync as mkdirSync3, mkdtempSync as mkdtempSync2, rmSync as rmSync3 } from "node:fs";
+import { execFileSync as execFileSync4, spawnSync as spawnSync2 } from "node:child_process";
+import { existsSync as existsSync5, mkdirSync as mkdirSync4, mkdtempSync as mkdtempSync2, rmSync as rmSync4 } from "node:fs";
 import { dirname as dirname4, join as join4, resolve as resolve8 } from "node:path";
 import { tmpdir } from "node:os";
 function findRepositoryRoot2(start) {
   try {
-    return resolve8(execFileSync3("git", ["rev-parse", "--show-toplevel"], {
+    return resolve8(execFileSync4("git", ["rev-parse", "--show-toplevel"], {
       cwd: start,
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"]
@@ -6613,7 +7228,7 @@ function findRepositoryRoot2(start) {
   } catch {
     let cursor = resolve8(start);
     while (cursor !== "/") {
-      if (existsSync4(resolve8(cursor, ".git")))
+      if (existsSync5(resolve8(cursor, ".git")))
         return cursor;
       cursor = resolve8(cursor, "..");
     }
@@ -6622,7 +7237,7 @@ function findRepositoryRoot2(start) {
 }
 function readHeadSha2(root) {
   try {
-    return execFileSync3("git", ["rev-parse", "HEAD"], {
+    return execFileSync4("git", ["rev-parse", "HEAD"], {
       cwd: root,
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"]
@@ -6682,7 +7297,7 @@ function prepareDetachedReviewWorktree(input) {
     };
   }
   const parent = input.tempRoot ? resolve8(input.tempRoot) : tmpdir();
-  mkdirSync3(parent, { recursive: true });
+  mkdirSync4(parent, { recursive: true });
   const temporaryRoot = mkdtempSync2(join4(parent, "archctx-review-worktree-"));
   const worktreeRoot = join4(temporaryRoot, "worktree");
   try {
@@ -6714,7 +7329,7 @@ function prepareDetachedReviewWorktree(input) {
       }
     };
   } catch (error) {
-    rmSync3(temporaryRoot, { recursive: true, force: true });
+    rmSync4(temporaryRoot, { recursive: true, force: true });
     if (isGitWorktreeError(error)) {
       return {
         schemaVersion: "archcontext.detached-review-worktree-verification/v1",
@@ -6731,9 +7346,9 @@ function removeDetachedReviewWorktree(worktree) {
   try {
     runGit(worktree.sourceRoot, ["worktree", "remove", "--force", worktree.worktreeRoot]);
   } catch {
-    rmSync3(worktree.worktreeRoot, { recursive: true, force: true });
+    rmSync4(worktree.worktreeRoot, { recursive: true, force: true });
   } finally {
-    rmSync3(worktree.temporaryRoot || dirname4(worktree.worktreeRoot), { recursive: true, force: true });
+    rmSync4(worktree.temporaryRoot || dirname4(worktree.worktreeRoot), { recursive: true, force: true });
   }
 }
 function readCommitTreeOid(root, headSha) {
@@ -6769,7 +7384,7 @@ function readDetachedWorktreeObserved(worktreeRoot) {
   }
 }
 function runGit(root, args) {
-  return execFileSync3("git", args, {
+  return execFileSync4("git", args, {
     cwd: root,
     encoding: "utf8",
     stdio: ["ignore", "pipe", "pipe"]
@@ -6787,16 +7402,34 @@ function isGitWorktreeError(error) {
 }
 
 // packages/local-runtime/local-store-sqlite/src/index.ts
-import { randomUUID } from "node:crypto";
-import { closeSync as closeSync3, existsSync as existsSync5, fsyncSync as fsyncSync2, mkdirSync as mkdirSync4, openSync as openSync3, renameSync as renameSync2, rmSync as rmSync4 } from "node:fs";
+import { execFileSync as execFileSync5 } from "node:child_process";
+import { createHash as createHash6, randomUUID as randomUUID2 } from "node:crypto";
+import { chmodSync as chmodSync2, closeSync as closeSync4, existsSync as existsSync6, fsyncSync as fsyncSync3, lstatSync as lstatSync3, mkdirSync as mkdirSync5, openSync as openSync4, readFileSync as readFileSync6, realpathSync as realpathSync5, renameSync as renameSync3, rmSync as rmSync5, writeFileSync as writeFileSync3 } from "node:fs";
 import { readdir, readFile } from "node:fs/promises";
-import { dirname as dirname5, join as join5, resolve as resolve9 } from "node:path";
-var SQLITE_PRAGMAS = [
+import { createRequire as createRequire3 } from "node:module";
+import { homedir as homedir2 } from "node:os";
+import { dirname as dirname5, isAbsolute as isAbsolute4, join as join5, relative as relative5, resolve as resolve9 } from "node:path";
+var runtimeRequire2 = createRequire3(import.meta.url);
+var SQLITE_SIDECAR_SUFFIXES2 = ["", "-wal", "-shm"];
+var LEGACY_MIGRATION_MARKER_FILE2 = "runtime.sqlite.migration.json";
+var LEGACY_MIGRATION_LOCK_FILE2 = "runtime.sqlite.migration.lock";
+var REQUIRED_LOCAL_STORE_TABLES2 = [
+  "schema_migrations",
+  "repository_sessions",
+  "snapshots",
+  "task_states",
+  "observed_evidence",
+  "review_results",
+  "landscapes",
+  "cross_repo_edges",
+  "changeset_journal"
+];
+var SQLITE_PRAGMAS2 = [
   "PRAGMA journal_mode = WAL",
   "PRAGMA foreign_keys = ON",
   "PRAGMA busy_timeout = 5000"
 ];
-var LOCAL_SQLITE_MIGRATIONS = [
+var LOCAL_SQLITE_MIGRATIONS2 = [
   {
     id: "0001_runtime_state",
     statements: [
@@ -6893,8 +7526,117 @@ var LOCAL_SQLITE_MIGRATIONS = [
     ]
   }
 ];
+var ARCHCONTEXT_STATE_DIR_ENV2 = "ARCHCONTEXT_STATE_DIR";
+var ARCHCONTEXT_LOCAL_STORE_PATH_ENV2 = "ARCHCONTEXT_LOCAL_STORE_PATH";
+function defaultArchContextStateRoot2(env = process.env, platform = process.platform, home = homedir2()) {
+  const override = env[ARCHCONTEXT_STATE_DIR_ENV2];
+  if (override)
+    return { path: resolve9(override), source: "environment" };
+  if (platform === "darwin")
+    return { path: join5(home, "Library", "Application Support", "ArchContext"), source: "os-user-data" };
+  if (platform === "win32")
+    return { path: join5(env.LOCALAPPDATA ?? join5(home, "AppData", "Local"), "ArchContext"), source: "os-user-data" };
+  return { path: join5(env.XDG_DATA_HOME ?? join5(home, ".local", "share"), "archcontext"), source: "os-user-data" };
+}
+function runtimeStatePaths2(root = process.cwd(), env = process.env) {
+  const repositoryRoot = readGitPath2(root, ["rev-parse", "--show-toplevel"]) ?? root;
+  const canonicalRepositoryRoot3 = canonicalPath2(repositoryRoot);
+  const gitCommonDir = readGitPath2(canonicalRepositoryRoot3, ["rev-parse", "--git-common-dir"]);
+  const repositoryAnchor = canonicalPath2(gitCommonDir ? resolveMaybeRelative2(canonicalRepositoryRoot3, gitCommonDir) : canonicalRepositoryRoot3);
+  const workspaceAnchor = canonicalRepositoryRoot3;
+  const storageRepositoryId = stableStorageId2("repo", repositoryAnchor);
+  const storageWorkspaceId = stableStorageId2("ws", workspaceAnchor);
+  const stateRoot = defaultArchContextStateRoot2(env);
+  const repositoryStateDir = join5(stateRoot.path, "repositories", storageRepositoryId);
+  const workspaceStateDir = join5(repositoryStateDir, "worktrees", storageWorkspaceId);
+  const legacyControlDir = resolve9(canonicalRepositoryRoot3, ".archcontext", ".local");
+  return {
+    schemaVersion: "archcontext.runtime-state-paths/v1",
+    stateRoot: stateRoot.path,
+    source: stateRoot.source,
+    repositoryRoot: canonicalRepositoryRoot3,
+    repositoryAnchor,
+    workspaceAnchor,
+    storageRepositoryId,
+    storageWorkspaceId,
+    repositoryId: storageRepositoryId,
+    workspaceId: storageWorkspaceId,
+    repositoryStateDir,
+    workspaceStateDir,
+    sharedCacheDir: join5(repositoryStateDir, "shared", "cache"),
+    localStorePath: env[ARCHCONTEXT_LOCAL_STORE_PATH_ENV2] ?? join5(workspaceStateDir, "runtime.sqlite"),
+    daemonConnectionPath: join5(workspaceStateDir, "archctxd.json"),
+    daemonLockPath: join5(workspaceStateDir, "archctxd.lock"),
+    daemonLogPath: join5(workspaceStateDir, "archctxd.log"),
+    developerReviewRunStateDir: join5(workspaceStateDir, "developer-review-runs"),
+    legacyControlDir,
+    legacyLocalStorePath: join5(legacyControlDir, "runtime.sqlite")
+  };
+}
 function defaultLocalStorePath2(root = process.cwd()) {
-  return process.env.ARCHCONTEXT_LOCAL_STORE_PATH ?? resolve9(root, ".archcontext/.local/runtime.sqlite");
+  return runtimeStatePaths2(root).localStorePath;
+}
+function migrateLegacyLocalStoreIfNeeded2(root = process.cwd(), env = process.env) {
+  const paths = runtimeStatePaths2(root, env);
+  if (env[ARCHCONTEXT_LOCAL_STORE_PATH_ENV2]) {
+    return legacyMigrationResult2(false, "explicit-local-store-override", paths, [], {
+      status: "explicit-local-store-override"
+    });
+  }
+  ensurePrivateDir2(dirname5(paths.localStorePath));
+  const legacyExists = existsSync6(paths.legacyLocalStorePath);
+  const integrityCheck = {};
+  const quarantinedFiles = [];
+  const targetExists = existsSync6(paths.localStorePath);
+  if (targetExists) {
+    try {
+      integrityCheck.target = assertCurrentLocalStore2(paths.localStorePath);
+      return legacyMigrationResult2(false, "target-exists", paths, [], {
+        status: "target-current",
+        integrityCheck
+      });
+    } catch (error) {
+      integrityCheck.target = "failed";
+      integrityCheck.error = error instanceof Error ? error.message : String(error);
+      if (!legacyExists) {
+        throw new Error(`ArchContext runtime state target is not a valid SQLite database and no legacy store is available: ${paths.localStorePath}`);
+      }
+    }
+  }
+  if (!legacyExists) {
+    return legacyMigrationResult2(false, "legacy-missing", paths, [], {
+      status: "legacy-missing",
+      integrityCheck
+    });
+  }
+  assertTrustedLegacyLocalStoreSource2(paths);
+  const lock = acquireLegacyMigrationLock2(paths);
+  const stagingDir = join5(paths.workspaceStateDir, `.runtime.sqlite.migration-${process.pid}-${randomUUID2()}`);
+  const stagingPath = join5(stagingDir, "runtime.sqlite");
+  try {
+    if (targetExists)
+      quarantinedFiles.push(...quarantineExistingLocalStore2(paths));
+    ensurePrivateDir2(stagingDir);
+    integrityCheck.legacy = vacuumLegacySqliteInto2(paths.legacyLocalStorePath, stagingPath);
+    makePrivateFile2(stagingPath);
+    migrateSqliteDatabaseSync2(stagingPath);
+    compactSqliteDatabase2(stagingPath);
+    integrityCheck.staging = assertCurrentLocalStore2(stagingPath);
+    publishStagedLocalStore2(stagingPath, paths.localStorePath);
+    integrityCheck.target = assertCurrentLocalStore2(paths.localStorePath);
+    const markerPath = writeLegacyMigrationMarker2(paths, integrityCheck, quarantinedFiles);
+    return legacyMigrationResult2(true, undefined, paths, [paths.localStorePath], {
+      status: quarantinedFiles.length > 0 ? "target-quarantined-and-migrated" : "migrated",
+      integrityCheck,
+      markerPath,
+      quarantinedFiles
+    });
+  } catch (error) {
+    throw new Error(`ArchContext legacy SQLite migration failed: ${error instanceof Error ? error.message : String(error)}`);
+  } finally {
+    rmSync5(stagingDir, { recursive: true, force: true });
+    releaseLegacyMigrationLock2(lock);
+  }
 }
 
 class SqliteLocalStore {
@@ -6905,20 +7647,20 @@ class SqliteLocalStore {
   }
   async migrate() {
     const db = await this.database();
-    for (const pragma of SQLITE_PRAGMAS)
+    for (const pragma of SQLITE_PRAGMAS2)
       db.exec(pragma);
-    for (const migration of LOCAL_SQLITE_MIGRATIONS) {
+    for (const migration of LOCAL_SQLITE_MIGRATIONS2) {
       for (const statement of migration.statements)
         db.exec(statement);
-      db.prepare("INSERT OR IGNORE INTO schema_migrations (id, applied_at) VALUES (?, ?)").run(migration.id, nowIso());
+      db.prepare("INSERT OR IGNORE INTO schema_migrations (id, applied_at) VALUES (?, ?)").run(migration.id, nowIso2());
     }
   }
   async beginSnapshot(snapshot) {
     const db = await this.database();
-    const snapshotId = `snapshot_${randomUUID()}`;
+    const snapshotId = `snapshot_${randomUUID2()}`;
     db.prepare(`INSERT INTO snapshots
         (id, repository_id, head_sha, worktree_digest, state, created_at)
-        VALUES (?, ?, ?, ?, ?, ?)`).run(snapshotId, snapshot.repositoryId, snapshot.headSha, snapshot.worktreeDigest, "pending", nowIso());
+        VALUES (?, ?, ?, ?, ?, ?)`).run(snapshotId, snapshot.repositoryId, snapshot.headSha, snapshot.worktreeDigest, "pending", nowIso2());
     return snapshotId;
   }
   async commitSnapshot(snapshotId) {
@@ -6926,7 +7668,7 @@ class SqliteLocalStore {
     const existing = db.prepare("SELECT id FROM snapshots WHERE id = ?").get(snapshotId);
     if (!existing)
       throw new Error(`Snapshot not found: ${snapshotId}`);
-    db.prepare("UPDATE snapshots SET state = ?, committed_at = ? WHERE id = ?").run("committed", nowIso(), snapshotId);
+    db.prepare("UPDATE snapshots SET state = ?, committed_at = ? WHERE id = ?").run("committed", nowIso2(), snapshotId);
   }
   recoverPendingSnapshots() {
     const db = this.requireOpenDatabase();
@@ -6954,10 +7696,10 @@ class SqliteLocalStore {
   }
   async beginChangeSet(root, draft) {
     const db = await this.database();
-    const journalId = `changeset_${randomUUID()}`;
+    const journalId = `changeset_${randomUUID2()}`;
     db.prepare(`INSERT INTO changeset_journal
         (journal_id, changeset_id, root, status, metadata_json, files_json, created_at, updated_at)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(journalId, draft.id, root, "pending", stableJson(changeSetMetadata(draft)), "[]", nowIso(), nowIso());
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(journalId, draft.id, root, "pending", stableJson(changeSetMetadata(draft)), "[]", nowIso2(), nowIso2());
     return journalId;
   }
   async recordChangeSetFile(journalId, file) {
@@ -6967,14 +7709,14 @@ class SqliteLocalStore {
       throw new Error(`ChangeSet journal not found: ${journalId}`);
     const files = JSON.parse(String(row.files_json));
     files.push(file);
-    db.prepare("UPDATE changeset_journal SET files_json = ?, updated_at = ? WHERE journal_id = ?").run(stableJson(files), nowIso(), journalId);
+    db.prepare("UPDATE changeset_journal SET files_json = ?, updated_at = ? WHERE journal_id = ?").run(stableJson(files), nowIso2(), journalId);
   }
   async commitChangeSet(journalId) {
     const db = await this.database();
     const existing = db.prepare("SELECT journal_id FROM changeset_journal WHERE journal_id = ?").get(journalId);
     if (!existing)
       throw new Error(`ChangeSet journal not found: ${journalId}`);
-    db.prepare("UPDATE changeset_journal SET status = ?, updated_at = ?, completed_at = ? WHERE journal_id = ?").run("committed", nowIso(), nowIso(), journalId);
+    db.prepare("UPDATE changeset_journal SET status = ?, updated_at = ?, completed_at = ? WHERE journal_id = ?").run("committed", nowIso2(), nowIso2(), journalId);
   }
   async abortChangeSet(journalId, reason) {
     const db = await this.database();
@@ -6982,7 +7724,7 @@ class SqliteLocalStore {
     if (!row)
       throw new Error(`ChangeSet journal not found: ${journalId}`);
     const metadata = JSON.parse(String(row.metadata_json));
-    db.prepare("UPDATE changeset_journal SET status = ?, metadata_json = ?, updated_at = ?, completed_at = ? WHERE journal_id = ?").run("aborted", stableJson({ ...metadata, abortReason: reason }), nowIso(), nowIso(), journalId);
+    db.prepare("UPDATE changeset_journal SET status = ?, metadata_json = ?, updated_at = ?, completed_at = ? WHERE journal_id = ?").run("aborted", stableJson({ ...metadata, abortReason: reason }), nowIso2(), nowIso2(), journalId);
   }
   recoverPendingChangeSets() {
     const db = this.requireOpenDatabase();
@@ -6994,7 +7736,7 @@ class SqliteLocalStore {
     for (const row of rows) {
       const files = JSON.parse(String(row.files_json));
       recoverJournalFiles(String(row.root), files);
-      db.prepare("UPDATE changeset_journal SET status = ?, updated_at = ?, completed_at = ? WHERE journal_id = ?").run("recovered", nowIso(), nowIso(), String(row.journal_id));
+      db.prepare("UPDATE changeset_journal SET status = ?, updated_at = ?, completed_at = ? WHERE journal_id = ?").run("recovered", nowIso2(), nowIso2(), String(row.journal_id));
     }
     return rows.length;
   }
@@ -7002,7 +7744,7 @@ class SqliteLocalStore {
     const db = await this.database();
     db.prepare(`INSERT OR REPLACE INTO task_states
         (task_session_id, payload_json, updated_at)
-        VALUES (?, ?, ?)`).run(taskSessionId, stableJson(state), nowIso());
+        VALUES (?, ?, ?)`).run(taskSessionId, stableJson(state), nowIso2());
   }
   async readTaskState(taskSessionId) {
     const db = await this.database();
@@ -7013,13 +7755,13 @@ class SqliteLocalStore {
     const db = await this.database();
     db.prepare(`INSERT OR REPLACE INTO review_results
         (review_id, task_session_id, payload_json, created_at)
-        VALUES (?, ?, ?, ?)`).run(reviewId, reviewTaskSessionId(result) ?? reviewId, stableJson(result), nowIso());
+        VALUES (?, ?, ?, ?)`).run(reviewId, reviewTaskSessionId(result) ?? reviewId, stableJson(result), nowIso2());
   }
   async saveLandscape(landscape) {
     const db = await this.database();
     db.prepare(`INSERT OR REPLACE INTO landscapes
         (id, digest, metadata_json, updated_at)
-        VALUES (?, ?, ?, ?)`).run(landscape.id, landscapeDigest(landscape), stableJson(landscape), nowIso());
+        VALUES (?, ?, ?, ?)`).run(landscape.id, landscapeDigest(landscape), stableJson(landscape), nowIso2());
   }
   async readLandscape(landscapeId) {
     const db = await this.database();
@@ -7030,7 +7772,7 @@ class SqliteLocalStore {
     const db = await this.database();
     db.prepare(`INSERT OR REPLACE INTO cross_repo_edges
         (id, landscape_id, from_repository_id, from_node_id, to_repository_id, to_node_id, via_kind, via_id, metadata_json, updated_at)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(relation.id, "unscoped", relation.source.repositoryId, relation.source.nodeId, relation.target.repositoryId, relation.target.nodeId, relation.via.kind, relation.via.id, stableJson(relation), nowIso());
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(relation.id, "unscoped", relation.source.repositoryId, relation.source.nodeId, relation.target.repositoryId, relation.target.nodeId, relation.via.kind, relation.via.id, stableJson(relation), nowIso2());
   }
   async listCrossRepoRelations(landscape) {
     const db = await this.database();
@@ -7090,7 +7832,7 @@ async function rebuildDerivedLandscapeState(store, input) {
 }
 async function openSqliteDatabase(databasePath) {
   if (databasePath !== ":memory:")
-    mkdirSync4(dirname5(databasePath), { recursive: true });
+    ensurePrivateDir2(dirname5(databasePath));
   try {
     const nodeSqlite = await import("node:sqlite");
     const db = new nodeSqlite.DatabaseSync(databasePath);
@@ -7109,10 +7851,293 @@ async function openSqliteDatabase(databasePath) {
     };
   }
 }
+function openSqliteDatabaseSync2(databasePath) {
+  if (databasePath !== ":memory:")
+    ensurePrivateDir2(dirname5(databasePath));
+  try {
+    const nodeSqlite = runtimeRequire2("node:sqlite");
+    const db2 = new nodeSqlite.DatabaseSync(databasePath);
+    return {
+      exec: (sql) => db2.exec(sql),
+      prepare: (sql) => db2.prepare(sql),
+      close: () => db2.close()
+    };
+  } catch (error) {
+    if (error.code !== "ERR_UNKNOWN_BUILTIN_MODULE" && error.code !== "MODULE_NOT_FOUND") {
+      throw error;
+    }
+  }
+  const bunSqlite = runtimeRequire2("bun:sqlite");
+  const db = new bunSqlite.Database(databasePath);
+  return {
+    exec: (sql) => db.exec(sql),
+    prepare: (sql) => db.query(sql),
+    close: () => db.close()
+  };
+}
+function legacyMigrationResult2(migrated, skippedReason, paths, copiedFiles, details) {
+  return {
+    schemaVersion: "archcontext.legacy-local-store-migration/v1",
+    status: details.status,
+    migrated,
+    skippedReason,
+    legacyLocalStorePath: paths.legacyLocalStorePath,
+    targetLocalStorePath: paths.localStorePath,
+    markerPath: details.markerPath ?? legacyMigrationMarkerPath2(paths),
+    lockPath: legacyMigrationLockPath2(paths),
+    integrityCheck: details.integrityCheck ?? {},
+    copiedFiles,
+    quarantinedFiles: details.quarantinedFiles ?? []
+  };
+}
+function assertCurrentLocalStore2(path) {
+  const db = openSqliteDatabaseSync2(path);
+  try {
+    db.exec("PRAGMA busy_timeout = 5000");
+    const integrity = sqliteIntegrityCheckOpenDatabase2(db, path);
+    assertCurrentLocalStoreSchema2(db, path);
+    return integrity;
+  } finally {
+    db.close();
+  }
+}
+function assertCurrentLocalStoreSchema2(db, path) {
+  const tables = new Set(db.prepare("SELECT name FROM sqlite_master WHERE type = 'table'").all().map((row) => String(row.name)));
+  const missingTables = REQUIRED_LOCAL_STORE_TABLES2.filter((table) => !tables.has(table));
+  if (missingTables.length > 0) {
+    throw new Error(`SQLite local store schema incomplete for ${path}: missing tables ${missingTables.join(", ")}`);
+  }
+  const migrations = new Set(db.prepare("SELECT id FROM schema_migrations").all().map((row) => String(row.id)));
+  const missingMigrations = LOCAL_SQLITE_MIGRATIONS2.map((migration) => migration.id).filter((id) => !migrations.has(id));
+  if (missingMigrations.length > 0) {
+    throw new Error(`SQLite local store schema incomplete for ${path}: missing migrations ${missingMigrations.join(", ")}`);
+  }
+}
+function assertTrustedLegacyLocalStoreSource2(paths) {
+  const stat = lstatSync3(paths.legacyLocalStorePath);
+  if (stat.isSymbolicLink()) {
+    throw new Error(`Legacy SQLite source must not be a symbolic link: ${paths.legacyLocalStorePath}`);
+  }
+  if (!stat.isFile()) {
+    throw new Error(`Legacy SQLite source must be a regular file: ${paths.legacyLocalStorePath}`);
+  }
+  const sourceRealPath = realpathSync5.native(paths.legacyLocalStorePath);
+  if (!isPathInsideOrSame2(sourceRealPath, paths.repositoryRoot)) {
+    throw new Error(`Legacy SQLite source must stay inside the repository root: ${paths.legacyLocalStorePath}`);
+  }
+}
+function vacuumLegacySqliteInto2(sourcePath, targetPath) {
+  const db = openSqliteDatabaseSync2(sourcePath);
+  try {
+    db.exec("PRAGMA busy_timeout = 5000");
+    db.exec("PRAGMA wal_checkpoint(TRUNCATE)");
+    const integrity = sqliteIntegrityCheckOpenDatabase2(db, sourcePath);
+    db.exec(`VACUUM INTO ${sqliteStringLiteral2(targetPath)}`);
+    return integrity;
+  } finally {
+    db.close();
+  }
+}
+function migrateSqliteDatabaseSync2(databasePath) {
+  const db = openSqliteDatabaseSync2(databasePath);
+  try {
+    for (const pragma of SQLITE_PRAGMAS2)
+      db.exec(pragma);
+    for (const migration of LOCAL_SQLITE_MIGRATIONS2) {
+      for (const statement of migration.statements)
+        db.exec(statement);
+      db.prepare("INSERT OR IGNORE INTO schema_migrations (id, applied_at) VALUES (?, ?)").run(migration.id, nowIso2());
+    }
+  } finally {
+    db.close();
+  }
+}
+function compactSqliteDatabase2(databasePath) {
+  const db = openSqliteDatabaseSync2(databasePath);
+  try {
+    db.exec("PRAGMA busy_timeout = 5000");
+    db.exec("PRAGMA wal_checkpoint(TRUNCATE)");
+    db.exec("PRAGMA journal_mode = DELETE");
+  } finally {
+    db.close();
+  }
+  for (const suffix of ["-wal", "-shm"])
+    rmSync5(`${databasePath}${suffix}`, { force: true });
+}
+function sqliteIntegrityCheckOpenDatabase2(db, path) {
+  const row = db.prepare("PRAGMA integrity_check").get();
+  const result = firstSqliteColumn2(row);
+  if (result !== "ok")
+    throw new Error(`SQLite integrity_check failed for ${path}: ${result}`);
+  return result;
+}
+function firstSqliteColumn2(row) {
+  const value = row ? Object.values(row)[0] : undefined;
+  return typeof value === "string" ? value : String(value ?? "");
+}
+function sqliteStringLiteral2(value) {
+  return `'${value.replace(/'/g, "''")}'`;
+}
+function publishStagedLocalStore2(stagingPath, targetPath) {
+  for (const suffix of SQLITE_SIDECAR_SUFFIXES2) {
+    const path = `${targetPath}${suffix}`;
+    if (existsSync6(path))
+      throw new Error(`Cannot publish migrated SQLite over existing target file: ${path}`);
+  }
+  renameSync3(stagingPath, targetPath);
+  makePrivateFile2(targetPath);
+  fsyncDirectory3(dirname5(targetPath));
+}
+function writeLegacyMigrationMarker2(paths, integrityCheck, quarantinedFiles) {
+  const markerPath = legacyMigrationMarkerPath2(paths);
+  writePrivateJson2(markerPath, {
+    schemaVersion: "archcontext.legacy-local-store-migration-marker/v1",
+    migratedAt: nowIso2(),
+    legacyLocalStorePath: paths.legacyLocalStorePath,
+    targetLocalStorePath: paths.localStorePath,
+    integrityCheck,
+    quarantinedFiles
+  });
+  return markerPath;
+}
+function acquireLegacyMigrationLock2(paths) {
+  const lockPath = legacyMigrationLockPath2(paths);
+  ensurePrivateDir2(dirname5(lockPath));
+  try {
+    const fd = openSync4(lockPath, "wx", 384);
+    writeFileSync3(fd, JSON.stringify({
+      schemaVersion: "archcontext.legacy-local-store-migration-lock/v1",
+      pid: process.pid,
+      root: paths.repositoryRoot,
+      targetLocalStorePath: paths.localStorePath,
+      startedAt: nowIso2()
+    }, null, 2), "utf8");
+    fsyncSync3(fd);
+    return { fd, path: lockPath };
+  } catch (error) {
+    const code = error.code;
+    if (code === "EEXIST" && isStaleMigrationLock2(lockPath)) {
+      rmSync5(lockPath, { force: true });
+      return acquireLegacyMigrationLock2(paths);
+    }
+    if (code === "EEXIST")
+      throw new Error(`Legacy SQLite migration already in progress; lock=${lockPath}`);
+    throw error;
+  }
+}
+function releaseLegacyMigrationLock2(lock) {
+  closeSync4(lock.fd);
+  rmSync5(lock.path, { force: true });
+}
+function isStaleMigrationLock2(lockPath) {
+  try {
+    const parsed = JSON.parse(readFileSync6(lockPath, "utf8"));
+    if (typeof parsed.pid !== "number" || parsed.pid <= 0)
+      return true;
+    return !isProcessAlive2(parsed.pid);
+  } catch {
+    return true;
+  }
+}
+function isProcessAlive2(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code !== "ESRCH";
+  }
+}
+function quarantineExistingLocalStore2(paths) {
+  const quarantineDir = join5(paths.workspaceStateDir, "quarantine", `runtime.sqlite-${Date.now()}-${randomUUID2()}`);
+  ensurePrivateDir2(quarantineDir);
+  const quarantinedFiles = [];
+  for (const suffix of SQLITE_SIDECAR_SUFFIXES2) {
+    const source = `${paths.localStorePath}${suffix}`;
+    if (!existsSync6(source))
+      continue;
+    const target = join5(quarantineDir, `runtime.sqlite${suffix}`);
+    renameSync3(source, target);
+    quarantinedFiles.push(target);
+  }
+  const markerPath = legacyMigrationMarkerPath2(paths);
+  if (existsSync6(markerPath)) {
+    const target = join5(quarantineDir, LEGACY_MIGRATION_MARKER_FILE2);
+    renameSync3(markerPath, target);
+    quarantinedFiles.push(target);
+  }
+  fsyncDirectory3(quarantineDir);
+  fsyncDirectory3(dirname5(paths.localStorePath));
+  return quarantinedFiles;
+}
+function legacyMigrationMarkerPath2(paths) {
+  return join5(paths.workspaceStateDir, LEGACY_MIGRATION_MARKER_FILE2);
+}
+function legacyMigrationLockPath2(paths) {
+  return join5(paths.workspaceStateDir, LEGACY_MIGRATION_LOCK_FILE2);
+}
+function writePrivateJson2(path, value) {
+  ensurePrivateDir2(dirname5(path));
+  const fd = openSync4(path, "w", 384);
+  try {
+    writeFileSync3(fd, JSON.stringify(value, null, 2), "utf8");
+    fsyncSync3(fd);
+  } finally {
+    closeSync4(fd);
+  }
+  makePrivateFile2(path);
+  fsyncDirectory3(dirname5(path));
+}
+function ensurePrivateDir2(path) {
+  mkdirSync5(path, { recursive: true, mode: 448 });
+  if (process.platform !== "win32") {
+    try {
+      chmodSync2(path, 448);
+    } catch {}
+  }
+}
+function makePrivateFile2(path) {
+  if (process.platform !== "win32") {
+    try {
+      chmodSync2(path, 384);
+    } catch {}
+  }
+}
+function readGitPath2(root, args) {
+  try {
+    const value = execFileSync5("git", args, {
+      cwd: root,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    return value.length > 0 ? value : undefined;
+  } catch {
+    return;
+  }
+}
+function resolveMaybeRelative2(base, path) {
+  return isAbsolute4(path) ? resolve9(path) : resolve9(base, path);
+}
+function canonicalPath2(path) {
+  const resolved = resolve9(path);
+  try {
+    return realpathSync5.native(resolved);
+  } catch {
+    return resolved;
+  }
+}
+function isPathInsideOrSame2(path, parent) {
+  const child = resolve9(path);
+  const base = resolve9(parent);
+  const fromBase = relative5(base, child);
+  return fromBase === "" || !!fromBase && !fromBase.startsWith("..") && !isAbsolute4(fromBase);
+}
+function stableStorageId2(prefix, value) {
+  return `${prefix}.${createHash6("sha256").update(value).digest("hex").slice(0, 16)}`;
+}
 function stableJson(value) {
   return JSON.stringify(value);
 }
-function nowIso() {
+function nowIso2() {
   return new Date().toISOString();
 }
 function changeSetMetadata(draft) {
@@ -7137,36 +8162,36 @@ function recoverJournalFiles(root, files) {
   for (const file of [...files].reverse()) {
     const absolute = resolve9(root, file.path);
     if (file.tempPath)
-      rmSync4(file.tempPath, { recursive: true, force: true });
-    rmSync4(absolute, { recursive: true, force: true });
-    if (file.existed && file.backupPath && existsSync5(file.backupPath)) {
-      renameSync2(file.backupPath, absolute);
+      rmSync5(file.tempPath, { recursive: true, force: true });
+    rmSync5(absolute, { recursive: true, force: true });
+    if (file.existed && file.backupPath && existsSync6(file.backupPath)) {
+      renameSync3(file.backupPath, absolute);
     }
-    fsyncDirectory2(dirname5(absolute));
+    fsyncDirectory3(dirname5(absolute));
   }
 }
 function cleanupCommittedJournalFiles(files) {
   for (const file of files) {
     if (file.tempPath)
-      rmSync4(file.tempPath, { recursive: true, force: true });
+      rmSync5(file.tempPath, { recursive: true, force: true });
     if (file.backupPath)
-      rmSync4(file.backupPath, { recursive: true, force: true });
+      rmSync5(file.backupPath, { recursive: true, force: true });
   }
 }
-function fsyncDirectory2(path) {
+function fsyncDirectory3(path) {
   try {
-    const fd = openSync3(path, "r");
+    const fd = openSync4(path, "r");
     try {
-      fsyncSync2(fd);
+      fsyncSync3(fd);
     } finally {
-      closeSync3(fd);
+      closeSync4(fd);
     }
   } catch (error) {
-    if (!isIgnorableDirectoryFsyncError2(error))
+    if (!isIgnorableDirectoryFsyncError3(error))
       throw error;
   }
 }
-function isIgnorableDirectoryFsyncError2(error) {
+function isIgnorableDirectoryFsyncError3(error) {
   const code = error.code;
   return code === "EINVAL" || code === "EISDIR" || process.platform === "win32" && code === "EPERM";
 }
@@ -7197,7 +8222,7 @@ async function readRelationFiles(root, relationsDir) {
 
 // packages/local-runtime/model-store-yaml/src/index.ts
 init_src();
-import { existsSync as existsSync6, mkdirSync as mkdirSync5, readdirSync as readdirSync4, readFileSync as readFileSync5, rmSync as rmSync5, writeFileSync as writeFileSync2 } from "node:fs";
+import { existsSync as existsSync7, mkdirSync as mkdirSync6, readdirSync as readdirSync4, readFileSync as readFileSync7, rmSync as rmSync6, writeFileSync as writeFileSync4 } from "node:fs";
 import { dirname as dirname6, resolve as resolve10 } from "node:path";
 function createDefaultManifest(productId, productName) {
   return {
@@ -7251,7 +8276,7 @@ function initializeArchContextModel(root, productName = "ArchContext Project") {
   rebuildGeneratedProjection(root);
 }
 function rebuildGeneratedProjection(root) {
-  rmSync5(resolve10(root, ".archcontext/generated"), { recursive: true, force: true });
+  rmSync6(resolve10(root, ".archcontext/generated"), { recursive: true, force: true });
   writeFile(root, ".archcontext/generated/ARCHITECTURE.md", [
     "<!-- Generated by ArchContext. Do not edit by hand. -->",
     "",
@@ -7265,7 +8290,7 @@ function rebuildGeneratedProjection(root) {
 
 class YamlModelStore {
   async loadManifest(workspace) {
-    return readFileSync5(resolve10(workspace.root, ".archcontext/manifest.yaml"), "utf8");
+    return readFileSync7(resolve10(workspace.root, ".archcontext/manifest.yaml"), "utf8");
   }
   async loadModel(workspace) {
     return listModelFiles(workspace.root);
@@ -7274,7 +8299,7 @@ class YamlModelStore {
     const errors = [];
     for (const required of [".archcontext/manifest.yaml", ".archcontext/product.yaml"]) {
       try {
-        readFileSync5(resolve10(workspace.root, required), "utf8");
+        readFileSync7(resolve10(workspace.root, required), "utf8");
       } catch {
         errors.push(`missing ${required}`);
       }
@@ -7301,7 +8326,7 @@ function listModelFiles(root) {
     ".archcontext/generated"
   ]);
   return paths.map((path) => {
-    const body = readFileSync5(resolve10(root, path), "utf8");
+    const body = readFileSync7(resolve10(root, path), "utf8");
     return {
       path,
       body,
@@ -7314,7 +8339,7 @@ function collectArchContextFiles(root, entries) {
   const files = [];
   for (const entry of entries) {
     const absolute = resolve10(root, entry);
-    if (!existsSync6(absolute))
+    if (!existsSync7(absolute))
       continue;
     const stat = readdirOrFile(absolute);
     if (stat === "file") {
@@ -7359,8 +8384,8 @@ function writeYaml(root, path, value) {
 }
 function writeFile(root, path, body) {
   const absolute = resolve10(root, path);
-  mkdirSync5(dirname6(absolute), { recursive: true });
-  writeFileSync2(absolute, body.endsWith(`
+  mkdirSync6(dirname6(absolute), { recursive: true });
+  writeFileSync4(absolute, body.endsWith(`
 `) ? body : `${body}
 `, "utf8");
 }
@@ -7568,9 +8593,9 @@ class ArchctxDaemon {
       tempRoot: input.tempRoot,
       stateDir: input.stateDir
     });
-    mkdirSync6(paths.stateDir, { recursive: true });
-    mkdirSync6(paths.runRoot, { recursive: true });
-    mkdirSync6(paths.worktreeTempRoot, { recursive: true });
+    mkdirSync7(paths.stateDir, { recursive: true });
+    mkdirSync7(paths.runRoot, { recursive: true });
+    mkdirSync7(paths.worktreeTempRoot, { recursive: true });
     const preparing = {
       schemaVersion: "archcontext.developer-review-run/v1",
       runId: paths.runId,
@@ -7589,13 +8614,13 @@ class ArchctxDaemon {
         cleanup: "remove-run-root"
       }
     };
-    if (existsSync7(paths.lockPath) || existsSync7(paths.manifestPath)) {
-      rmSync6(paths.runRoot, { recursive: true, force: true });
+    if (existsSync8(paths.lockPath) || existsSync8(paths.manifestPath)) {
+      rmSync7(paths.runRoot, { recursive: true, force: true });
       throw new Error(`developer-review-run-already-active: ${input.challenge.challengeId}`);
     }
     let lockAcquired = false;
     try {
-      writePrivateJson(paths.lockPath, {
+      writePrivateJson3(paths.lockPath, {
         schemaVersion: "archcontext.developer-review-run-lock/v1",
         runId: paths.runId,
         challengeId: input.challenge.challengeId,
@@ -7625,7 +8650,7 @@ class ArchctxDaemon {
       if (lockAcquired) {
         this.cleanupDeveloperReviewRun(preparing);
       } else {
-        rmSync6(paths.runRoot, { recursive: true, force: true });
+        rmSync7(paths.runRoot, { recursive: true, force: true });
       }
       throw error;
     }
@@ -7646,7 +8671,7 @@ class ArchctxDaemon {
     const errors = [];
     if (run.worktree) {
       try {
-        const hadWorktree = existsSync7(run.worktree.worktreeRoot);
+        const hadWorktree = existsSync8(run.worktree.worktreeRoot);
         removeDetachedReviewWorktree(run.worktree);
         if (hadWorktree)
           removed.push("worktree");
@@ -7660,8 +8685,8 @@ class ArchctxDaemon {
       ["lock", run.lockPath]
     ]) {
       try {
-        const existed = existsSync7(path);
-        rmSync6(path, { recursive: true, force: true });
+        const existed = existsSync8(path);
+        rmSync7(path, { recursive: true, force: true });
         if (existed)
           removed.push(kind);
       } catch (error) {
@@ -7689,7 +8714,7 @@ class ArchctxDaemon {
       removedLocks: [],
       skippedActive: []
     };
-    if (!existsSync7(stateDir))
+    if (!existsSync8(stateDir))
       return recovery;
     for (const entry of readdirSync5(stateDir).sort()) {
       if (!entry.endsWith(".json"))
@@ -7697,7 +8722,7 @@ class ArchctxDaemon {
       const manifestPath = join6(stateDir, entry);
       const manifest = readDeveloperReviewRunManifest(manifestPath);
       if (!manifest) {
-        rmSync6(manifestPath, { force: true });
+        rmSync7(manifestPath, { force: true });
         continue;
       }
       if (!input.force && isDeveloperReviewPidAlive(manifest.pid)) {
@@ -7717,7 +8742,7 @@ class ArchctxDaemon {
         recovery.skippedActive.push(runId);
         continue;
       }
-      rmSync6(lockPath, { force: true });
+      rmSync7(lockPath, { force: true });
       recovery.removedLocks.push(lockPath);
     }
     return recovery;
@@ -8010,7 +9035,7 @@ class ArchctxDaemon {
     const status = this.status();
     if (!root)
       return okEnvelope("status", status);
-    const repositoryId = repositoryFingerprint(root);
+    const repositoryId = repositoryFingerprint2(root);
     const session = this.sessions.get(repositoryId);
     return okEnvelope("status", {
       ...status,
@@ -8057,9 +9082,9 @@ class ArchctxDaemon {
   }
   async restoreRepositorySessions() {
     for (const record of await this.localStore.listRepositorySessions()) {
-      if (!record.root || !existsSync7(record.root))
+      if (!record.root || !existsSync8(record.root))
         continue;
-      if (repositoryFingerprint(record.root) !== record.repositoryId)
+      if (repositoryFingerprint2(record.root) !== record.repositoryId)
         continue;
       this.sessions.set(record.repositoryId, {
         workspace: {
@@ -8345,8 +9370,8 @@ class ArchctxRuntimeRpcServer {
     const root = this.options.root ?? process.cwd();
     const connectionPath = this.options.connectionPath ?? defaultDaemonConnectionPath(root);
     const lockPath = this.options.lockPath ?? defaultDaemonLockPath(root);
-    mkdirSync6(dirname7(connectionPath), { recursive: true });
-    mkdirSync6(dirname7(lockPath), { recursive: true });
+    mkdirSync7(dirname7(connectionPath), { recursive: true });
+    mkdirSync7(dirname7(lockPath), { recursive: true });
     this.lockFd = acquireDaemonLock(lockPath, root);
     const token = this.options.token ?? randomBytes(18).toString("base64url");
     const server = createServer((request, response) => {
@@ -8369,8 +9394,8 @@ class ArchctxRuntimeRpcServer {
       connectionPath,
       startedAt: (this.options.clock ?? (() => new Date().toISOString()))()
     };
-    writeFileSync3(connectionPath, JSON.stringify(this.connection, null, 2), { mode: 384 });
-    chmodSync(connectionPath, 384);
+    writeFileSync5(connectionPath, JSON.stringify(this.connection, null, 2), { mode: 384 });
+    chmodSync3(connectionPath, 384);
     return this.connection;
   }
   async stop() {
@@ -8385,12 +9410,12 @@ class ArchctxRuntimeRpcServer {
     }
     await this.daemon.stop();
     if (connection)
-      rmSync6(connection.connectionPath, { force: true });
+      rmSync7(connection.connectionPath, { force: true });
     if (this.lockFd !== undefined)
-      closeSync4(this.lockFd);
+      closeSync5(this.lockFd);
     this.lockFd = undefined;
     if (connection)
-      rmSync6(connection.lockPath, { force: true });
+      rmSync7(connection.lockPath, { force: true });
     this.options.onStop?.();
   }
   async handleRequest(request, response) {
@@ -8513,24 +9538,21 @@ class ArchctxRuntimeRpcServer {
     }
   }
 }
-function defaultDaemonControlDir(root = process.cwd()) {
-  return join6(root, ".archcontext", ".local");
-}
 function defaultDeveloperReviewRunStateDir(root = process.cwd()) {
-  return join6(defaultDaemonControlDir(root), "developer-review-runs");
+  return runtimeStatePaths2(root).developerReviewRunStateDir;
 }
 function defaultDaemonConnectionPath(root = process.cwd()) {
-  return join6(defaultDaemonControlDir(root), "archctxd.json");
+  return runtimeStatePaths2(root).daemonConnectionPath;
 }
 function defaultDaemonLockPath(root = process.cwd()) {
-  return join6(defaultDaemonControlDir(root), "archctxd.lock");
+  return runtimeStatePaths2(root).daemonLockPath;
 }
 function readRuntimeRpcConnectionFile(root = process.cwd()) {
   const path = defaultDaemonConnectionPath(root);
   try {
     if (!isPrivateControlFile(path))
       return;
-    const parsed = JSON.parse(readFileSync6(path, "utf8"));
+    const parsed = JSON.parse(readFileSync8(path, "utf8"));
     if (!parsed || typeof parsed !== "object")
       return;
     return {
@@ -8562,7 +9584,7 @@ function runtimeRpcCompatibilityIssue(root = process.cwd()) {
     connectionPath: connection.connectionPath ?? defaultDaemonConnectionPath(root),
     lockPath: connection.lockPath ?? defaultDaemonLockPath(root),
     pid,
-    pidAlive: pid !== undefined ? isProcessAlive(pid) : false,
+    pidAlive: pid !== undefined ? isProcessAlive3(pid) : false,
     upgradeCommand: "archctx daemon upgrade"
   };
 }
@@ -8571,7 +9593,7 @@ function readRuntimeRpcConnection(root = process.cwd()) {
   try {
     if (!isPrivateControlFile(path))
       return;
-    const parsed = JSON.parse(readFileSync6(path, "utf8"));
+    const parsed = JSON.parse(readFileSync8(path, "utf8"));
     return isValidRuntimeRpcConnection(parsed) ? parsed : undefined;
   } catch {
     return;
@@ -8587,11 +9609,11 @@ function recoverStaleDaemonControlFiles(root = process.cwd(), options = {}) {
   const removed = [];
   const connectionReason = staleConnectionFileReason(connectionPath, options.removeUnhealthyConnection ?? false);
   if (connectionReason) {
-    rmSync6(connectionPath, { force: true });
+    rmSync7(connectionPath, { force: true });
     removed.push(connectionReason);
   }
-  if (existsSync7(lockPath) && isStaleLock(lockPath)) {
-    rmSync6(lockPath, { force: true });
+  if (existsSync8(lockPath) && isStaleLock(lockPath)) {
+    rmSync7(lockPath, { force: true });
     removed.push("stale-lock-file");
   }
   return { connectionPath, lockPath, removed };
@@ -8687,7 +9709,7 @@ function createDeveloperReviewRunPaths(input) {
   const runId = `${safeChallengeId}-${randomBytes(6).toString("hex")}`;
   const stateDir = input.stateDir ? resolve11(input.stateDir) : defaultDeveloperReviewRunStateDir(input.sourceRoot);
   const tempParent = input.tempRoot ? resolve11(input.tempRoot) : tmpdir2();
-  mkdirSync6(tempParent, { recursive: true });
+  mkdirSync7(tempParent, { recursive: true });
   const runRoot = mkdtempSync3(join6(tempParent, `archctx-developer-review-${safeChallengeId.slice(0, 32)}-`));
   return {
     runId,
@@ -8703,12 +9725,12 @@ function safeControlFileSegment(value) {
   return sanitized.length > 0 ? sanitized : "developer-review";
 }
 function writeDeveloperReviewRunManifest(manifest) {
-  writePrivateJson(manifest.manifestPath, manifest);
+  writePrivateJson3(manifest.manifestPath, manifest);
 }
-function writePrivateJson(path, value, flag = "w") {
-  mkdirSync6(dirname7(path), { recursive: true });
-  writeFileSync3(path, JSON.stringify(value, null, 2), { mode: 384, flag });
-  chmodSync(path, 384);
+function writePrivateJson3(path, value, flag = "w") {
+  mkdirSync7(dirname7(path), { recursive: true });
+  writeFileSync5(path, JSON.stringify(value, null, 2), { mode: 384, flag });
+  chmodSync3(path, 384);
 }
 function readDeveloperReviewRunManifest(path) {
   const parsed = readJsonObject(path);
@@ -8730,7 +9752,7 @@ function readDeveloperReviewRunManifest(path) {
 }
 function readJsonObject(path) {
   try {
-    const parsed = JSON.parse(readFileSync6(path, "utf8"));
+    const parsed = JSON.parse(readFileSync8(path, "utf8"));
     return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : undefined;
   } catch {
     return;
@@ -8739,7 +9761,7 @@ function readJsonObject(path) {
 function isDeveloperReviewPidAlive(pid) {
   if (!pid || pid <= 0)
     return false;
-  return isProcessAlive(pid);
+  return isProcessAlive3(pid);
 }
 function cleanupErrorMessage(kind, error) {
   return `${kind}: ${error instanceof Error ? error.message : String(error)}`;
@@ -8750,6 +9772,8 @@ async function createStartedDaemon(deps = {}) {
   return daemon;
 }
 function createProductionDaemon(options = {}) {
+  if (!options.localStorePath)
+    migrateLegacyLocalStoreIfNeeded2(options.root);
   const deps = {
     localStorePath: options.localStorePath ?? defaultLocalStorePath2(options.root),
     maxRepoSessions: options.maxRepoSessions
@@ -8796,15 +9820,15 @@ function blockedProductionInjections(deps) {
 }
 function acquireDaemonLock(lockPath, root) {
   try {
-    const fd = openSync4(lockPath, "wx", 384);
-    writeFileSync3(fd, JSON.stringify({ pid: process.pid, root, startedAt: new Date().toISOString() }, null, 2), "utf8");
+    const fd = openSync5(lockPath, "wx", 384);
+    writeFileSync5(fd, JSON.stringify({ pid: process.pid, root, startedAt: new Date().toISOString() }, null, 2), "utf8");
     return fd;
   } catch (error) {
     const code = error.code;
     if (code !== "EEXIST")
       throw error;
     if (isStaleLock(lockPath)) {
-      rmSync6(lockPath, { force: true });
+      rmSync7(lockPath, { force: true });
       return acquireDaemonLock(lockPath, root);
     }
     throw new Error(`archctxd already running for ${root}; lock=${lockPath}`);
@@ -8814,15 +9838,15 @@ function isValidRuntimeRpcConnection(value) {
   return value.schemaVersion === RUNTIME_RPC_VERSION && value.protocol === "http-loopback" && value.version === 1 && typeof value.url === "string" && value.url.startsWith("http://127.0.0.1:") && typeof value.token === "string" && value.token.length > 0 && typeof value.pid === "number" && typeof value.connectionPath === "string" && typeof value.lockPath === "string";
 }
 function staleConnectionFileReason(path, removeUnhealthyConnection) {
-  if (!existsSync7(path))
+  if (!existsSync8(path))
     return;
   try {
     if (!isPrivateControlFile(path))
       return "insecure-connection-file";
-    const parsed = JSON.parse(readFileSync6(path, "utf8"));
+    const parsed = JSON.parse(readFileSync8(path, "utf8"));
     if (!isValidRuntimeRpcConnection(parsed))
       return "invalid-connection-file";
-    if (!isProcessAlive(parsed.pid))
+    if (!isProcessAlive3(parsed.pid))
       return "dead-connection-pid";
     return removeUnhealthyConnection ? "unhealthy-connection-file" : undefined;
   } catch {
@@ -8837,15 +9861,15 @@ function isPrivateControlFile(path) {
 }
 function isStaleLock(lockPath) {
   try {
-    const lock = JSON.parse(readFileSync6(lockPath, "utf8"));
+    const lock = JSON.parse(readFileSync8(lockPath, "utf8"));
     if (typeof lock.pid !== "number" || lock.pid <= 0)
       return true;
-    return !isProcessAlive(lock.pid);
+    return !isProcessAlive3(lock.pid);
   } catch {
     return true;
   }
 }
-function isProcessAlive(pid) {
+function isProcessAlive3(pid) {
   try {
     process.kill(pid, 0);
     return true;
@@ -9031,7 +10055,7 @@ init_src();
 
 // packages/local-runtime/runtime-daemon/src/index.ts
 import { randomBytes as randomBytes2 } from "node:crypto";
-import { chmodSync as chmodSync2, closeSync as closeSync5, existsSync as existsSync8, mkdirSync as mkdirSync7, mkdtempSync as mkdtempSync4, openSync as openSync5, readdirSync as readdirSync6, readFileSync as readFileSync7, rmSync as rmSync7, statSync as statSync5, writeFileSync as writeFileSync4 } from "node:fs";
+import { chmodSync as chmodSync4, closeSync as closeSync6, existsSync as existsSync9, mkdirSync as mkdirSync8, mkdtempSync as mkdtempSync4, openSync as openSync6, readdirSync as readdirSync6, readFileSync as readFileSync9, rmSync as rmSync8, statSync as statSync5, writeFileSync as writeFileSync6 } from "node:fs";
 import { createServer as createServer2 } from "node:http";
 import { tmpdir as tmpdir3 } from "node:os";
 import { dirname as dirname8, join as join7, resolve as resolve12 } from "node:path";
@@ -9238,9 +10262,9 @@ class ArchctxDaemon2 {
       tempRoot: input.tempRoot,
       stateDir: input.stateDir
     });
-    mkdirSync7(paths.stateDir, { recursive: true });
-    mkdirSync7(paths.runRoot, { recursive: true });
-    mkdirSync7(paths.worktreeTempRoot, { recursive: true });
+    mkdirSync8(paths.stateDir, { recursive: true });
+    mkdirSync8(paths.runRoot, { recursive: true });
+    mkdirSync8(paths.worktreeTempRoot, { recursive: true });
     const preparing = {
       schemaVersion: "archcontext.developer-review-run/v1",
       runId: paths.runId,
@@ -9259,13 +10283,13 @@ class ArchctxDaemon2 {
         cleanup: "remove-run-root"
       }
     };
-    if (existsSync8(paths.lockPath) || existsSync8(paths.manifestPath)) {
-      rmSync7(paths.runRoot, { recursive: true, force: true });
+    if (existsSync9(paths.lockPath) || existsSync9(paths.manifestPath)) {
+      rmSync8(paths.runRoot, { recursive: true, force: true });
       throw new Error(`developer-review-run-already-active: ${input.challenge.challengeId}`);
     }
     let lockAcquired = false;
     try {
-      writePrivateJson2(paths.lockPath, {
+      writePrivateJson4(paths.lockPath, {
         schemaVersion: "archcontext.developer-review-run-lock/v1",
         runId: paths.runId,
         challengeId: input.challenge.challengeId,
@@ -9295,7 +10319,7 @@ class ArchctxDaemon2 {
       if (lockAcquired) {
         this.cleanupDeveloperReviewRun(preparing);
       } else {
-        rmSync7(paths.runRoot, { recursive: true, force: true });
+        rmSync8(paths.runRoot, { recursive: true, force: true });
       }
       throw error;
     }
@@ -9316,7 +10340,7 @@ class ArchctxDaemon2 {
     const errors = [];
     if (run.worktree) {
       try {
-        const hadWorktree = existsSync8(run.worktree.worktreeRoot);
+        const hadWorktree = existsSync9(run.worktree.worktreeRoot);
         removeDetachedReviewWorktree(run.worktree);
         if (hadWorktree)
           removed.push("worktree");
@@ -9330,8 +10354,8 @@ class ArchctxDaemon2 {
       ["lock", run.lockPath]
     ]) {
       try {
-        const existed = existsSync8(path);
-        rmSync7(path, { recursive: true, force: true });
+        const existed = existsSync9(path);
+        rmSync8(path, { recursive: true, force: true });
         if (existed)
           removed.push(kind);
       } catch (error) {
@@ -9359,7 +10383,7 @@ class ArchctxDaemon2 {
       removedLocks: [],
       skippedActive: []
     };
-    if (!existsSync8(stateDir))
+    if (!existsSync9(stateDir))
       return recovery;
     for (const entry of readdirSync6(stateDir).sort()) {
       if (!entry.endsWith(".json"))
@@ -9367,7 +10391,7 @@ class ArchctxDaemon2 {
       const manifestPath = join7(stateDir, entry);
       const manifest = readDeveloperReviewRunManifest2(manifestPath);
       if (!manifest) {
-        rmSync7(manifestPath, { force: true });
+        rmSync8(manifestPath, { force: true });
         continue;
       }
       if (!input.force && isDeveloperReviewPidAlive2(manifest.pid)) {
@@ -9387,7 +10411,7 @@ class ArchctxDaemon2 {
         recovery.skippedActive.push(runId);
         continue;
       }
-      rmSync7(lockPath, { force: true });
+      rmSync8(lockPath, { force: true });
       recovery.removedLocks.push(lockPath);
     }
     return recovery;
@@ -9680,7 +10704,7 @@ class ArchctxDaemon2 {
     const status = this.status();
     if (!root)
       return okEnvelope("status", status);
-    const repositoryId = repositoryFingerprint(root);
+    const repositoryId = repositoryFingerprint2(root);
     const session = this.sessions.get(repositoryId);
     return okEnvelope("status", {
       ...status,
@@ -9727,9 +10751,9 @@ class ArchctxDaemon2 {
   }
   async restoreRepositorySessions() {
     for (const record of await this.localStore.listRepositorySessions()) {
-      if (!record.root || !existsSync8(record.root))
+      if (!record.root || !existsSync9(record.root))
         continue;
-      if (repositoryFingerprint(record.root) !== record.repositoryId)
+      if (repositoryFingerprint2(record.root) !== record.repositoryId)
         continue;
       this.sessions.set(record.repositoryId, {
         workspace: {
@@ -9996,14 +11020,11 @@ class RuntimeRpcClient2 {
     return await response.json();
   }
 }
-function defaultDaemonControlDir2(root = process.cwd()) {
-  return join7(root, ".archcontext", ".local");
-}
 function defaultDeveloperReviewRunStateDir2(root = process.cwd()) {
-  return join7(defaultDaemonControlDir2(root), "developer-review-runs");
+  return runtimeStatePaths2(root).developerReviewRunStateDir;
 }
 function defaultDaemonConnectionPath2(root = process.cwd()) {
-  return join7(defaultDaemonControlDir2(root), "archctxd.json");
+  return runtimeStatePaths2(root).daemonConnectionPath;
 }
 function unwrapRpcData2(result) {
   if (!result.ok)
@@ -10015,7 +11036,7 @@ function readRuntimeRpcConnection2(root = process.cwd()) {
   try {
     if (!isPrivateControlFile2(path))
       return;
-    const parsed = JSON.parse(readFileSync7(path, "utf8"));
+    const parsed = JSON.parse(readFileSync9(path, "utf8"));
     return isValidRuntimeRpcConnection2(parsed) ? parsed : undefined;
   } catch {
     return;
@@ -10116,7 +11137,7 @@ function createDeveloperReviewRunPaths2(input) {
   const runId = `${safeChallengeId}-${randomBytes2(6).toString("hex")}`;
   const stateDir = input.stateDir ? resolve12(input.stateDir) : defaultDeveloperReviewRunStateDir2(input.sourceRoot);
   const tempParent = input.tempRoot ? resolve12(input.tempRoot) : tmpdir3();
-  mkdirSync7(tempParent, { recursive: true });
+  mkdirSync8(tempParent, { recursive: true });
   const runRoot = mkdtempSync4(join7(tempParent, `archctx-developer-review-${safeChallengeId.slice(0, 32)}-`));
   return {
     runId,
@@ -10132,12 +11153,12 @@ function safeControlFileSegment2(value) {
   return sanitized.length > 0 ? sanitized : "developer-review";
 }
 function writeDeveloperReviewRunManifest2(manifest) {
-  writePrivateJson2(manifest.manifestPath, manifest);
+  writePrivateJson4(manifest.manifestPath, manifest);
 }
-function writePrivateJson2(path, value, flag = "w") {
-  mkdirSync7(dirname8(path), { recursive: true });
-  writeFileSync4(path, JSON.stringify(value, null, 2), { mode: 384, flag });
-  chmodSync2(path, 384);
+function writePrivateJson4(path, value, flag = "w") {
+  mkdirSync8(dirname8(path), { recursive: true });
+  writeFileSync6(path, JSON.stringify(value, null, 2), { mode: 384, flag });
+  chmodSync4(path, 384);
 }
 function readDeveloperReviewRunManifest2(path) {
   const parsed = readJsonObject2(path);
@@ -10159,7 +11180,7 @@ function readDeveloperReviewRunManifest2(path) {
 }
 function readJsonObject2(path) {
   try {
-    const parsed = JSON.parse(readFileSync7(path, "utf8"));
+    const parsed = JSON.parse(readFileSync9(path, "utf8"));
     return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : undefined;
   } catch {
     return;
@@ -10168,7 +11189,7 @@ function readJsonObject2(path) {
 function isDeveloperReviewPidAlive2(pid) {
   if (!pid || pid <= 0)
     return false;
-  return isProcessAlive2(pid);
+  return isProcessAlive4(pid);
 }
 function cleanupErrorMessage2(kind, error) {
   return `${kind}: ${error instanceof Error ? error.message : String(error)}`;
@@ -10214,7 +11235,7 @@ function isPrivateControlFile2(path) {
   const mode = statSync5(path).mode & 511;
   return (mode & 63) === 0;
 }
-function isProcessAlive2(pid) {
+function isProcessAlive4(pid) {
   try {
     process.kill(pid, 0);
     return true;
@@ -10401,7 +11422,7 @@ async function runStdioMcpLoop(input, output, log = (line) => process.stderr.wri
 
 // packages/surfaces/renderer/src/index.ts
 init_src();
-import { existsSync as existsSync9, readdirSync as readdirSync7, readFileSync as readFileSync8 } from "node:fs";
+import { existsSync as existsSync10, readdirSync as readdirSync7, readFileSync as readFileSync10 } from "node:fs";
 import { resolve as resolve13 } from "node:path";
 function normalizeNativeModel2(model) {
   return {
@@ -10437,9 +11458,9 @@ function mermaidId(id) {
   return stableId(id).replace(/-/g, "_").replace(/\./g, "_");
 }
 function readYamlObjects(dir) {
-  if (!existsSync9(dir))
+  if (!existsSync10(dir))
     return [];
-  return readdirSync7(dir).filter((file) => /\.ya?ml$/.test(file)).sort().map((file) => parseFlatYaml(readFileSync8(resolve13(dir, file), "utf8")));
+  return readdirSync7(dir).filter((file) => /\.ya?ml$/.test(file)).sort().map((file) => parseFlatYaml(readFileSync10(resolve13(dir, file), "utf8")));
 }
 function parseFlatYaml(body) {
   const out = {};
@@ -10464,7 +11485,7 @@ function escapeMermaid(value) {
 // packages/surfaces/cli/src/main.ts
 var [, , command, ...args] = process.argv;
 var CLI_ENTRY = fileURLToPath(import.meta.url);
-var DAEMON_START_TIMEOUT_MS = 5000;
+var DAEMON_START_TIMEOUT_MS = 15000;
 
 class RuntimeVersionUnsupportedError extends Error {
   issue;
@@ -10679,6 +11700,8 @@ async function runCliUnchecked(command2 = "help", args2 = [], cwd, deps = {}) {
         };
       case "doctor":
         return { schemaVersion: "archcontext.envelope/v1", ok: true, requestId: "doctor", data: await doctorReport(cwd) };
+      case "paths":
+        return { schemaVersion: "archcontext.envelope/v1", ok: true, requestId: "paths", data: runtimePathsReport(cwd) };
       case "privacy-audit":
         return {
           schemaVersion: "archcontext.envelope/v1",
@@ -10724,8 +11747,8 @@ async function runCliUnchecked(command2 = "help", args2 = [], cwd, deps = {}) {
           ok: true,
           requestId: "help",
           data: {
-            commands: ["init", "sync", "validate", "context", "status", "daemon", "repo", "landscape", "explore", "prepare", "checkpoint", "plan", "apply", "review", "complete", "github", "config", "mcp", "install", "uninstall", "doctor", "privacy-audit", "export", "import", "tunnel"],
-            examples: ["archctx init --name MyApp", "archctx github connect", "archctx github status", "archctx daemon start", "archctx explore start --foreground", "archctx export likec4", "archctx import structurizr --content '<json>'", "archctx tunnel"]
+            commands: ["init", "sync", "validate", "context", "status", "daemon", "repo", "landscape", "explore", "prepare", "checkpoint", "plan", "apply", "review", "complete", "github", "config", "mcp", "install", "uninstall", "doctor", "paths", "privacy-audit", "export", "import", "tunnel"],
+            examples: ["archctx init --name MyApp", "archctx paths", "archctx github connect", "archctx github status", "archctx daemon start", "archctx explore start --foreground", "archctx export likec4", "archctx import structurizr --content '<json>'", "archctx tunnel"]
           }
         };
     }
@@ -10811,7 +11834,7 @@ async function runGithubCommand(args2, cwd, deps) {
     tokenStore.clear(record.codeVerifierRef);
     tokenStore.clear(record.refreshTokenRef);
     keyStore.removeDevicePrivateKey(record.deviceKey.keyRef);
-    rmSync8(connectionPath, { force: true });
+    rmSync9(connectionPath, { force: true });
     return okEnvelope("github.disconnect", {
       disconnected: true,
       connected: false,
@@ -11094,20 +12117,20 @@ function defaultGithubDeveloperReviewStatePath(cwd, pullRequestNumber) {
 }
 async function writeGithubDeveloperReviewState(cwd, state) {
   const path = defaultGithubDeveloperReviewStatePath(cwd, state.challenge.pullRequestNumber);
-  mkdirSync8(dirname9(path), { recursive: true });
+  mkdirSync9(dirname9(path), { recursive: true });
   const serialized = `${JSON.stringify(state, null, 2)}
 `;
   assertNoCliSecretMaterial(serialized);
-  writeFileSync5(path, serialized, { mode: 384 });
+  writeFileSync7(path, serialized, { mode: 384 });
   if (process.platform !== "win32")
-    chmodSync3(path, 384);
+    chmodSync5(path, 384);
   return { state, path };
 }
 function readGithubDeveloperReviewState(path) {
-  if (!existsSync10(path))
+  if (!existsSync11(path))
     return;
   try {
-    const parsed = JSON.parse(readFileSync9(path, "utf8"));
+    const parsed = JSON.parse(readFileSync11(path, "utf8"));
     if (parsed.schemaVersion !== "archcontext.github-developer-review-state/v1")
       return;
     if (!parsed.challenge || typeof parsed.challenge.pullRequestNumber !== "number")
@@ -11156,10 +12179,10 @@ function defaultGithubConnectionPath(cwd) {
   return join8(dirname9(defaultDaemonConnectionPath(cwd)), "github-connection.json");
 }
 function readGithubConnection(path) {
-  if (!existsSync10(path))
+  if (!existsSync11(path))
     return;
   try {
-    const parsed = JSON.parse(readFileSync9(path, "utf8"));
+    const parsed = JSON.parse(readFileSync11(path, "utf8"));
     if (parsed.schemaVersion !== "archcontext.github-connection/v1" || parsed.status !== "connected")
       return;
     return parsed;
@@ -11168,13 +12191,13 @@ function readGithubConnection(path) {
   }
 }
 function writeGithubConnection(path, record) {
-  mkdirSync8(dirname9(path), { recursive: true });
+  mkdirSync9(dirname9(path), { recursive: true });
   const serialized = `${JSON.stringify(record, null, 2)}
 `;
   assertNoCliSecretMaterial(serialized);
-  writeFileSync5(path, serialized, { mode: 384 });
+  writeFileSync7(path, serialized, { mode: 384 });
   if (process.platform !== "win32")
-    chmodSync3(path, 384);
+    chmodSync5(path, 384);
 }
 function sanitizeGithubConnection(record, connectionPath) {
   return {
@@ -11203,7 +12226,7 @@ async function readReviewChallengeV2Arg(args2, cwd, commandName = "github verify
   if (!inline && !challengePath)
     return { ok: false, message: `${commandName} requires --challenge-json or --challenge-path` };
   try {
-    const raw = inline ?? readFileSync9(resolve14(cwd, challengePath), "utf8");
+    const raw = inline ?? readFileSync11(resolve14(cwd, challengePath), "utf8");
     const parsed = JSON.parse(raw);
     const attestation = await Promise.resolve().then(() => (init_src7(), exports_src3));
     const assertReviewChallengeV23 = attestation.assertReviewChallengeV2;
@@ -11286,6 +12309,7 @@ function agentHostRemoveConfig(host) {
 }
 async function doctorReport(cwd) {
   const product = productVersionManifest();
+  const paths = runtimePathsReport(cwd);
   const daemon = await doctorDaemon(cwd);
   const git = doctorGit(cwd);
   const sqlite = doctorSqlite(cwd);
@@ -11303,6 +12327,7 @@ async function doctorReport(cwd) {
     },
     daemon,
     sqlite,
+    paths,
     codeGraph: product.runtime.codeGraph,
     git,
     permissions,
@@ -11350,23 +12375,46 @@ function doctorGit(cwd) {
   }
 }
 function doctorSqlite(cwd) {
-  const path = defaultLocalStorePath(cwd);
+  const paths = runtimeStatePaths(cwd);
+  const path = paths.localStorePath;
+  const legacyLocalStore = inspectLegacyLocalStoreMigration(cwd);
   return {
     path,
-    exists: existsSync10(path),
-    migrations: productVersionManifest().runtime.sqliteMigrations
+    exists: existsSync11(path),
+    migrations: productVersionManifest().runtime.sqliteMigrations,
+    legacyPath: paths.legacyLocalStorePath,
+    legacyExists: existsSync11(paths.legacyLocalStorePath),
+    legacyLocalStore
   };
 }
 function doctorPermissions(cwd) {
+  const paths = runtimeStatePaths(cwd);
   const controlDir = dirname9(defaultDaemonConnectionPath(cwd));
   return {
     workspace: pathAccess(cwd),
+    stateRoot: pathAccess(paths.stateRoot),
+    runtimeStateDir: pathAccess(paths.workspaceStateDir),
     controlDir: pathAccess(controlDir),
     sqlite: pathAccess(defaultLocalStorePath(cwd))
   };
 }
+function runtimePathsReport(cwd) {
+  const paths = runtimeStatePaths(cwd);
+  return {
+    ...paths,
+    legacyLocalStore: inspectLegacyLocalStoreMigration(cwd),
+    runtimeRepositoryId: repositoryFingerprint(paths.repositoryRoot),
+    repositoryTruthDir: join8(paths.repositoryRoot, ".archcontext"),
+    codeGraphIndexDir: join8(paths.repositoryRoot, ".codegraph"),
+    npmGlobalInstallState: "forbidden",
+    overrides: {
+      stateRootEnv: "ARCHCONTEXT_STATE_DIR",
+      localStorePathEnv: "ARCHCONTEXT_LOCAL_STORE_PATH"
+    }
+  };
+}
 function pathAccess(path) {
-  const exists = existsSync10(path);
+  const exists = existsSync11(path);
   return {
     path,
     exists,
@@ -11442,6 +12490,8 @@ async function createCliRuntime(cwd, deps) {
     githubReviewSubmissionPort: _githubReviewSubmissionPort,
     ...runtimeDeps
   } = deps;
+  if (!runtimeDeps.localStorePath)
+    migrateLegacyLocalStoreIfNeeded(cwd);
   const daemon = await createStartedDaemon({
     localStorePath: defaultLocalStorePath(cwd),
     ...runtimeDeps,
@@ -11544,8 +12594,8 @@ async function startBackgroundDaemon(args2, cwd) {
   const connectionPath = defaultDaemonConnectionPath(cwd);
   const controlDir = dirname9(connectionPath);
   const logPath = join8(controlDir, "archctxd.log");
-  mkdirSync8(controlDir, { recursive: true });
-  const logFd = openSync6(logPath, "a", 384);
+  mkdirSync9(controlDir, { recursive: true });
+  const logFd = openSync7(logPath, "a", 384);
   try {
     const child = spawn(process.execPath, [
       CLI_ENTRY,
@@ -11563,7 +12613,7 @@ async function startBackgroundDaemon(args2, cwd) {
     child.unref();
     const ready = await waitForDaemonReady(cwd, Number(readFlag(args2, "--timeout-ms") ?? DAEMON_START_TIMEOUT_MS));
     if (!ready) {
-      return errorEnvelope("daemon.start", "AC_RUNTIME_UNAVAILABLE", `archctxd did not become ready; log=${logPath}`);
+      return errorEnvelope("daemon.start", "AC_RUNTIME_UNAVAILABLE", `archctxd did not become ready; log=${logPath}; logTail=${readFileTail(logPath)}`);
     }
     return okEnvelope("daemon.start", {
       running: true,
@@ -11575,7 +12625,7 @@ async function startBackgroundDaemon(args2, cwd) {
       ...recoveryData(recovery)
     });
   } finally {
-    closeSync6(logFd);
+    closeSync7(logFd);
   }
 }
 async function upgradeDaemon(args2, cwd) {
@@ -11712,8 +12762,16 @@ async function waitForDaemonReady(cwd, timeoutMs) {
 function sleep(ms) {
   return new Promise((resolve15) => setTimeout(resolve15, ms));
 }
+function readFileTail(path, maxBytes = 4096) {
+  try {
+    const content = readFileSync11(path, "utf8");
+    return content.slice(Math.max(0, content.length - maxBytes)).replace(/\s+/g, " ").trim();
+  } catch {
+    return "<unavailable>";
+  }
+}
 async function runForegroundDaemon(cwd, args2) {
-  const daemon = await createStartedProductionDaemon({ root: cwd, localStorePath: defaultLocalStorePath(cwd) });
+  const daemon = await createStartedProductionDaemon({ root: cwd });
   let resolveStopped;
   const stopped = new Promise((resolve15) => {
     resolveStopped = resolve15;