@hasna/instructions 0.6.1 → 0.7.0

package/dist/index.js

@@ -16,7 +16,7 @@ var __export = (target, all) => {
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 
 // src/types/index.ts
-var CONFIG_KINDS, CONFIG_CATEGORIES, CONFIG_AGENTS, CONFIG_TRANSFORMS, CONFIG_FORMATS, PROFILE_CONFIG_BINDING_SCHEMA = "hasna.instructions.profile-config-binding/v1", INSTRUCTION_ACTIVATION_MODES, INSTRUCTION_FALLBACKS, PROFILE_ASSET_BINDING_SCHEMA = "hasna.instructions.profile-asset-binding/v1", ASSET_KINDS, ASSET_DESTINATION_STRATEGIES, ASSET_SCOPES, ASSET_UNINSTALL_POLICIES, ASSET_ROLLBACK_POLICIES, ConfigNotFoundError, ProfileNotFoundError, ConfigApplyError, TemplateRenderError;
+var CONFIG_KINDS, CONFIG_CATEGORIES, CONFIG_AGENTS, CONFIG_TRANSFORMS, CONFIG_FORMATS, PROFILE_CONFIG_BINDING_SCHEMA = "hasna.instructions.profile-config-binding/v1", INSTRUCTION_ACTIVATION_MODES, INSTRUCTION_FALLBACKS, PROFILE_ASSET_BINDING_SCHEMA = "hasna.instructions.profile-asset-binding/v1", ASSET_KINDS, ASSET_DESTINATION_STRATEGIES, ASSET_SCOPES, ASSET_UNINSTALL_POLICIES, ASSET_ROLLBACK_POLICIES, INSTRUCTIONS_DOMAIN_ARCHIVE_SCHEMA = "hasna.instructions.domain-archive/v2", ConfigNotFoundError, ProfileNotFoundError, ConfigApplyError, TemplateRenderError;
 var init_types = __esm(() => {
   CONFIG_KINDS = ["file", "reference"];
   CONFIG_CATEGORIES = [
@@ -108,9 +108,9 @@ function parseCursor(value) {
   const parsed = typeof value === "number" ? value : Number.parseInt(String(value ?? ""), 10);
   if (!Number.isFinite(parsed) || parsed < 0)
     return 0;
-  return Math.floor(parsed);
+  return Math.min(Math.floor(parsed), MAX_LIST_CURSOR);
 }
-var DEFAULT_LIST_LIMIT = 20, MAX_LIST_LIMIT = 100;
+var DEFAULT_LIST_LIMIT = 20, MAX_LIST_LIMIT = 100, MAX_LIST_CURSOR = 1e5;
 
 // src/lib/bounded-read.ts
 function normalizeBoundedReadOptions(options = {}) {
@@ -10925,7 +10925,7 @@ var init_instruction_graph = __esm(() => {
   };
 });
 
-// ../contracts/dist/client/transport.js
+// ../../node_modules/.bun/@hasna+contracts@1.0.2+e8014c875821e0be/node_modules/@hasna/contracts/dist/client/transport.js
 import { isIP } from "net";
 import { spawnSync } from "child_process";
 import { closeSync as closeSync2, fstatSync as fstatSync2, openSync as openSync2, readFileSync as readFileSync5 } from "fs";
@@ -11658,7 +11658,7 @@ var init_transport = __esm(() => {
   ]);
 });
 
-// ../contracts/dist/client/storage.js
+// ../../node_modules/.bun/@hasna+contracts@1.0.2+e8014c875821e0be/node_modules/@hasna/contracts/dist/client/storage.js
 import { isIP as isIP2 } from "net";
 import { spawnSync as spawnSync2 } from "child_process";
 import { closeSync as closeSync3, fstatSync as fstatSync3, openSync as openSync3, readFileSync as readFileSync6 } from "fs";
@@ -13876,11 +13876,11 @@ var init_local = __esm(() => {
 
 // src/data/config-store.ts
 import { randomUUID as randomUUID3 } from "crypto";
-function parseBoundedPagePayload(value, label) {
+function parseBoundedPagePayload(value, label, expected) {
   const page = value;
   const consumed = Number(page?.cursor) + (page?.items?.length ?? 0);
   const complete = Boolean(page && Number.isSafeInteger(page.total) && consumed >= Number(page.total));
-  if (!page || !Array.isArray(page.items) || !Number.isSafeInteger(page.total) || Number(page.total) < 0 || !Number.isSafeInteger(page.limit) || Number(page.limit) < 1 || !Number.isSafeInteger(page.cursor) || Number(page.cursor) < 0 || page.items.length > Number(page.limit) || typeof page.has_more !== "boolean" || typeof page.complete !== "boolean" || page.truncated !== false || page.next_cursor !== null && !Number.isSafeInteger(page.next_cursor) || page.complete !== complete || page.has_more !== !complete || page.next_cursor !== (complete ? null : consumed)) {
+  if (!page || !Array.isArray(page.items) || !Number.isSafeInteger(page.total) || Number(page.total) < 0 || !Number.isSafeInteger(page.limit) || Number(page.limit) < 1 || !Number.isSafeInteger(page.cursor) || Number(page.cursor) < 0 || page.items.length > Number(page.limit) || typeof page.has_more !== "boolean" || typeof page.complete !== "boolean" || page.truncated !== false || page.next_cursor !== null && !Number.isSafeInteger(page.next_cursor) || page.complete !== complete || page.has_more !== !complete || page.next_cursor !== (complete ? null : consumed) || expected !== undefined && Number(page.cursor) !== expected.cursor) {
     throw new Error(`${label} returned an invalid or truncated bounded-read envelope`);
   }
   return {
@@ -13892,7 +13892,7 @@ function parseBoundedOrLegacyPage(value, legacyItems, options, label) {
   if (value && typeof value === "object") {
     const candidate = value;
     if ("items" in candidate || "total" in candidate || "complete" in candidate || "truncated" in candidate || "next_cursor" in candidate) {
-      return parseBoundedPagePayload(value, label);
+      return parseBoundedPagePayload(value, label, normalizeBoundedReadOptions(options));
     }
   }
   if (!Array.isArray(legacyItems)) {
@@ -13902,6 +13902,57 @@ function parseBoundedOrLegacyPage(value, legacyItems, options, label) {
   const page = boundedReadPage(legacyItems.slice(normalized.cursor, normalized.cursor + normalized.limit), legacyItems.length, normalized);
   return { ...page, source_bounded: false };
 }
+async function aggregateBoundedCollection(label, readPage, identity, options = {}) {
+  let lastError = null;
+  for (let attempt = 0;attempt < COLLECTION_READ_ATTEMPTS; attempt += 1) {
+    try {
+      const items = [];
+      const seen = new Set;
+      let expectedTotal = null;
+      let cursor = 0;
+      let previousIdentity = null;
+      while (true) {
+        const page = await readPage(cursor);
+        if (page.cursor !== cursor) {
+          throw new CollectionChangedWhilePagingError(label, `server returned cursor ${page.cursor} for requested cursor ${cursor}`);
+        }
+        if (expectedTotal === null)
+          expectedTotal = page.total;
+        else if (page.total !== expectedTotal) {
+          throw new CollectionChangedWhilePagingError(label, `total changed from ${expectedTotal} to ${page.total}`);
+        }
+        for (const item of page.items) {
+          const key = identity(item);
+          if (!key)
+            throw new CollectionChangedWhilePagingError(label, "an item had no stable identity");
+          if (seen.has(key))
+            throw new CollectionChangedWhilePagingError(label, `duplicate identity ${key}`);
+          if (options.requireAscendingIdentity && page.source_bounded && previousIdentity !== null && key <= previousIdentity) {
+            throw new CollectionChangedWhilePagingError(label, `identity order was not strictly increasing at ${key}`);
+          }
+          seen.add(key);
+          previousIdentity = key;
+          items.push(item);
+        }
+        if (page.complete) {
+          if (items.length !== expectedTotal) {
+            throw new CollectionChangedWhilePagingError(label, `received ${items.length} unique rows for total ${expectedTotal}`);
+          }
+          return items;
+        }
+        if (page.next_cursor === null || page.next_cursor <= cursor) {
+          throw new CollectionChangedWhilePagingError(label, `cursor did not advance from ${cursor}`);
+        }
+        cursor = page.next_cursor;
+      }
+    } catch (error) {
+      if (!(error instanceof CollectionChangedWhilePagingError))
+        throw error;
+      lastError = error;
+    }
+  }
+  throw lastError ?? new CollectionChangedWhilePagingError(label, "read did not stabilize");
+}
 function isLocalOptIn(env = process.env) {
   return isInstructionsLocalOptIn(env);
 }
@@ -13980,15 +14031,7 @@ class LocalConfigStore {
     return (await localStoreModule()).pruneSnapshots(configId, keep, this.db);
   }
   async listProfiles() {
-    const profiles = [];
-    let cursor = 0;
-    while (true) {
-      const page = await this.listProfilesPage({ limit: 100, cursor });
-      profiles.push(...page.items);
-      if (page.complete)
-        return profiles;
-      cursor = page.next_cursor;
-    }
+    return aggregateBoundedCollection("profile list", (cursor) => this.listProfilesPage({ limit: 100, cursor }), (profile) => profile.id);
   }
   async listProfilesPage(options = {}) {
     return (await localStoreModule()).listProfilesPage(options, this.db);
@@ -13997,15 +14040,7 @@ class LocalConfigStore {
     return (await localStoreModule()).getProfile(idOrSlug, this.db);
   }
   async getProfileConfigs(idOrSlug) {
-    const configs = [];
-    let cursor = 0;
-    while (true) {
-      const page = await this.getProfileConfigsPage(idOrSlug, { limit: 100, cursor });
-      configs.push(...page.items);
-      if (page.complete)
-        return configs;
-      cursor = page.next_cursor;
-    }
+    return aggregateBoundedCollection("profile membership", (cursor) => this.getProfileConfigsPage(idOrSlug, { limit: 100, cursor }), (config) => config.id);
   }
   async getProfileConfigsPage(idOrSlug, options = {}) {
     return (await localStoreModule()).getProfileConfigsPage(idOrSlug, options, this.db);
@@ -14086,7 +14121,8 @@ class CloudConfigStore {
       throw err;
     }
   }
-  async listConfigs(filter = {}) {
+  async listConfigsPageRemote(filter, options) {
+    const normalized = normalizeBoundedReadOptions(options);
     const params = new URLSearchParams;
     if (filter.category)
       params.set("category", filter.category);
@@ -14096,16 +14132,21 @@ class CloudConfigStore {
       params.set("kind", filter.kind);
     if (filter.search)
       params.set("search", filter.search);
-    const qs = params.toString();
-    const { data } = await this.request("GET", `/configs${qs ? `?${qs}` : ""}`);
-    let configs = data?.configs ?? [];
+    params.set("limit", String(normalized.limit));
+    params.set("cursor", String(normalized.cursor));
+    const { data } = await this.request("GET", `/configs?${params.toString()}`);
+    return parseBoundedOrLegacyPage(data, data?.configs, normalized, "config list");
+  }
+  async listConfigs(filter = {}) {
+    const configs = await aggregateBoundedCollection("config list", (cursor) => this.listConfigsPageRemote(filter, { limit: 100, cursor }), (config) => config.id, { requireAscendingIdentity: true });
+    let filtered = configs;
     if (filter.tags && filter.tags.length > 0) {
-      configs = configs.filter((c) => filter.tags.every((t) => c.tags.includes(t)));
+      filtered = filtered.filter((config) => filter.tags.every((tag) => config.tags.includes(tag)));
     }
     if (filter.is_template !== undefined) {
-      configs = configs.filter((c) => c.is_template === filter.is_template);
+      filtered = filtered.filter((config) => config.is_template === filter.is_template);
     }
-    return configs;
+    return filtered;
   }
   async getConfig(idOrSlug) {
     const { status, data } = await this.request("GET", `/configs/${encodeURIComponent(idOrSlug)}`, undefined, { allow404: true });
@@ -14136,8 +14177,11 @@ class CloudConfigStore {
     return data ?? { total: 0 };
   }
   async listSnapshots(configId) {
-    const { data } = await this.request("GET", `/configs/${encodeURIComponent(configId)}/snapshots`);
-    return data?.snapshots ?? [];
+    return aggregateBoundedCollection("snapshot list", async (cursor) => {
+      const normalized = normalizeBoundedReadOptions({ limit: 100, cursor });
+      const { data } = await this.request("GET", `/configs/${encodeURIComponent(configId)}/snapshots?limit=${normalized.limit}&cursor=${normalized.cursor}`);
+      return parseBoundedOrLegacyPage(data, data?.snapshots, normalized, "snapshot list");
+    }, (snapshot) => snapshot.id);
   }
   async getSnapshot(id) {
     const { status, data } = await this.request("GET", `/snapshots/${encodeURIComponent(id)}`, undefined, { allow404: true });
@@ -14160,15 +14204,7 @@ class CloudConfigStore {
     return data?.pruned ?? 0;
   }
   async listProfiles() {
-    const profiles = [];
-    let cursor = 0;
-    while (true) {
-      const page = await this.listProfilesPage({ limit: 100, cursor });
-      profiles.push(...page.items);
-      if (page.complete)
-        return profiles;
-      cursor = page.next_cursor;
-    }
+    return aggregateBoundedCollection("profile list", (cursor) => this.listProfilesPage({ limit: 100, cursor }), (profile) => profile.id, { requireAscendingIdentity: true });
   }
   async listProfilesPage(options = {}) {
     const normalized = normalizeBoundedReadOptions(options);
@@ -14192,15 +14228,7 @@ class CloudConfigStore {
     return profile;
   }
   async getProfileConfigs(idOrSlug) {
-    const configs = [];
-    let cursor = 0;
-    while (true) {
-      const page = await this.getProfileConfigsPage(idOrSlug, { limit: 100, cursor });
-      configs.push(...page.items);
-      if (page.complete)
-        return configs;
-      cursor = page.next_cursor;
-    }
+    return aggregateBoundedCollection("profile membership", (cursor) => this.getProfileConfigsPage(idOrSlug, { limit: 100, cursor }), (config) => config.id);
   }
   async getProfileConfigsPage(idOrSlug, options = {}) {
     const normalized = normalizeBoundedReadOptions(options);
@@ -14214,20 +14242,26 @@ class CloudConfigStore {
     return parseBoundedOrLegacyPage(data.configs, data.profile.configs, normalized, "profile membership");
   }
   async getProfileConfigBindings(idOrSlug) {
-    const { status, data } = await this.requestProfileRoute(idOrSlug, (profileId) => `/profiles/${encodeURIComponent(profileId)}/bindings`, (value) => Array.isArray(value?.bindings));
-    if (status === 404) {
-      const profile = await this.getProfile(idOrSlug);
-      const configs = await this.getProfileConfigs(idOrSlug);
-      return configs.map((config, sort_order) => ({
-        profile_id: profile.id,
-        config_id: config.id,
-        sort_order,
-        binding: legacyProfileConfigBinding()
-      }));
-    }
-    if (!data || !Array.isArray(data.bindings))
-      throw new ProfileNotFoundError(idOrSlug);
-    return data.bindings;
+    let routeMissing = false;
+    const bindings = await aggregateBoundedCollection("profile config bindings", async (cursor) => {
+      const normalized = normalizeBoundedReadOptions({ limit: 100, cursor });
+      const { status, data } = await this.requestProfileRoute(idOrSlug, (profileId) => `/profiles/${encodeURIComponent(profileId)}/bindings?limit=${normalized.limit}&cursor=${normalized.cursor}`, (value) => Boolean(value && (Array.isArray(value.bindings) || Array.isArray(value.items))));
+      if (status === 404) {
+        routeMissing = true;
+        return { ...boundedReadPage([], 0, normalized), source_bounded: false };
+      }
+      return parseBoundedOrLegacyPage(data, data?.bindings, normalized, "profile config bindings");
+    }, (binding) => `${binding.profile_id}\x00${binding.config_id}`);
+    if (!routeMissing)
+      return bindings;
+    const profile = await this.getProfile(idOrSlug);
+    const configs = await this.getProfileConfigs(idOrSlug);
+    return configs.map((config, sort_order) => ({
+      profile_id: profile.id,
+      config_id: config.id,
+      sort_order,
+      binding: legacyProfileConfigBinding()
+    }));
   }
   async requestProfileRoute(idOrSlug, pathForId, isUsable) {
     const attempted = new Set;
@@ -14285,14 +14319,20 @@ class CloudConfigStore {
     await this.request("DELETE", `/profiles/${encodeURIComponent(profileIdOrSlug)}/configs/${encodeURIComponent(configId)}`, undefined, { allow404: true });
   }
   async getProfileAssetBindings(profileIdOrSlug) {
-    const { status, data } = await this.requestProfileRoute(profileIdOrSlug, (profileId) => `/profiles/${encodeURIComponent(profileId)}/assets`, (value) => Array.isArray(value?.assets));
-    if (status === 404) {
-      await this.getProfile(profileIdOrSlug);
-      return [];
-    }
-    if (!data || !Array.isArray(data.assets))
-      throw new ProfileNotFoundError(profileIdOrSlug);
-    return data.assets;
+    let routeMissing = false;
+    const assets = await aggregateBoundedCollection("profile asset bindings", async (cursor) => {
+      const normalized = normalizeBoundedReadOptions({ limit: 100, cursor });
+      const { status, data } = await this.requestProfileRoute(profileIdOrSlug, (profileId) => `/profiles/${encodeURIComponent(profileId)}/assets?limit=${normalized.limit}&cursor=${normalized.cursor}`, (value) => Boolean(value && (Array.isArray(value.assets) || Array.isArray(value.items))));
+      if (status === 404) {
+        routeMissing = true;
+        return { ...boundedReadPage([], 0, normalized), source_bounded: false };
+      }
+      return parseBoundedOrLegacyPage(data, data?.assets, normalized, "profile asset bindings");
+    }, (asset) => `${asset.profile_id}\x00${asset.binding.assetKey}`);
+    if (!routeMissing)
+      return assets;
+    await this.getProfile(profileIdOrSlug);
+    return [];
   }
   async addAssetToProfile(profileIdOrSlug, sourceConfigId, binding) {
     const { data } = await this.request("POST", `/profiles/${encodeURIComponent(profileIdOrSlug)}/assets`, { source_config_id: sourceConfigId, binding }, { idempotent: true });
@@ -14362,8 +14402,11 @@ class CloudConfigStore {
     await this.request("POST", "/machines/applied", { hostname: hostname2 });
   }
   async listMachines() {
-    const { data } = await this.request("GET", "/machines");
-    return data?.machines ?? [];
+    return aggregateBoundedCollection("machine list", async (cursor) => {
+      const normalized = normalizeBoundedReadOptions({ limit: 100, cursor });
+      const { data } = await this.request("GET", `/machines?limit=${normalized.limit}&cursor=${normalized.cursor}`);
+      return parseBoundedOrLegacyPage(data, data?.machines, normalized, "machine list");
+    }, (machine) => machine.id, { requireAscendingIdentity: true });
   }
   async sendFeedback(input) {
     await this.request("POST", "/feedback", {
@@ -14386,13 +14429,19 @@ function resolveConfigStore(env = process.env, options = {}) {
   const { client } = resolveInstructionsStorageClient(env, options);
   return new CloudConfigStore(client);
 }
-var LOCAL_OPT_IN_ENV, localStoreModulePromise = null;
+var CollectionChangedWhilePagingError, COLLECTION_READ_ATTEMPTS = 2, LOCAL_OPT_IN_ENV, localStoreModulePromise = null;
 var init_config_store = __esm(() => {
   init_types();
   init_bounded_read();
   init_instruction_graph();
   init_transport_resolver();
   init_local_opt_in();
+  CollectionChangedWhilePagingError = class CollectionChangedWhilePagingError extends Error {
+    constructor(label, detail) {
+      super(`${label} changed while paging: ${detail}`);
+      this.name = "CollectionChangedWhilePagingError";
+    }
+  };
   LOCAL_OPT_IN_ENV = INSTRUCTIONS_LOCAL_OPT_IN_ENV;
 });
 
@@ -14415,7 +14464,7 @@ init_config_agents();
 init_machine();
 init_session_render();
 import { existsSync as existsSync9, mkdirSync as mkdirSync3, readFileSync as readFileSync8, realpathSync as realpathSync3, writeFileSync as writeFileSync2 } from "fs";
-import { basename as basename5, dirname as dirname6, join as join12, resolve as resolve9 } from "path";
+import { basename as basename5, dirname as dirname6, isAbsolute as isAbsolute6, join as join12, relative as relative4, resolve as resolve9, sep as sep2 } from "path";
 import { homedir as homedir7 } from "os";
 
 // src/lib/session-render-ownership.ts
@@ -14504,6 +14553,17 @@ function expandPath(p) {
   }
   return resolve9(p);
 }
+function compactPathForConfigHome(p) {
+  const absolute = resolve9(p);
+  const configHome = resolve9(getConfigHome());
+  const conventionalHome = resolve9(process.env["HOME"] || homedir7());
+  if (configHome !== conventionalHome)
+    return absolute;
+  const rel = relative4(configHome, absolute);
+  if (!rel || rel === ".." || rel.startsWith(`..${sep2}`) || isAbsolute6(rel))
+    return absolute;
+  return `~/${rel}`;
+}
 function normalizeTargetPath(p) {
   const expanded = expandPath(p);
   try {
@@ -14957,7 +15017,7 @@ import {
   writeFileSync as writeFileSync3
 } from "fs";
 import { homedir as homedir8 } from "os";
-import { dirname as dirname8, join as join14, parse as parse4, relative as relative4, resolve as resolve10 } from "path";
+import { dirname as dirname8, join as join14, parse as parse4, relative as relative5, resolve as resolve10 } from "path";
 var INBOX_CONVERSATIONS_MINIMUM_VERSION = "0.5.28";
 var INBOX_SKILL_MARKERS = [
   [".claude", "skills", "inbox", "SKILL.md"],
@@ -14981,7 +15041,7 @@ function findSymlinkedAncestor(path) {
   const normalized = resolve10(path);
   const parsed = parse4(normalized);
   let current = parsed.root;
-  const rel = relative4(parsed.root, normalized);
+  const rel = relative5(parsed.root, normalized);
   for (const segment of rel.split(/[\\/]+/).filter(Boolean)) {
     current = join14(current, segment);
     if (!existsSync11(current))
@@ -15000,16 +15060,7 @@ function assertNoSymlinkAncestors2(path) {
 function packagedInboxSkillPath(explicitPath) {
   if (explicitPath)
     return explicitPath;
-  const candidates = [
-    join14(import.meta.dir, "..", "..", "assets", "skills", "inbox", "SKILL.md"),
-    join14(import.meta.dir, "..", "assets", "skills", "inbox", "SKILL.md"),
-    join14(process.cwd(), "assets", "skills", "inbox", "SKILL.md")
-  ];
-  const found = candidates.find((candidate) => existsSync11(candidate));
-  if (!found) {
-    throw new Error(`packaged inbox skill contract is missing (checked ${candidates.length} package-relative locations)`);
-  }
-  return found;
+  throw new Error("Bundled skill contracts are retired; use the Skills CLI to manage private skills");
 }
 function readCanonicalSkill(explicitPath) {
   const assetPath = packagedInboxSkillPath(explicitPath);
@@ -16028,7 +16079,7 @@ import {
   readdirSync as readdirSync3,
   statSync as statSync5
 } from "fs";
-import { dirname as dirname10, isAbsolute as isAbsolute6, join as join17, parse as parse5, relative as relative5, resolve as resolve11 } from "path";
+import { dirname as dirname10, isAbsolute as isAbsolute7, join as join17, parse as parse5, relative as relative6, resolve as resolve11 } from "path";
 
 class SessionApplyError extends Error {
   constructor(message) {
@@ -16166,7 +16217,7 @@ function ensureSessionTargetHome(targetHome) {
 }
 function checkSessionRenderDrift(targetHome, manifestPath) {
   const safeTargetHome = assertSafeTargetHome(targetHome);
-  const resolvedManifestPath = manifestPath ? resolveManifestRelativePath(relative5(safeTargetHome, resolve11(manifestPath)), safeTargetHome) : resolve11(safeTargetHome, ".hasna", "session-render-manifest.json");
+  const resolvedManifestPath = manifestPath ? resolveManifestRelativePath(relative6(safeTargetHome, resolve11(manifestPath)), safeTargetHome) : resolve11(safeTargetHome, ".hasna", "session-render-manifest.json");
   const checkedAt = new Date().toISOString();
   const previousManifest = readPreviousManifest(resolvedManifestPath);
   if (!previousManifest) {
@@ -16218,11 +16269,11 @@ function restoreSessionRenderSnapshot(snapshotPath, options = {}) {
   const targetHome = assertSafeTargetHome(snapshot.targetHome);
   const resolvedSnapshotPath = resolve11(snapshotPath);
   const snapshotDir = getSessionRenderSnapshotDir(targetHome);
-  const snapshotDirRelative = relative5(snapshotDir, resolvedSnapshotPath);
-  const insideSnapshotDir = snapshotDirRelative !== ".." && !snapshotDirRelative.startsWith("../") && !isAbsolute6(snapshotDirRelative);
+  const snapshotDirRelative = relative6(snapshotDir, resolvedSnapshotPath);
+  const insideSnapshotDir = snapshotDirRelative !== ".." && !snapshotDirRelative.startsWith("../") && !isAbsolute7(snapshotDirRelative);
   if (!insideSnapshotDir) {
-    const snapshotRelativePath = relative5(targetHome, resolvedSnapshotPath);
-    if (snapshotRelativePath === "" || snapshotRelativePath === ".." || snapshotRelativePath.startsWith("../") || isAbsolute6(snapshotRelativePath)) {
+    const snapshotRelativePath = relative6(targetHome, resolvedSnapshotPath);
+    if (snapshotRelativePath === "" || snapshotRelativePath === ".." || snapshotRelativePath.startsWith("../") || isAbsolute7(snapshotRelativePath)) {
       throw new SessionApplyError("Session snapshot must be stored inside its session-render snapshot location.");
     }
   }
@@ -16421,7 +16472,7 @@ function readSessionRenderSnapshot(snapshotPath) {
 function reconstructPreRollbackLegacyV1Snapshot(snapshot, previousFiles, previousManifestFiles, targetHome, snapshotPath) {
   assertNoNewerSessionSnapshot(snapshotPath, snapshot.createdAt, targetHome);
   const manifestPath = resolve11(snapshot.manifestPath);
-  const manifestRelativePath = relative5(targetHome, manifestPath).replaceAll("\\", "/");
+  const manifestRelativePath = relative6(targetHome, manifestPath).replaceAll("\\", "/");
   resolveSnapshotFilePath(manifestRelativePath, snapshot.manifestPath, targetHome);
   const manifestSha256 = currentSessionFileHash(manifestPath, targetHome);
   if (manifestSha256 === null) {
@@ -16754,8 +16805,8 @@ function isPreviouslyManaged(file, previousSha256, previousHashes, previousManif
 }
 function resolvePlannedFilePath(plan, file, targetHome) {
   const target = resolve11(targetHome, ...file.relativePath.split("/"));
-  const rel = relative5(targetHome, target);
-  if (rel === "" || rel === ".." || rel.startsWith("../") || isAbsolute6(rel)) {
+  const rel = relative6(targetHome, target);
+  if (rel === "" || rel === ".." || rel.startsWith("../") || isAbsolute7(rel)) {
     throw new SessionApplyError(`Session file escapes target home: ${file.relativePath}`);
   }
   if (resolve11(file.path) !== target) {
@@ -16766,8 +16817,8 @@ function resolvePlannedFilePath(plan, file, targetHome) {
 }
 function resolveManifestRelativePath(relativePath, targetHome) {
   const target = resolve11(targetHome, ...relativePath.split(/[\\/]+/));
-  const rel = relative5(targetHome, target);
-  if (rel === "" || rel === ".." || rel.startsWith("../") || isAbsolute6(rel)) {
+  const rel = relative6(targetHome, target);
+  if (rel === "" || rel === ".." || rel.startsWith("../") || isAbsolute7(rel)) {
     throw new SessionApplyError(`Session manifest file escapes target home: ${relativePath}`);
   }
   assertNoSymlinkSegments2(targetHome, target);
@@ -16811,7 +16862,7 @@ function applyPlannedFile(plan, file, targetHome, resultsByPath, coordination, a
 function assertExpectedSessionFileHash(path, targetHome, expectedHash) {
   const actualHash = currentSessionFileHash(path, targetHome);
   if (actualHash !== expectedHash) {
-    throw new SessionApplyError(`Session apply path changed after planning: ${relative5(targetHome, path)}`);
+    throw new SessionApplyError(`Session apply path changed after planning: ${relative6(targetHome, path)}`);
   }
 }
 function currentSessionFileHash(path, targetHome) {
@@ -16896,7 +16947,7 @@ function writeSessionSnapshot(plan, targetHome, manifestPath, results, previousM
   };
 }
 function assertSafeTargetHome(targetHome) {
-  if (!isAbsolute6(targetHome))
+  if (!isAbsolute7(targetHome))
     throw new SessionApplyError(`Session target home must be absolute: ${targetHome}`);
   const normalized = resolve11(targetHome);
   if (normalized === parse5(normalized).root) {
@@ -16910,7 +16961,7 @@ function assertSafeTargetHome(targetHome) {
 }
 function assertNoSymlinkSegments2(root, target) {
   assertNoSymlinkAncestors3(root);
-  const rel = relative5(root, target);
+  const rel = relative6(root, target);
   let current = root;
   for (const segment of rel.split(/[\\/]+/).filter(Boolean)) {
     current = join17(current, segment);
@@ -16923,7 +16974,7 @@ function assertNoSymlinkAncestors3(path) {
   const normalized = resolve11(path);
   const parsed = parse5(normalized);
   let current = parsed.root;
-  const rel = relative5(parsed.root, normalized);
+  const rel = relative6(parsed.root, normalized);
   for (const segment of rel.split(/[\\/]+/).filter(Boolean)) {
     current = join17(current, segment);
     if (!existsSync15(current))
@@ -17268,8 +17319,7 @@ init_transforms();
 // src/lib/sync-dir.ts
 init_config_store();
 import { existsSync as existsSync16, readdirSync as readdirSync4, readFileSync as readFileSync15, statSync as statSync6 } from "fs";
-import { join as join18, relative as relative6 } from "path";
-import { homedir as homedir10 } from "os";
+import { join as join18, relative as relative7 } from "path";
 init_redact();
 var SKIP = [".db", ".db-shm", ".db-wal", ".log", ".lock", ".DS_Store", "node_modules", ".git"];
 function shouldSkip(p) {
@@ -17282,7 +17332,6 @@ async function syncFromDir(dir, opts = {}) {
     return { added: 0, updated: 0, unchanged: 0, skipped: [`Not found: ${absDir}`] };
   const files = opts.recursive !== false ? walkDir(absDir) : readdirSync4(absDir).map((f) => join18(absDir, f)).filter((f) => statSync6(f).isFile());
   const result = { added: 0, updated: 0, unchanged: 0, skipped: [] };
-  const home = homedir10();
   const allConfigs = await store.listConfigs();
   for (const file of files) {
     if (shouldSkip(file)) {
@@ -17295,12 +17344,12 @@ async function syncFromDir(dir, opts = {}) {
         result.skipped.push(file + " (too large)");
         continue;
       }
-      const targetPath = file.replace(home, "~");
+      const targetPath = compactPathForConfigHome(file);
       const redacted = redactContent(content, redactFormatForTarget(targetPath, detectFormat(file)));
       const existing = allConfigs.find((c) => c.target_path === targetPath);
       if (!existing) {
         if (!opts.dryRun)
-          await store.createConfig({ name: relative6(absDir, file), category: detectCategory(file), agent: detectAgent(file), target_path: targetPath, format: detectFormat(file), content: redacted.content });
+          await store.createConfig({ name: relative7(absDir, file), category: detectCategory(file), agent: detectAgent(file), target_path: targetPath, format: detectFormat(file), content: redacted.content });
         result.added++;
       } else if (existing.content !== redacted.content) {
         if (!opts.dryRun)
@@ -17317,9 +17366,8 @@ async function syncFromDir(dir, opts = {}) {
 }
 async function syncToDir(dir, opts = {}) {
   const store = opts.store ?? resolveConfigStore();
-  const home = homedir10();
   const absDir = expandPath(dir);
-  const normalized = dir.startsWith("~/") ? dir : absDir.replace(home, "~");
+  const normalized = dir.startsWith("~/") ? dir : compactPathForConfigHome(absDir);
   const configs = (await store.listConfigs()).filter((c) => c.target_path && (c.target_path.startsWith(normalized) || c.target_path.startsWith(absDir)));
   const result = { added: 0, updated: 0, unchanged: 0, skipped: [] };
   for (const config of configs) {
@@ -17869,112 +17917,688 @@ function detectFormat(filePath) {
   return "text";
 }
 // src/lib/export.ts
+init_types();
 init_config_store();
-import { existsSync as existsSync18, mkdirSync as mkdirSync8, rmSync as rmSync4, writeFileSync as writeFileSync6 } from "fs";
-import { join as join20, resolve as resolve12 } from "path";
+import { createHash as createHash11 } from "crypto";
+import { existsSync as existsSync18, mkdirSync as mkdirSync8, mkdtempSync, rmSync as rmSync4, writeFileSync as writeFileSync6 } from "fs";
+import { dirname as dirname11, join as join20, resolve as resolve12 } from "path";
 import { tmpdir } from "os";
-async function exportConfigs(outputPath, opts = {}) {
+var ARCHIVE_EXCLUSIONS = [
+  {
+    entity: "api_keys",
+    classification: "security_state",
+    reason: "API credentials are security state and must be provisioned independently, never copied in a domain archive."
+  },
+  {
+    entity: "idempotency_receipts",
+    classification: "transport_state",
+    reason: "Request replay receipts are transport state and are not portable business-domain data."
+  },
+  {
+    entity: "feedback",
+    classification: "out_of_domain",
+    reason: "Feedback is product telemetry, not part of the Instructions configuration domain."
+  }
+];
+function compareText(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+function sha25611(value) {
+  return createHash11("sha256").update(value).digest("hex");
+}
+function canonicalize(value) {
+  if (Array.isArray(value))
+    return value.map(canonicalize);
+  if (value && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined).sort(([left], [right]) => compareText(left, right)).map(([key, entry]) => [key, canonicalize(entry)]));
+  }
+  return value;
+}
+function canonicalDomainJson(value) {
+  return JSON.stringify(canonicalize(value));
+}
+function logicalAssetLocator(locator, idToSlug) {
+  const match = /^config:\/\/([^@]+)@(\d+)$/.exec(locator);
+  if (!match)
+    return locator;
+  let configId;
+  try {
+    configId = decodeURIComponent(match[1]);
+  } catch {
+    return locator;
+  }
+  const slug2 = idToSlug.get(configId);
+  return slug2 ? `config-slug://${encodeURIComponent(slug2)}@${match[2]}` : locator;
+}
+function logicalCollections(domain, options) {
+  const configs = [...domain.configs].sort((left, right) => compareText(left.slug, right.slug));
+  const snapshots = [...domain.config_snapshots].sort((left, right) => compareText(left.config_slug, right.config_slug) || left.version - right.version || compareText(left.id, right.id));
+  const profiles = [...domain.profiles].sort((left, right) => compareText(left.slug, right.slug));
+  const configBindings = [...domain.profile_config_bindings].sort((left, right) => compareText(left.profile_slug, right.profile_slug) || left.sort_order - right.sort_order || compareText(left.config_slug, right.config_slug));
+  const assetBindings = [...domain.profile_asset_bindings].sort((left, right) => compareText(left.profile_slug, right.profile_slug) || left.sort_order - right.sort_order || compareText(left.binding.assetKey, right.binding.assetKey));
+  const machines = [...domain.machines].sort((left, right) => compareText(left.hostname, right.hostname));
+  const idToSlug = new Map(configs.map((config) => [config.id, config.slug]));
+  const configOrder = new Map;
+  const assetOrder = new Map;
+  return {
+    configs: configs.map((config) => ({
+      slug: config.slug,
+      name: config.name,
+      kind: config.kind,
+      category: config.category,
+      agent: config.agent,
+      target_path: config.target_path,
+      outputs: config.outputs,
+      format: config.format,
+      content: config.content,
+      description: config.description,
+      tags: [...config.tags].sort(compareText),
+      is_template: config.is_template,
+      version: config.version,
+      ...options.includeOperationalTimestamps ? {
+        created_at: config.created_at,
+        updated_at: config.updated_at,
+        synced_at: config.synced_at
+      } : {}
+    })),
+    config_snapshots: snapshots.map((snapshot) => ({
+      config_slug: snapshot.config_slug,
+      version: snapshot.version,
+      content: snapshot.content,
+      ...options.includeOperationalTimestamps ? { created_at: snapshot.created_at } : {}
+    })),
+    profiles: profiles.map((profile) => ({
+      slug: profile.slug,
+      name: profile.name,
+      description: profile.description,
+      selectors: profile.selectors,
+      variables: profile.variables,
+      ...options.includeOperationalTimestamps ? {
+        created_at: profile.created_at,
+        updated_at: profile.updated_at
+      } : {}
+    })),
+    profile_config_bindings: configBindings.map((row) => {
+      const order = configOrder.get(row.profile_slug) ?? 0;
+      configOrder.set(row.profile_slug, order + 1);
+      return {
+        profile_slug: row.profile_slug,
+        config_slug: row.config_slug,
+        order,
+        binding: row.binding
+      };
+    }),
+    profile_asset_bindings: assetBindings.map((row) => {
+      const order = assetOrder.get(row.profile_slug) ?? 0;
+      assetOrder.set(row.profile_slug, order + 1);
+      return {
+        profile_slug: row.profile_slug,
+        source_config_slug: row.source_config_slug,
+        order,
+        binding: {
+          ...row.binding,
+          source: {
+            ...row.binding.source,
+            locator: logicalAssetLocator(row.binding.source.locator, idToSlug)
+          }
+        }
+      };
+    }),
+    machines: machines.map((machine) => ({
+      hostname: machine.hostname,
+      os: machine.os,
+      arch: machine.arch,
+      ...options.includeOperationalTimestamps ? {
+        created_at: machine.created_at,
+        last_applied_at: machine.last_applied_at
+      } : {
+        applied: machine.last_applied_at !== null
+      }
+    }))
+  };
+}
+function computeIntegrity(domain, options) {
+  const collections = logicalCollections(domain, options);
+  const counts = {
+    configs: collections.configs.length,
+    config_snapshots: collections.config_snapshots.length,
+    profiles: collections.profiles.length,
+    profile_config_bindings: collections.profile_config_bindings.length,
+    profile_asset_bindings: collections.profile_asset_bindings.length,
+    machines: collections.machines.length
+  };
+  const hashes = {
+    configs: sha25611(canonicalDomainJson(collections.configs)),
+    config_snapshots: sha25611(canonicalDomainJson(collections.config_snapshots)),
+    profiles: sha25611(canonicalDomainJson(collections.profiles)),
+    profile_config_bindings: sha25611(canonicalDomainJson(collections.profile_config_bindings)),
+    profile_asset_bindings: sha25611(canonicalDomainJson(collections.profile_asset_bindings)),
+    machines: sha25611(canonicalDomainJson(collections.machines))
+  };
+  return {
+    algorithm: "sha256",
+    canonicalization: options.canonicalization,
+    counts,
+    hashes,
+    domain_sha256: sha25611(canonicalDomainJson({ counts, hashes }))
+  };
+}
+function computeDomainIntegrity(domain) {
+  return computeIntegrity(domain, {
+    includeOperationalTimestamps: true,
+    canonicalization: "hasna.instructions.logical-json/v1"
+  });
+}
+function computeRestorableDomainIntegrity(domain) {
+  return computeIntegrity(domain, {
+    includeOperationalTimestamps: false,
+    canonicalization: "hasna.instructions.restorable-logical-json/v1"
+  });
+}
+function assertArray(value, label) {
+  if (!Array.isArray(value))
+    throw new Error(`Invalid v2 archive: ${label} must be an array`);
+}
+function assertUnique(values, label) {
+  const seen = new Set;
+  for (const value of values) {
+    if (!value || seen.has(value))
+      throw new Error(`Invalid v2 archive: duplicate or empty ${label} ${JSON.stringify(value)}`);
+    seen.add(value);
+  }
+}
+function assertTimestamp(value, label, nullable = false) {
+  if (nullable && value === null)
+    return;
+  if (typeof value !== "string" || value.length === 0 || Number.isNaN(Date.parse(value))) {
+    throw new Error(`Invalid v2 archive: ${label} must be ${nullable ? "null or " : ""}an ISO timestamp`);
+  }
+}
+function validateInstructionsDomainArchive(value) {
+  if (!value || typeof value !== "object")
+    throw new Error("Invalid v2 archive: domain payload must be an object");
+  const domain = value;
+  if (domain.schema !== INSTRUCTIONS_DOMAIN_ARCHIVE_SCHEMA)
+    throw new Error("Invalid v2 archive: unsupported domain schema");
+  assertArray(domain.configs, "configs");
+  assertArray(domain.config_snapshots, "config_snapshots");
+  assertArray(domain.profiles, "profiles");
+  assertArray(domain.profile_config_bindings, "profile_config_bindings");
+  assertArray(domain.profile_asset_bindings, "profile_asset_bindings");
+  assertArray(domain.machines, "machines");
+  const typed = domain;
+  assertUnique(typed.configs.map((row) => row.slug), "config slug");
+  assertUnique(typed.profiles.map((row) => row.slug), "profile slug");
+  assertUnique(typed.machines.map((row) => row.hostname), "machine hostname");
+  assertUnique(typed.config_snapshots.map((row) => `${row.config_slug}@${row.version}`), "config snapshot");
+  assertUnique(typed.profile_config_bindings.map((row) => `${row.profile_slug}:${row.config_slug}`), "profile config binding");
+  assertUnique(typed.profile_asset_bindings.map((row) => `${row.profile_slug}:${row.binding.assetKey}`), "profile asset binding");
+  const configSlugs = new Set(typed.configs.map((row) => row.slug));
+  const profileSlugs = new Set(typed.profiles.map((row) => row.slug));
+  for (const config of typed.configs) {
+    assertTimestamp(config.created_at, `config ${config.slug} created_at`);
+    assertTimestamp(config.updated_at, `config ${config.slug} updated_at`);
+    assertTimestamp(config.synced_at, `config ${config.slug} synced_at`, true);
+    if (!Number.isSafeInteger(config.version) || config.version < 1)
+      throw new Error(`Invalid v2 archive: config ${config.slug} has invalid version`);
+    const snapshots = typed.config_snapshots.filter((row) => row.config_slug === config.slug).sort((a, b) => a.version - b.version);
+    if (snapshots.some((row) => !Number.isSafeInteger(row.version) || row.version < 1 || row.version > config.version)) {
+      throw new Error(`Invalid v2 archive: config ${config.slug} has an invalid snapshot version`);
+    }
+    if (snapshots.length) {
+      const first = snapshots[0].version;
+      const expected = Array.from({ length: config.version - first + 1 }, (_, index) => first + index);
+      if (canonicalDomainJson(snapshots.map((row) => row.version)) !== canonicalDomainJson(expected) || snapshots.at(-1).version !== config.version) {
+        throw new Error(`Invalid v2 archive: snapshots for ${config.slug} must be a contiguous suffix ending at version ${config.version}`);
+      }
+      if (snapshots.at(-1).content !== config.content) {
+        throw new Error(`Invalid v2 archive: latest snapshot content differs from config ${config.slug}`);
+      }
+    }
+  }
+  for (const row of typed.config_snapshots) {
+    if (!configSlugs.has(row.config_slug))
+      throw new Error(`Invalid v2 archive: snapshot references missing config ${row.config_slug}`);
+    assertTimestamp(row.created_at, `snapshot ${row.config_slug}@${row.version} created_at`);
+  }
+  for (const profile of typed.profiles) {
+    assertTimestamp(profile.created_at, `profile ${profile.slug} created_at`);
+    assertTimestamp(profile.updated_at, `profile ${profile.slug} updated_at`);
+  }
+  for (const row of typed.profile_config_bindings) {
+    if (!profileSlugs.has(row.profile_slug) || !configSlugs.has(row.config_slug)) {
+      throw new Error(`Invalid v2 archive: profile config binding has a missing logical reference`);
+    }
+  }
+  for (const row of typed.profile_asset_bindings) {
+    if (!profileSlugs.has(row.profile_slug) || !configSlugs.has(row.source_config_slug)) {
+      throw new Error(`Invalid v2 archive: profile asset binding has a missing logical reference`);
+    }
+  }
+  for (const machine of typed.machines) {
+    assertTimestamp(machine.created_at, `machine ${machine.hostname} created_at`);
+    assertTimestamp(machine.last_applied_at, `machine ${machine.hostname} last_applied_at`, true);
+  }
+  return typed;
+}
+function matchesFilter(config, filter) {
+  if (!filter)
+    return true;
+  if (filter.category && config.category !== filter.category)
+    return false;
+  if (filter.agent && config.agent !== filter.agent)
+    return false;
+  if (filter.kind && config.kind !== filter.kind)
+    return false;
+  if (filter.is_template !== undefined && config.is_template !== filter.is_template)
+    return false;
+  if (filter.tags?.length && !filter.tags.every((tag) => config.tags.includes(tag)))
+    return false;
+  if (filter.search) {
+    const needle = filter.search.toLocaleLowerCase();
+    if (![config.name, config.description ?? "", config.content].some((value) => value.toLocaleLowerCase().includes(needle)))
+      return false;
+  }
+  return true;
+}
+async function collectInstructionsDomain(opts = {}) {
   const store = opts.store ?? resolveConfigStore();
-  const configs = await store.listConfigs(opts.filter);
+  const selectedProfile = opts.profileId ? await store.getProfile(opts.profileId) : null;
+  const listedConfigs = selectedProfile ? await store.getProfileConfigs(selectedProfile.id) : await store.listConfigs(opts.filter);
+  const configs = listedConfigs.filter((config) => matchesFilter(config, selectedProfile ? opts.filter : undefined));
+  configs.sort((left, right) => compareText(left.slug, right.slug));
+  const selectedIds = new Set(configs.map((config) => config.id));
+  const profiles = (selectedProfile ? [selectedProfile] : await store.listProfiles()).sort((left, right) => compareText(left.slug, right.slug));
+  const profileById = new Map(profiles.map((profile) => [profile.id, profile]));
+  const configById = new Map(configs.map((config) => [config.id, config]));
+  const configSnapshots = [];
+  for (const config of configs) {
+    for (const snapshot of await store.listSnapshots(config.id)) {
+      configSnapshots.push({
+        id: snapshot.id,
+        config_slug: config.slug,
+        content: snapshot.content,
+        version: snapshot.version,
+        created_at: snapshot.created_at
+      });
+    }
+  }
+  configSnapshots.sort((left, right) => compareText(left.config_slug, right.config_slug) || left.version - right.version || compareText(left.id, right.id));
+  const profileConfigBindings = (await Promise.all(profiles.map(async (profile) => (await store.getProfileConfigBindings(profile.id)).filter((row) => selectedIds.has(row.config_id)).map((row) => ({
+    profile_slug: profile.slug,
+    config_slug: configById.get(row.config_id).slug,
+    sort_order: row.sort_order,
+    binding: row.binding
+  }))))).flat().sort((left, right) => compareText(left.profile_slug, right.profile_slug) || left.sort_order - right.sort_order || compareText(left.config_slug, right.config_slug));
+  const profileAssetBindings = (await Promise.all(profiles.map(async (profile) => (await store.getProfileAssetBindings(profile.id)).filter((row) => selectedIds.has(row.source_config_id)).map((row) => ({
+    profile_slug: profile.slug,
+    source_config_slug: configById.get(row.source_config_id).slug,
+    sort_order: row.sort_order,
+    binding: row.binding
+  }))))).flat().sort((left, right) => compareText(left.profile_slug, right.profile_slug) || left.sort_order - right.sort_order || compareText(left.binding.assetKey, right.binding.assetKey));
+  const archivedProfiles = profiles.filter((profile) => profileById.has(profile.id));
+  const machines = (await store.listMachines()).sort((left, right) => compareText(left.hostname, right.hostname));
+  return {
+    schema: INSTRUCTIONS_DOMAIN_ARCHIVE_SCHEMA,
+    configs,
+    config_snapshots: configSnapshots,
+    profiles: archivedProfiles,
+    profile_config_bindings: profileConfigBindings,
+    profile_asset_bindings: profileAssetBindings,
+    machines
+  };
+}
+async function exportConfigs(outputPath, opts = {}) {
+  const domain = validateInstructionsDomainArchive(await collectInstructionsDomain(opts));
+  const integrity = computeDomainIntegrity(domain);
+  const payload = `${JSON.stringify(domain, null, 2)}
+`;
+  const manifest = {
+    schema: INSTRUCTIONS_DOMAIN_ARCHIVE_SCHEMA,
+    version: "2.0.0",
+    exported_at: new Date().toISOString(),
+    payload: {
+      path: "domain.json",
+      sha256: sha25611(payload),
+      size_bytes: Buffer.byteLength(payload)
+    },
+    integrity,
+    exclusions: ARCHIVE_EXCLUSIONS
+  };
   const absOutput = resolve12(outputPath);
-  const tmpDir = join20(tmpdir(), `configs-export-${Date.now()}`);
-  const contentsDir = join20(tmpDir, "contents");
+  mkdirSync8(dirname11(absOutput), { recursive: true });
+  const stagingDir = mkdtempSync(join20(tmpdir(), "instructions-domain-export-"));
   try {
-    mkdirSync8(contentsDir, { recursive: true });
-    const manifest = {
-      version: "1.0.0",
-      exported_at: new Date().toISOString(),
-      configs: configs.map(({ content: _content, ...meta }) => meta)
-    };
-    writeFileSync6(join20(tmpDir, "manifest.json"), JSON.stringify(manifest, null, 2), "utf-8");
-    for (const config of configs) {
-      const fileName = `${config.slug}.${config.format === "text" ? "txt" : config.format}`;
-      writeFileSync6(join20(contentsDir, fileName), config.content, "utf-8");
-    }
-    const proc = Bun.spawn(["tar", "czf", absOutput, "-C", tmpDir, "."], {
+    writeFileSync6(join20(stagingDir, "manifest.json"), `${JSON.stringify(manifest, null, 2)}
+`, "utf-8");
+    writeFileSync6(join20(stagingDir, "domain.json"), payload, "utf-8");
+    const proc = Bun.spawn(["tar", "czf", absOutput, "-C", stagingDir, "manifest.json", "domain.json"], {
       stdout: "pipe",
       stderr: "pipe"
     });
     const exitCode = await proc.exited;
     if (exitCode !== 0) {
       const stderr = await new Response(proc.stderr).text();
-      throw new Error(`tar failed: ${stderr}`);
+      throw new Error(`tar failed: ${stderr.trim()}`);
     }
-    return { path: absOutput, count: configs.length };
+    return { path: absOutput, count: domain.configs.length, counts: integrity.counts, integrity };
   } finally {
-    if (existsSync18(tmpDir)) {
-      rmSync4(tmpDir, { recursive: true, force: true });
-    }
+    if (existsSync18(stagingDir))
+      rmSync4(stagingDir, { recursive: true, force: true });
   }
 }
 // src/lib/import.ts
+init_types();
 init_config_store();
-import { existsSync as existsSync19, mkdirSync as mkdirSync9, readFileSync as readFileSync17, rmSync as rmSync5 } from "fs";
-import { join as join21, resolve as resolve13 } from "path";
-import { tmpdir as tmpdir2 } from "os";
-async function importConfigs(bundlePath, opts = {}) {
-  const store = opts.store ?? resolveConfigStore();
-  const conflict = opts.conflict ?? "skip";
-  const absPath = resolve13(bundlePath);
-  const tmpDir = join21(tmpdir2(), `configs-import-${Date.now()}`);
-  const result = { created: 0, updated: 0, skipped: 0, errors: [] };
+import { createHash as createHash12 } from "crypto";
+import { resolve as resolve13 } from "path";
+function compareText2(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+function emptyMutationCounts() {
+  return { created: 0, updated: 0, skipped: 0 };
+}
+function emptyResult() {
+  return {
+    created: 0,
+    updated: 0,
+    skipped: 0,
+    counts: {
+      configs: emptyMutationCounts(),
+      config_snapshots: { created: 0, skipped: 0 },
+      profiles: emptyMutationCounts(),
+      profile_config_bindings: emptyMutationCounts(),
+      profile_asset_bindings: emptyMutationCounts(),
+      machines: emptyMutationCounts()
+    },
+    errors: [],
+    integrity: null
+  };
+}
+function sha25612(value) {
+  return createHash12("sha256").update(value).digest("hex");
+}
+function normalizeMemberName(name) {
+  let normalized = name;
+  while (normalized.startsWith("./"))
+    normalized = normalized.slice(2);
+  if (normalized.startsWith("/") || normalized.includes("\x00") || normalized.split("/").some((segment) => segment === "..")) {
+    throw new Error(`Invalid archive member path: ${JSON.stringify(name)}`);
+  }
+  return normalized;
+}
+async function openArchive(path) {
+  const list = Bun.spawn(["tar", "tzf", path], { stdout: "pipe", stderr: "pipe" });
+  const [exitCode, stdout, stderr] = await Promise.all([
+    list.exited,
+    new Response(list.stdout).text(),
+    new Response(list.stderr).text()
+  ]);
+  if (exitCode !== 0)
+    throw new Error(`tar listing failed: ${stderr.trim()}`);
+  const members = new Map;
+  for (const raw of stdout.split(`
+`).filter(Boolean)) {
+    const normalized = normalizeMemberName(raw);
+    if (normalized.length === 0)
+      continue;
+    if (members.has(normalized))
+      throw new Error(`Invalid archive: duplicate member ${normalized}`);
+    members.set(normalized, raw);
+  }
+  return {
+    members,
+    async read(member) {
+      const actual = members.get(member);
+      if (!actual)
+        throw new Error(`Invalid archive: missing ${member}`);
+      const proc = Bun.spawn(["tar", "xOzf", path, "--", actual], { stdout: "pipe", stderr: "pipe" });
+      const [code, content, memberError] = await Promise.all([
+        proc.exited,
+        new Response(proc.stdout).text(),
+        new Response(proc.stderr).text()
+      ]);
+      if (code !== 0)
+        throw new Error(`tar read failed for ${member}: ${memberError.trim()}`);
+      return content;
+    }
+  };
+}
+function isNotFound(error) {
+  return Boolean(error && typeof error === "object" && (error.name === "ConfigNotFoundError" || error.name === "ProfileNotFoundError" || error.status === 404));
+}
+async function findConfig(store, slug2) {
   try {
-    mkdirSync9(tmpDir, { recursive: true });
-    const proc = Bun.spawn(["tar", "xzf", absPath, "-C", tmpDir], {
-      stdout: "pipe",
-      stderr: "pipe"
+    return await store.getConfig(slug2);
+  } catch (error) {
+    if (isNotFound(error))
+      return null;
+    throw error;
+  }
+}
+function verifyCounts(actual, expected) {
+  if (canonicalDomainJson(actual) !== canonicalDomainJson(expected)) {
+    throw new Error("Archive integrity failure: manifest counts do not match the domain payload");
+  }
+}
+async function readV2(reader, manifest) {
+  if (manifest.schema !== INSTRUCTIONS_DOMAIN_ARCHIVE_SCHEMA || manifest.version !== "2.0.0" || manifest.payload?.path !== "domain.json" || manifest.integrity?.algorithm !== "sha256" || manifest.integrity?.canonicalization !== "hasna.instructions.logical-json/v1") {
+    throw new Error("Invalid v2 archive manifest");
+  }
+  const payload = await reader.read("domain.json");
+  if (Buffer.byteLength(payload) !== manifest.payload.size_bytes || sha25612(payload) !== manifest.payload.sha256) {
+    throw new Error("Archive integrity failure: domain payload hash or size does not match the manifest");
+  }
+  const domain = validateInstructionsDomainArchive(JSON.parse(payload));
+  const actual = computeDomainIntegrity(domain);
+  verifyCounts(actual.counts, manifest.integrity.counts);
+  if (canonicalDomainJson(actual) !== canonicalDomainJson(manifest.integrity)) {
+    throw new Error("Archive integrity failure: logical domain hashes do not match the manifest");
+  }
+  return domain;
+}
+function configInput(config, content) {
+  return {
+    name: config.name,
+    kind: config.kind,
+    category: config.category,
+    agent: config.agent,
+    target_path: config.target_path,
+    outputs: config.outputs,
+    format: config.format,
+    content,
+    description: config.description ?? undefined,
+    tags: config.tags,
+    is_template: config.is_template
+  };
+}
+async function restoreNewConfig(store, archived, domain) {
+  const snapshots = domain.config_snapshots.filter((row) => row.config_slug === archived.slug).sort((left, right) => left.version - right.version);
+  const byVersion = new Map(snapshots.map((snapshot) => [snapshot.version, snapshot.content]));
+  let content = byVersion.get(1) ?? snapshots[0]?.content ?? archived.content;
+  let restored = await store.createConfig(configInput(archived, content));
+  for (let version = 2;version <= archived.version; version++) {
+    content = byVersion.get(version) ?? (version === archived.version ? archived.content : content);
+    restored = await store.updateConfig(restored.id, {
+      content,
+      ...version === archived.version ? {
+        name: archived.name,
+        kind: archived.kind,
+        category: archived.category,
+        agent: archived.agent,
+        target_path: archived.target_path,
+        outputs: archived.outputs,
+        format: archived.format,
+        description: archived.description,
+        tags: archived.tags,
+        is_template: archived.is_template,
+        synced_at: archived.synced_at
+      } : {}
     });
-    const exitCode = await proc.exited;
-    if (exitCode !== 0) {
-      const stderr = await new Response(proc.stderr).text();
-      throw new Error(`tar extraction failed: ${stderr}`);
+  }
+  await store.pruneSnapshots(restored.id, snapshots.length);
+  const restoredSnapshots = (await store.listSnapshots(restored.id)).map(({ version, content: snapshotContent }) => ({ version, content: snapshotContent })).sort((left, right) => left.version - right.version);
+  const expectedSnapshots = snapshots.map(({ version, content: snapshotContent }) => ({ version, content: snapshotContent }));
+  if (restored.version !== archived.version || restored.content !== archived.content || canonicalDomainJson(restoredSnapshots) !== canonicalDomainJson(expectedSnapshots)) {
+    throw new Error(`restored config or snapshot history did not match archive for ${archived.slug}`);
+  }
+  return restored;
+}
+function rewriteAssetLocator(binding, archivedSourceId, restoredSourceId) {
+  const match = /^config:\/\/([^@]+)@(\d+)$/.exec(binding.source.locator);
+  if (!match)
+    return binding;
+  let locatorId;
+  try {
+    locatorId = decodeURIComponent(match[1]);
+  } catch {
+    return binding;
+  }
+  if (locatorId !== archivedSourceId)
+    return binding;
+  return {
+    ...binding,
+    source: {
+      ...binding.source,
+      locator: `config://${encodeURIComponent(restoredSourceId)}@${match[2]}`
     }
-    const manifestPath = join21(tmpDir, "manifest.json");
-    if (!existsSync19(manifestPath))
-      throw new Error("Invalid bundle: missing manifest.json");
-    const manifest = JSON.parse(readFileSync17(manifestPath, "utf-8"));
-    for (const meta of manifest.configs) {
-      try {
-        const ext = meta.format === "text" ? "txt" : meta.format;
-        const contentFile = join21(tmpDir, "contents", `${meta.slug}.${ext}`);
-        const content = existsSync19(contentFile) ? readFileSync17(contentFile, "utf-8") : "";
-        let existing = null;
-        try {
-          existing = await store.getConfig(meta.slug);
-        } catch {}
-        if (existing) {
-          if (conflict === "skip") {
-            result.skipped++;
-          } else if (conflict === "overwrite" || conflict === "version") {
-            await store.updateConfig(existing.id, { content, description: meta.description ?? undefined, tags: meta.tags, outputs: meta.outputs });
-            result.updated++;
-          }
-        } else {
-          await store.createConfig({
-            name: meta.name,
-            kind: meta.kind,
-            category: meta.category,
-            agent: meta.agent,
-            target_path: meta.target_path ?? undefined,
-            outputs: meta.outputs,
-            format: meta.format,
-            content,
-            description: meta.description ?? undefined,
-            tags: meta.tags,
-            is_template: meta.is_template
-          });
-          result.created++;
-        }
-      } catch (err) {
-        result.errors.push(`${meta.slug}: ${err instanceof Error ? err.message : String(err)}`);
+  };
+}
+async function assertEmptyV2Destination(store) {
+  const [configs, profiles, machines] = await Promise.all([
+    store.listConfigs(),
+    store.listProfiles(),
+    store.listMachines()
+  ]);
+  if (configs.length > 0 || profiles.length > 0 || machines.length > 0) {
+    throw new Error(`Instructions domain archive v2 recovery requires an empty destination ` + `(found configs=${configs.length}, profiles=${profiles.length}, machines=${machines.length})`);
+  }
+}
+async function importV2(domain, manifest, store, conflict) {
+  if (conflict !== "skip") {
+    throw new Error(`Instructions domain archive v2 does not support ${conflict}; restore into an empty destination`);
+  }
+  await assertEmptyV2Destination(store);
+  const result = emptyResult();
+  result.integrity = manifest.integrity;
+  const configMap = new Map;
+  for (const archived of domain.configs) {
+    const restored = await restoreNewConfig(store, archived, domain);
+    configMap.set(archived.slug, restored);
+    result.counts.configs.created++;
+    result.created++;
+    result.counts.config_snapshots.created += domain.config_snapshots.filter((row) => row.config_slug === archived.slug).length;
+  }
+  const profileMap = new Map;
+  for (const archived of domain.profiles) {
+    const created = await store.createProfile({
+      name: archived.name,
+      description: archived.description ?? undefined,
+      selectors: archived.selectors,
+      variables: archived.variables
+    });
+    profileMap.set(archived.slug, created);
+    result.counts.profiles.created++;
+  }
+  for (const archived of domain.profiles) {
+    const restoredProfile = profileMap.get(archived.slug);
+    if (!restoredProfile)
+      throw new Error(`post-create profile mapping missing for ${archived.slug}`);
+    const archivedMembership = domain.profile_config_bindings.filter((row) => row.profile_slug === archived.slug).sort((left, right) => left.sort_order - right.sort_order || compareText2(left.config_slug, right.config_slug));
+    const archivedAssets = domain.profile_asset_bindings.filter((row) => row.profile_slug === archived.slug).sort((left, right) => left.sort_order - right.sort_order || compareText2(left.binding.assetKey, right.binding.assetKey));
+    for (const row of archivedMembership) {
+      const config = configMap.get(row.config_slug);
+      if (!config)
+        throw new Error(`missing restored config ${row.config_slug}`);
+      await store.addConfigToProfile(restoredProfile.id, config.id);
+      await store.setProfileConfigBinding(restoredProfile.id, config.id, row.binding);
+      result.counts.profile_config_bindings.created++;
+    }
+    for (const row of archivedAssets) {
+      const source = configMap.get(row.source_config_slug);
+      const archivedSource = domain.configs.find((config) => config.slug === row.source_config_slug);
+      if (!source || !archivedSource)
+        throw new Error(`missing restored asset source ${row.source_config_slug}`);
+      await store.addAssetToProfile(restoredProfile.id, source.id, rewriteAssetLocator(row.binding, archivedSource.id, source.id));
+      result.counts.profile_asset_bindings.created++;
+    }
+  }
+  for (const archived of domain.machines) {
+    const restored = await store.registerMachine(archived.hostname, archived.os ?? undefined, archived.arch ?? undefined);
+    if (archived.last_applied_at !== null)
+      await store.updateMachineApplied(restored.hostname);
+    result.counts.machines.created++;
+  }
+  const restoredDomain = await collectInstructionsDomain({ store });
+  const expected = computeRestorableDomainIntegrity(domain);
+  const actual = computeRestorableDomainIntegrity(restoredDomain);
+  if (canonicalDomainJson(actual) !== canonicalDomainJson(expected)) {
+    throw new Error(`Post-restore logical integrity verification failed: expected ${expected.domain_sha256}, got ${actual.domain_sha256}`);
+  }
+  return result;
+}
+async function importV1(reader, manifest, store, conflict) {
+  const result = emptyResult();
+  if (!Array.isArray(manifest.configs))
+    throw new Error("Invalid v1 bundle: configs must be an array");
+  for (const meta of manifest.configs) {
+    const ext = meta.format === "text" ? "txt" : meta.format;
+    const contentPath = `contents/${meta.slug}.${ext}`;
+    const content = reader.members.has(contentPath) ? await reader.read(contentPath) : "";
+    const existing = await findConfig(store, meta.slug);
+    if (existing) {
+      if (conflict === "skip") {
+        result.skipped++;
+        result.counts.configs.skipped++;
+      } else {
+        await store.updateConfig(existing.id, {
+          name: meta.name,
+          kind: meta.kind,
+          category: meta.category,
+          agent: meta.agent,
+          target_path: meta.target_path,
+          outputs: meta.outputs,
+          format: meta.format,
+          content,
+          description: meta.description,
+          tags: meta.tags,
+          is_template: meta.is_template,
+          synced_at: meta.synced_at
+        });
+        result.updated++;
+        result.counts.configs.updated++;
       }
-    }
-    return result;
-  } finally {
-    if (existsSync19(tmpDir)) {
-      rmSync5(tmpDir, { recursive: true, force: true });
+    } else {
+      await store.createConfig(configInput({ ...meta, content }, content));
+      result.created++;
+      result.counts.configs.created++;
     }
   }
+  return result;
+}
+async function importConfigs(bundlePath, opts = {}) {
+  const store = opts.store ?? resolveConfigStore();
+  const conflict = opts.conflict ?? "skip";
+  const reader = await openArchive(resolve13(bundlePath));
+  const manifestText = await reader.read("manifest.json");
+  let manifest;
+  try {
+    manifest = JSON.parse(manifestText);
+  } catch {
+    throw new Error("Invalid bundle: manifest.json is not valid JSON");
+  }
+  if (!manifest || typeof manifest !== "object" || typeof manifest.version !== "string") {
+    throw new Error("Invalid bundle: manifest version is missing");
+  }
+  if (manifest.version === "2.0.0") {
+    const v2 = manifest;
+    const domain = await readV2(reader, v2);
+    return importV2(domain, v2, store, conflict);
+  }
+  if (manifest.version.startsWith("1.")) {
+    return importV1(reader, manifest, store, conflict);
+  }
+  throw new Error(`Unsupported Instructions archive version: ${manifest.version}`);
 }
 
 // src/index.ts
@@ -17983,9 +18607,9 @@ init_redact();
 
 // src/lib/package-manager-guard.ts
 import { execFileSync as execFileSync2 } from "child_process";
-import { existsSync as existsSync20, lstatSync as lstatSync7, readdirSync as readdirSync6, readFileSync as readFileSync18 } from "fs";
-import { homedir as homedir11 } from "os";
-import { basename as basename7, dirname as dirname11, isAbsolute as isAbsolute7, join as join22, relative as relative7, resolve as resolve14 } from "path";
+import { existsSync as existsSync19, lstatSync as lstatSync7, readdirSync as readdirSync6, readFileSync as readFileSync17 } from "fs";
+import { homedir as homedir10 } from "os";
+import { basename as basename7, dirname as dirname12, isAbsolute as isAbsolute8, join as join21, relative as relative8, resolve as resolve14 } from "path";
 var SKIP_DIRS = new Set([
   ".git",
   "node_modules",
@@ -18027,7 +18651,7 @@ function scanPackageManagerSecrets(options = {}) {
   const findings = [];
   let scannedFiles = 0;
   for (const root of roots) {
-    if (!existsSync20(root))
+    if (!existsSync19(root))
       continue;
     const stat = lstatSync7(root);
     if (stat.isFile()) {
@@ -18037,14 +18661,14 @@ function scanPackageManagerSecrets(options = {}) {
       if (text === null)
         continue;
       scannedFiles++;
-      findings.push(...scanFile(root, text, classifyRepoFile(root), isTrackedFile(root), dirname11(root)));
+      findings.push(...scanFile(root, text, classifyRepoFile(root), isTrackedFile(root), dirname12(root)));
       continue;
     }
     if (!stat.isDirectory())
       continue;
     const tracked = trackedFiles(root);
     for (const file of collectRepoFiles(root)) {
-      const rel = toPosix(relative7(root, file));
+      const rel = toPosix(relative8(root, file));
       const isTracked = tracked.has(rel);
       const text = readTextFile(file);
       if (text === null)
@@ -18054,10 +18678,10 @@ function scanPackageManagerSecrets(options = {}) {
     }
   }
   if (options.includeHome) {
-    const home = homedir11();
+    const home = homedir10();
     for (const name of HOME_FILES) {
-      const file = join22(home, name);
-      if (!existsSync20(file))
+      const file = join21(home, name);
+      if (!existsSync19(file))
         continue;
       const text = readTextFile(file);
       if (text === null)
@@ -18081,12 +18705,12 @@ function collectRepoFiles(root) {
       if (entry.isDirectory()) {
         if (SKIP_DIRS.has(entry.name))
           continue;
-        visit(join22(dir, entry.name));
+        visit(join21(dir, entry.name));
         continue;
       }
       if (!entry.isFile())
         continue;
-      const file = join22(dir, entry.name);
+      const file = join21(dir, entry.name);
       if (shouldScanRepoFile(file))
         out.push(file);
     }
@@ -18124,7 +18748,7 @@ function readTextFile(file) {
     const stat = lstatSync7(file);
     if (!stat.isFile() || stat.size > 5000000)
       return null;
-    const buf = readFileSync18(file);
+    const buf = readFileSync17(file);
     if (buf.includes(0))
       return null;
     return buf.toString("utf-8");
@@ -18324,11 +18948,11 @@ function trackedFiles(root) {
 }
 function isTrackedFile(file) {
   try {
-    const repoRoot = execFileSync2("git", ["-C", dirname11(file), "rev-parse", "--show-toplevel"], {
+    const repoRoot = execFileSync2("git", ["-C", dirname12(file), "rev-parse", "--show-toplevel"], {
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "ignore"]
     }).trim();
-    const rel = toPosix(relative7(repoRoot, file));
+    const rel = toPosix(relative8(repoRoot, file));
     execFileSync2("git", ["-C", repoRoot, "ls-files", "--error-unmatch", "--", rel], {
       stdio: ["ignore", "ignore", "ignore"]
     });
@@ -18354,13 +18978,13 @@ function stripInlineComment(value) {
   return value.replace(/\s[#;].*$/, "").trim();
 }
 function displayPath(file, root) {
-  const home = homedir11();
+  const home = homedir10();
   if (root === home && (file === home || file.startsWith(home + "/")))
-    return "~/" + toPosix(relative7(home, file));
-  if (isAbsolute7(root) && file.startsWith(root + "/"))
-    return toPosix(relative7(root, file));
+    return "~/" + toPosix(relative8(home, file));
+  if (isAbsolute8(root) && file.startsWith(root + "/"))
+    return toPosix(relative8(root, file));
   if (file === home || file.startsWith(home + "/"))
-    return "~/" + toPosix(relative7(home, file));
+    return "~/" + toPosix(relative8(home, file));
   return file;
 }
 function toPosix(path) {
@@ -18526,6 +19150,7 @@ export {
   INSTRUCTION_ACTIVATION_MODES,
   INSTRUCTIONS_LOCAL_OPT_IN_ENV_KEYS,
   INSTRUCTIONS_LOCAL_OPT_IN_ENV,
+  INSTRUCTIONS_DOMAIN_ARCHIVE_SCHEMA,
   INBOX_CONVERSATIONS_MINIMUM_VERSION,
   GLOBAL_AGENT_RULES_STANDARD_SLUG,
   GLOBAL_AGENT_RULES_STANDARD_CONTENT,