@hasna/instructions 0.7.0 → 0.7.2

package/dist/cli/index.js

@@ -9,31 +9,39 @@ import {
   syncKnown,
   syncProject,
   syncToDisk
-} from "../chunks/index-1cnyjnd7.js";
+} from "../chunks/index-18j7x3xw.js";
 import {
   applyConfigsWithReport,
   compactPathForConfigHome,
   expandPath,
-  normalizeTargetPath
-} from "../chunks/index-z3ma4aqk.js";
+  normalizeTargetPath,
+  sessionRenderOwnsPath
+} from "../chunks/index-y8410ve0.js";
 import {
+  CODEWITH_NATIVE_IMPORTS_ENV,
   CloudConfigStore,
   DEFAULT_LIST_LIMIT,
   PROJECT_CONTEXT_MAX_INPUT_BYTES,
   ProjectContextError,
   SESSION_INSTRUCTION_LAYERS,
   SESSION_MANAGED_INPUT_MAX_BYTES,
+  SESSION_RENDERER_OWNER_ID,
   SESSION_RENDER_MANAGED_MARKER,
+  SESSION_RENDER_MANIFEST_RELATIVE_PATH,
   SESSION_RENDER_SCHEMA,
   SESSION_RENDER_TOOLS,
   applyProjectContext,
+  assertInstructionSource,
   detectClaudeAuthorityConflicts,
   detectCursorAuthorityConflicts,
   detectMachineContext,
   ensureCodewithSharedTodosStorageStandardConfig,
   ensureGlobalAgentRulesStandardConfig,
+  exports_external,
   formatCliError,
   getSessionRenderSnapshotDir,
+  instructionSourceRejection,
+  isRetiredInstructionSource,
   isRetiredOrUnsupportedConfigAgent,
   normalizeProfileAssetBinding,
   normalizeProfileConfigBinding,
@@ -61,11 +69,14 @@ import {
   truncateText,
   withProjectContextSessionGuard,
   writeProjectContextCoordinatedFile
-} from "../chunks/index-7m4j8a33.js";
+} from "../chunks/index-n6nh6f5r.js";
 import {
+  ConfigNotFoundError,
   INSTRUCTIONS_DOMAIN_ARCHIVE_SCHEMA,
-  extractTemplateVars
-} from "../chunks/index-n3fjspr0.js";
+  ProfileNotFoundError,
+  extractTemplateVars,
+  validateExpectedConfigVersion
+} from "../chunks/index-preyvj8n.js";
 import {
   slugify
 } from "../chunks/index-ma2xmp6c.js";
@@ -3784,9 +3795,9 @@ var {
 
 // src/cli/index.tsx
 import chalk from "chalk";
-import { existsSync as existsSync11, lstatSync as lstatSync4, mkdirSync as mkdirSync6, readFileSync as readFileSync7, readSync, renameSync as renameSync2, unlinkSync, writeFileSync as writeFileSync5, writeSync } from "fs";
+import { existsSync as existsSync11, lstatSync as lstatSync5, mkdirSync as mkdirSync6, readFileSync as readFileSync8, readSync, renameSync as renameSync2, unlinkSync, writeFileSync as writeFileSync5, writeSync } from "fs";
 import { homedir as homedir4 } from "os";
-import { basename, dirname as dirname6, join as join10, resolve as resolve6 } from "path";
+import { basename as basename2, dirname as dirname7, join as join11, resolve as resolve7 } from "path";
 
 // src/lib/config-target-identity.ts
 function findConfigsByTargetPath(configs, targetPath) {
@@ -3878,7 +3889,12 @@ function logicalAssetLocator(locator, idToSlug) {
 }
 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 snapshots = domain.config_snapshots.map((snapshot) => ({
+    config_slug: snapshot.config_slug,
+    version: snapshot.version,
+    content: snapshot.content,
+    ...options.includeOperationalTimestamps ? { created_at: snapshot.created_at } : {}
+  })).sort((left, right) => compareText(left.config_slug, right.config_slug) || left.version - right.version || compareText(left.content, right.content) || compareText("created_at" in left ? left.created_at ?? "" : "", "created_at" in right ? right.created_at ?? "" : ""));
   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));
@@ -3907,12 +3923,7 @@ function logicalCollections(domain, options) {
         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 } : {}
-    })),
+    config_snapshots: snapshots,
     profiles: profiles.map((profile) => ({
       slug: profile.slug,
       name: profile.name,
@@ -4036,10 +4047,11 @@ function validateInstructionsDomainArchive(value) {
   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.config_snapshots.map((row) => row.id), "config snapshot id");
   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 configsBySlug = new Map(typed.configs.map((row) => [row.slug, row]));
+  const configSlugs = new Set(configsBySlug.keys());
   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`);
@@ -4047,24 +4059,15 @@ function validateInstructionsDomainArchive(value) {
     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))
+    const config = configsBySlug.get(row.config_slug);
+    if (!config) {
       throw new Error(`Invalid v2 archive: snapshot references missing config ${row.config_slug}`);
+    }
+    if (!Number.isSafeInteger(row.version) || row.version < 1 || row.version > config.version) {
+      throw new Error(`Invalid v2 archive: config ${row.config_slug} has an invalid snapshot version`);
+    }
     assertTimestamp(row.created_at, `snapshot ${row.config_slug}@${row.version} created_at`);
   }
   for (const profile of typed.profiles) {
@@ -4318,14 +4321,11 @@ function configInput(config, content) {
   };
 }
 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));
+  const snapshots = domain.config_snapshots.filter((row) => row.config_slug === archived.slug).sort((left, right) => left.version - right.version || compareText2(left.content, right.content) || compareText2(left.id, right.id));
+  let restored = await store.createConfig(configInput(archived, 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,
+      content: archived.content,
       ...version === archived.version ? {
         name: archived.name,
         kind: archived.kind,
@@ -4341,9 +4341,12 @@ async function restoreNewConfig(store, archived, domain) {
       } : {}
     });
   }
-  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 }));
+  await store.pruneSnapshots(restored.id, 0);
+  for (const snapshot of snapshots) {
+    await store.createSnapshot(restored.id, snapshot.content, snapshot.version);
+  }
+  const restoredSnapshots = (await store.listSnapshots(restored.id)).map(({ version, content: snapshotContent }) => ({ version, content: snapshotContent })).sort((left, right) => left.version - right.version || compareText2(left.content, right.content));
+  const expectedSnapshots = snapshots.map(({ version, content: snapshotContent }) => ({ version, content: snapshotContent })).sort((left, right) => left.version - right.version || compareText2(left.content, right.content));
   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}`);
   }
@@ -4538,14 +4541,20 @@ function applySessionRenderUnlocked(plan, options, coordination) {
   const targetHome = assertSafeTargetHome(plan.targetHome);
   assertClaudeAuthorityStillClear(plan, targetHome, options.ownedClaudeAuthorities);
   const payloadFiles = [...plan.files, ...plan.assetFiles ?? []];
-  const files = [...payloadFiles, plan.manifestFile];
   const manifestPath = resolvePlannedFilePath(plan, plan.manifestFile, targetHome);
+  assertManifestPrecondition(manifestPath, targetHome, options.expectedManifestSha256);
   const previousManifest = readPreviousManifest(manifestPath);
   const previousHashes = previousManifest ? new Map(previousManifest.files.map((file) => [file.relativePath, file.sha256])) : new Map;
+  const adoptions = validateFileAdoptions(plan, targetHome, previousHashes, options);
+  const adoptedHashes = new Map(adoptions.map((entry) => [entry.relativePath, entry.preimageSha256]));
+  const reconciliations = validateFileReconciliations(plan, targetHome, previousManifest, options);
+  const reconciledHashes = new Map(reconciliations.map((entry) => [entry.relativePath, entry.preimageSha256]));
+  const manifestFile = manifestWithFileProvenance(plan, previousManifest, adoptions, reconciliations);
+  const files = [...payloadFiles, manifestFile];
   const currentRelativePaths = new Set(files.map((file) => file.relativePath));
   const drift = checkSessionRenderDrift(targetHome, manifestPath);
   const results = [
-    ...files.map((file) => planFileResult(plan, file, targetHome, previousHashes, previousManifest, options)),
+    ...files.map((file) => planFileResult(plan, file, targetHome, previousHashes, previousManifest, options, adoptedHashes, reconciledHashes)),
     ...planStaleFileResults(plan, targetHome, previousManifest, currentRelativePaths, options)
   ];
   assertNotSilentManagedWipeout(plan, results);
@@ -4568,7 +4577,9 @@ function applySessionRenderUnlocked(plan, options, coordination) {
       skippedSources: plan.manifest.skippedSources,
       files: results,
       conflicts,
-      drift
+      drift,
+      adoptions,
+      reconciliations
     };
   }
   let snapshotPath = null;
@@ -4581,10 +4592,12 @@ function applySessionRenderUnlocked(plan, options, coordination) {
   if (!options.dryRun) {
     const allowPortableFallback = coordination === null;
     const forcePortableFileOps = options.test_hooks?.force_portable_file_ops ?? false;
+    assertManifestPrecondition(manifestPath, targetHome, options.expectedManifestSha256);
     ensureSessionTargetHome(targetHome);
-    rollback = writeSessionSnapshot(plan, targetHome, manifestPath, results, previousManifest, coordination, allowPortableFallback, forcePortableFileOps);
+    rollback = writeSessionSnapshot(plan, targetHome, manifestPath, results, previousManifest, coordination, allowPortableFallback, forcePortableFileOps, adoptions, reconciliations);
     snapshotPath = rollback.snapshotPath;
     options.test_hooks?.before_apply_writes?.({ plan, results });
+    assertManifestPrecondition(manifestPath, targetHome, options.expectedManifestSha256);
     const resultsByPath = new Map(results.map((result) => [result.path, result]));
     for (const file of payloadFiles) {
       applyPlannedFile(plan, file, targetHome, resultsByPath, coordination, allowPortableFallback, forcePortableFileOps);
@@ -4604,7 +4617,7 @@ function applySessionRenderUnlocked(plan, options, coordination) {
       });
       coordination?.assert_held();
     }
-    applyPlannedFile(plan, plan.manifestFile, targetHome, resultsByPath, coordination, allowPortableFallback, forcePortableFileOps);
+    applyPlannedFile(plan, manifestFile, targetHome, resultsByPath, coordination, allowPortableFallback, forcePortableFileOps);
   }
   return {
     dryRun: options.dryRun ?? false,
@@ -4618,9 +4631,171 @@ function applySessionRenderUnlocked(plan, options, coordination) {
     skippedSources: plan.manifest.skippedSources,
     files: results,
     conflicts,
-    drift
+    drift,
+    adoptions,
+    reconciliations
   };
 }
+function assertManifestPrecondition(path, targetHome, expected) {
+  if (expected === undefined)
+    return;
+  if (!/^[a-f0-9]{64}$/.test(expected)) {
+    throw new SessionApplyError("Expected session manifest SHA-256 must contain 64 lowercase hexadecimal characters.");
+  }
+  if (currentSessionFileHash(path, targetHome) !== expected) {
+    throw new SessionApplyError("Session manifest SHA-256 precondition failed; reload the manifest and resolve a new plan.");
+  }
+}
+function validateFileAdoptions(plan, targetHome, previousHashes, options) {
+  const requests = options.adoptFiles ?? [];
+  if (!Array.isArray(requests))
+    throw new SessionApplyError("Session file adoptions must be an array.");
+  if (requests.length > 0 && options.force) {
+    throw new SessionApplyError("Exact file adoption cannot be combined with force.");
+  }
+  const seen = new Set;
+  return requests.map((request) => {
+    if (!request || typeof request.relativePath !== "string" || typeof request.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(request.sha256)) {
+      throw new SessionApplyError("Each file adoption requires a plan-relative path and a 64-character lowercase SHA-256.");
+    }
+    if (seen.has(request.relativePath)) {
+      throw new SessionApplyError(`Duplicate file adoption target: ${request.relativePath}`);
+    }
+    seen.add(request.relativePath);
+    const candidates = plan.files.filter((file2) => file2.relativePath === request.relativePath);
+    if (candidates.length !== 1 || candidates[0].role === "manifest") {
+      throw new SessionApplyError(`File adoption target is not a unique planned instruction output: ${request.relativePath}`);
+    }
+    const file = candidates[0];
+    const path = resolvePlannedFilePath(plan, file, targetHome);
+    if (previousHashes.has(file.relativePath) || sessionRenderOwnsPath(path)) {
+      throw new SessionApplyError(`File adoption target is already managed: ${request.relativePath}`);
+    }
+    const observedSha256 = readExactFilePreimage(path, targetHome, request, "adoption");
+    return {
+      path,
+      relativePath: file.relativePath,
+      preimageSha256: observedSha256,
+      renderedSha256: file.sha256,
+      sourceIds: [...file.sourceIds]
+    };
+  });
+}
+function readExactFilePreimage(path, targetHome, request, operation) {
+  if (currentSessionFileHash(path, targetHome) === null) {
+    throw new SessionApplyError(`File ${operation} target does not exist: ${request.relativePath}`);
+  }
+  const bytes = readFileSync(path);
+  if (!bytes.equals(Buffer.from(bytes.toString("utf8"), "utf8"))) {
+    throw new SessionApplyError(`File ${operation} target must contain losslessly restorable UTF-8: ${request.relativePath}`);
+  }
+  const observedSha256 = createHash3("sha256").update(bytes).digest("hex");
+  if (observedSha256 !== request.sha256) {
+    throw new SessionApplyError(`File ${operation} SHA-256 precondition failed: ${request.relativePath}`);
+  }
+  return observedSha256;
+}
+function validateFileReconciliations(plan, targetHome, previousManifest, options) {
+  const requests = options.reconcileFiles ?? [];
+  if (!Array.isArray(requests))
+    throw new SessionApplyError("Session file reconciliations must be an array.");
+  if (requests.length === 0)
+    return [];
+  if (options.force)
+    throw new SessionApplyError("Exact file reconciliation cannot be combined with force.");
+  if (options.expectedManifestSha256 === undefined) {
+    throw new SessionApplyError("Exact file reconciliation requires an expected manifest SHA-256 precondition.");
+  }
+  if (!previousManifest || previousManifest.targetOwner?.writer?.id !== SESSION_RENDERER_OWNER_ID || previousManifest.tool !== plan.tool || previousManifest.targetHome !== targetHome) {
+    throw new SessionApplyError("File reconciliation requires this renderer's manifest for the same tool and target home.");
+  }
+  const seen = new Set;
+  return requests.map((request) => {
+    if (!request || typeof request.relativePath !== "string" || typeof request.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(request.sha256)) {
+      throw new SessionApplyError("Each file reconciliation requires a plan-relative path and a 64-character lowercase SHA-256.");
+    }
+    if (seen.has(request.relativePath)) {
+      throw new SessionApplyError(`Duplicate file reconciliation target: ${request.relativePath}`);
+    }
+    seen.add(request.relativePath);
+    const candidates = plan.files.filter((file2) => file2.relativePath === request.relativePath);
+    if (candidates.length !== 1 || candidates[0].role === "manifest") {
+      throw new SessionApplyError(`File reconciliation target is not a unique planned instruction output: ${request.relativePath}`);
+    }
+    const file = candidates[0];
+    const path = resolvePlannedFilePath(plan, file, targetHome);
+    const owned = previousManifest.files.filter((entry) => entry.relativePath === file.relativePath);
+    if (owned.length !== 1 || owned[0].path !== path || owned[0].role !== file.role || !/^[a-f0-9]{64}$/.test(owned[0].sha256)) {
+      throw new SessionApplyError(`File reconciliation target is not owned by the observed manifest: ${request.relativePath}`);
+    }
+    const observedSha256 = readExactFilePreimage(path, targetHome, request, "reconciliation");
+    if (observedSha256 === owned[0].sha256) {
+      throw new SessionApplyError(`File reconciliation target has no managed drift: ${request.relativePath}`);
+    }
+    if (observedSha256 === file.sha256) {
+      throw new SessionApplyError(`File reconciliation target already matches the planned output: ${request.relativePath}`);
+    }
+    return {
+      path,
+      relativePath: file.relativePath,
+      preimageSha256: observedSha256,
+      renderedSha256: file.sha256,
+      previousManagedSha256: owned[0].sha256,
+      sourceIds: [...file.sourceIds]
+    };
+  });
+}
+function manifestWithFileProvenance(plan, previousManifest, adoptions, reconciliations) {
+  if (adoptions.length === 0 && previousManifest?.adoptions === undefined && reconciliations.length === 0 && previousManifest?.reconciliations === undefined)
+    return plan.manifestFile;
+  if (previousManifest?.adoptions !== undefined && !Array.isArray(previousManifest.adoptions)) {
+    throw new SessionApplyError("Previous session manifest adoption provenance is invalid.");
+  }
+  const entries = new Map;
+  for (const entry of [
+    ...previousManifest?.adoptions ?? [],
+    ...adoptions.map(({ path: _path, ...receipt }) => receipt)
+  ]) {
+    if (!entry || typeof entry.relativePath !== "string" || !/^[a-f0-9]{64}$/.test(entry.preimageSha256) || !/^[a-f0-9]{64}$/.test(entry.renderedSha256) || !Array.isArray(entry.sourceIds) || entry.sourceIds.some((id) => typeof id !== "string")) {
+      throw new SessionApplyError("Previous session manifest adoption provenance is invalid.");
+    }
+    resolveManifestRelativePath(entry.relativePath, plan.targetHome);
+    const previous = entries.get(entry.relativePath);
+    if (previous && JSON.stringify(previous) !== JSON.stringify(entry)) {
+      throw new SessionApplyError(`Conflicting session file adoption provenance: ${entry.relativePath}`);
+    }
+    entries.set(entry.relativePath, entry);
+  }
+  if (previousManifest?.reconciliations !== undefined && !Array.isArray(previousManifest.reconciliations)) {
+    throw new SessionApplyError("Previous session manifest reconciliation provenance is invalid.");
+  }
+  const reconciledEntries = new Map;
+  for (const entry of [
+    ...previousManifest?.reconciliations ?? [],
+    ...reconciliations.map(({ path: _path, ...receipt }) => receipt)
+  ]) {
+    if (!entry || typeof entry.relativePath !== "string" || !/^[a-f0-9]{64}$/.test(entry.preimageSha256) || !/^[a-f0-9]{64}$/.test(entry.renderedSha256) || !/^[a-f0-9]{64}$/.test(entry.previousManagedSha256) || !Array.isArray(entry.sourceIds) || entry.sourceIds.some((id) => typeof id !== "string")) {
+      throw new SessionApplyError("Previous session manifest reconciliation provenance is invalid.");
+    }
+    resolveManifestRelativePath(entry.relativePath, plan.targetHome);
+    const canonical = {
+      relativePath: entry.relativePath,
+      preimageSha256: entry.preimageSha256,
+      renderedSha256: entry.renderedSha256,
+      previousManagedSha256: entry.previousManagedSha256,
+      sourceIds: [...entry.sourceIds]
+    };
+    reconciledEntries.set(JSON.stringify(canonical), canonical);
+  }
+  const manifest = {
+    ...plan.manifest,
+    ...adoptions.length > 0 || previousManifest?.adoptions !== undefined ? { adoptions: [...entries.values()] } : {},
+    ...reconciliations.length > 0 || previousManifest?.reconciliations !== undefined ? { reconciliations: [...reconciledEntries.values()] } : {}
+  };
+  const content = `${JSON.stringify(manifest, null, 2)}
+`;
+  return { ...plan.manifestFile, content, sha256: sha2563(content) };
+}
 function assertCursorAuthorityUnchanged(plan) {
   if (plan.tool !== "cursor" || plan.targetKind === "blocked")
     return;
@@ -5092,12 +5267,29 @@ function resolveSnapshotFilePath(relativePath, recordedPath, targetHome) {
   }
   return path;
 }
-function planFileResult(plan, file, targetHome, previousHashes, previousManifest, options) {
+function planFileResult(plan, file, targetHome, previousHashes, previousManifest, options, adoptedHashes, reconciledHashes) {
   const target = resolvePlannedFilePath(plan, file, targetHome);
   const previousContent = existsSync5(target) ? readFileSync(target, "utf-8") : null;
   const previousSha256 = previousContent === null ? null : sha2563(previousContent);
   const previouslyManaged = isPreviouslyManaged(file, previousSha256, previousHashes, previousManifest);
   const changed = previousContent !== file.content;
+  const exactSha256 = adoptedHashes.get(file.relativePath) ?? reconciledHashes.get(file.relativePath);
+  if (exactSha256 !== undefined) {
+    const operation = adoptedHashes.has(file.relativePath) ? "adoption" : "reconciliation";
+    if (previousSha256 !== exactSha256) {
+      throw new SessionApplyError(`File ${operation} SHA-256 precondition failed: ${file.relativePath}`);
+    }
+    return {
+      path: target,
+      relativePath: file.relativePath,
+      role: file.role,
+      action: "update",
+      changed,
+      previousSha256,
+      newSha256: file.sha256,
+      reason: `exact observed SHA-256 ${operation}`
+    };
+  }
   if (previousContent !== null && !options.force && !previouslyManaged) {
     return {
       path: target,
@@ -5317,9 +5509,13 @@ function requiredPreviousHash(result) {
   }
   return result.previousSha256;
 }
-function writeSessionSnapshot(plan, targetHome, manifestPath, results, previousManifest, coordination, allowPortableFallback, forcePortableFileOps) {
-  const existingFiles = results.filter((result) => result.action === "update" || result.action === "delete").filter((result) => existsSync5(result.path)).map((result) => {
+function writeSessionSnapshot(plan, targetHome, manifestPath, results, previousManifest, coordination, allowPortableFallback, forcePortableFileOps, adoptions, reconciliations) {
+  const existingFiles = results.filter((result) => result.action === "update" || result.action === "delete").map((result) => {
+    assertExpectedSessionFileHash(result.path, targetHome, result.previousSha256);
     const content = readFileSync(result.path, "utf-8");
+    if (sha2563(content) !== result.previousSha256) {
+      throw new SessionApplyError(`Session snapshot preimage changed after planning: ${result.relativePath}`);
+    }
     return {
       path: result.path,
       relativePath: result.relativePath,
@@ -5360,13 +5556,19 @@ function writeSessionSnapshot(plan, targetHome, manifestPath, results, previousM
     manifestPath,
     previousManifest,
     files: existingFiles,
-    afterFiles
+    afterFiles,
+    ...adoptions.length > 0 ? { adoptions } : {},
+    ...reconciliations.length > 0 ? { reconciliations } : {}
   };
+  const snapshotContent = `${JSON.stringify(snapshot, null, 2)}
+`;
+  if ((adoptions.length > 0 || reconciliations.length > 0) && Buffer.byteLength(snapshotContent, "utf8") > 32 * 1024 * 1024) {
+    throw new SessionApplyError("Exact file preimage snapshot exceeds the 32 MiB restore limit.");
+  }
   coordination?.assert_held();
   writeProjectContextCoordinatedFile({
     path: snapshotPath,
-    content: `${JSON.stringify(snapshot, null, 2)}
-`,
+    content: snapshotContent,
     workspace_root: sessionRenderSnapshotWorkspaceRoot(targetHome),
     default_mode: 384,
     expected_hash: null,
@@ -5424,11 +5626,15 @@ function sha2563(content) {
   return createHash3("sha256").update(content).digest("hex");
 }
 
+// src/lib/session-refresh.ts
+import { createHash as createHash4 } from "crypto";
+import { closeSync, constants, fstatSync, lstatSync as lstatSync3, openSync, readFileSync as readFileSync3 } from "fs";
+import { dirname as dirname4, join as join7, parse as parse2, resolve as resolve5 } from "path";
+
 // src/lib/global-source-coverage.ts
 var GLOBAL_SOURCE_SLUG_PREFIX = "global-";
-var RETIRED_GLOBAL_SOURCE_TAG = "retired-global-source";
 function expectedGlobalSourceSlugs(registryConfigs) {
-  return registryConfigs.filter((c) => c.slug.startsWith(GLOBAL_SOURCE_SLUG_PREFIX)).filter((c) => !(c.tags ?? []).includes(RETIRED_GLOBAL_SOURCE_TAG)).map((c) => c.slug).sort();
+  return registryConfigs.filter((c) => c.slug.startsWith(GLOBAL_SOURCE_SLUG_PREFIX)).filter((c) => instructionSourceRejection(c) === null).map((c) => c.slug).sort();
 }
 function accountedGlobalSourceSlugs(manifest) {
   return [...manifest.sources, ...manifest.skippedSources].map((source) => source.id).filter((id) => id.startsWith(GLOBAL_SOURCE_SLUG_PREFIX));
@@ -5441,6 +5647,10 @@ function computeGlobalSourceCoverage(registryConfigs, configuredSlugs) {
   const unexpected = [...configuredSet].filter((slug) => slug.startsWith(GLOBAL_SOURCE_SLUG_PREFIX) && !expectedSet.has(slug)).sort();
   return {
     expectedSlugs: expected,
+    excludedSources: registryConfigs.filter((config) => config.slug.startsWith(GLOBAL_SOURCE_SLUG_PREFIX)).flatMap((config) => {
+      const reason = instructionSourceRejection(config);
+      return reason ? [{ slug: config.slug, reason }] : [];
+    }).sort((left, right) => left.slug.localeCompare(right.slug)),
     configuredSlugs: [...configuredSet].sort(),
     missingSlugs: missing,
     unexpectedSlugs: unexpected,
@@ -5696,6 +5906,176 @@ function stationProfileSource(env = process.env) {
   };
 }
 
+// src/lib/session-refresh.ts
+import { basename } from "path";
+var nonempty = exports_external.string().min(1).max(4096);
+var selectorSchema = exports_external.object({
+  schema: exports_external.literal("hasna.instructions.hosted-profile-selector/v1"),
+  authority: nonempty,
+  profileId: nonempty,
+  providerVersion: nonempty,
+  providerVariant: nonempty.optional(),
+  model: nonempty.optional(),
+  path: nonempty.optional(),
+  manual: exports_external.array(nonempty).max(256),
+  codewithNativeImports: exports_external.boolean(),
+  allowEmptySources: exports_external.boolean(),
+  stationProfile: exports_external.boolean(),
+  checkGlobalCoverage: exports_external.boolean(),
+  assetSurface: nonempty.optional(),
+  assetScope: exports_external.enum(["global", "project", "session"]).optional()
+}).strict();
+function authority(value) {
+  const url = new URL(value);
+  if (url.username || url.password || url.search || url.hash || !["https:", "http:"].includes(url.protocol)) {
+    throw new Error("SESSION_REFRESH_AUTHORITY_INVALID: expected a credential-free Instructions API authority.");
+  }
+  return url.toString().replace(/\/$/, "");
+}
+function normalizeSessionHostedProfileSelector(value) {
+  const parsed = selectorSchema.parse(value);
+  return { ...parsed, authority: authority(parsed.authority) };
+}
+function assertHostedProfileBindings(profileId, configs, bindings) {
+  const configIds = new Set(configs.map((config) => config.id));
+  const bindingIds = new Set(bindings.map((binding) => binding.config_id));
+  if (configIds.size !== configs.length || bindingIds.size !== bindings.length || bindings.some((binding) => binding.profile_id !== profileId || !configIds.has(binding.config_id)) || [...configIds].some((id) => !bindingIds.has(id))) {
+    throw new Error("HOSTED_PROFILE_BINDINGS_INCOMPLETE: exact one-to-one config membership and explicit profile bindings are required; refusing legacy activation fallback.");
+  }
+  for (const row of bindings) {
+    const raw = row.binding;
+    const invalid = () => new Error("HOSTED_PROFILE_BINDINGS_INVALID: each hosted binding must contain a complete explicit schema, activation, required flag and fallback; refusing legacy activation defaults.");
+    if (!raw || typeof raw !== "object" || Array.isArray(raw))
+      throw invalid();
+    const record = raw;
+    if (!["schema", "activation", "required", "fallback"].every((key) => Object.hasOwn(record, key)) || typeof record["required"] !== "boolean")
+      throw invalid();
+    try {
+      normalizeProfileConfigBinding(record);
+    } catch {
+      throw invalid();
+    }
+  }
+}
+function readManagedManifest(targetHome) {
+  const path = join7(targetHome, SESSION_RENDER_MANIFEST_RELATIVE_PATH);
+  let ancestor = dirname4(path);
+  while (true) {
+    const stat = lstatSync3(ancestor);
+    if (stat.isSymbolicLink() || !stat.isDirectory())
+      throw new Error("SESSION_REFRESH_PATH_INVALID: managed target uses a symlink or non-directory ancestor.");
+    const parent = dirname4(ancestor);
+    if (parent === ancestor)
+      break;
+    ancestor = parent;
+  }
+  const fd = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+  let raw;
+  try {
+    const stat = fstatSync(fd);
+    if (!stat.isFile() || stat.size > SESSION_MANAGED_INPUT_MAX_BYTES)
+      throw new Error("SESSION_REFRESH_MANIFEST_INVALID: expected a bounded regular manifest file.");
+    raw = readFileSync3(fd);
+    if (raw.byteLength > SESSION_MANAGED_INPUT_MAX_BYTES)
+      throw new Error("SESSION_REFRESH_MANIFEST_INVALID: manifest grew beyond the read limit.");
+  } finally {
+    closeSync(fd);
+  }
+  const manifest = JSON.parse(raw.toString("utf8"));
+  if (manifest.schema !== SESSION_RENDER_SCHEMA || !SESSION_RENDER_TOOLS.includes(manifest.tool) || manifest.targetHome !== targetHome || !manifest.profile?.trim() || !["session-home", "project-root"].includes(manifest.targetKind) || !Array.isArray(manifest.files) || !manifest.refreshSelector || manifest.targetOwner?.writer?.id !== SESSION_RENDERER_OWNER_ID || manifest.targetOwner?.targetHome !== targetHome) {
+    throw new Error("SESSION_REFRESH_MANIFEST_INVALID: target is not an owned hosted profile render; apply a hosted --compile-profile first.");
+  }
+  manifest.refreshSelector = normalizeSessionHostedProfileSelector(manifest.refreshSelector);
+  return { manifest, sha256: createHash4("sha256").update(raw).digest("hex") };
+}
+async function refreshSessionRender(input) {
+  const { store } = input;
+  if (store.mode !== "api" || !store.v1BaseUrl)
+    throw new Error("SESSION_REFRESH_HOSTED_REQUIRED: refresh requires the configured hosted Instructions API.");
+  const targetHome = resolve5(input.targetHome);
+  if (targetHome === parse2(targetHome).root)
+    throw new Error("SESSION_REFRESH_PATH_INVALID: filesystem root is not a managed target.");
+  const previous = readManagedManifest(targetHome);
+  const selector = previous.manifest.refreshSelector;
+  if (authority(store.v1BaseUrl) !== selector.authority)
+    throw new Error("SESSION_REFRESH_AUTHORITY_MISMATCH: configured API differs from the recorded profile authority.");
+  const profile = await store.getProfile(selector.profileId);
+  if (profile.id !== selector.profileId)
+    throw new Error("SESSION_REFRESH_PROFILE_MISMATCH: hosted profile identity changed.");
+  const [configs, bindings, assetBindings] = await Promise.all([
+    store.getProfileConfigs(profile.id),
+    store.getProfileConfigBindings(profile.id, { requireExplicit: true }),
+    store.getProfileAssetBindings(profile.id, { requireExplicit: true })
+  ]);
+  assertHostedProfileBindings(profile.id, configs, bindings);
+  if (configs.length > 2048 || bindings.length > 8192 || assetBindings.length > 1024)
+    throw new Error("SESSION_REFRESH_INPUT_LIMIT: hosted profile exceeds refresh bounds.");
+  const totalBytes = configs.reduce((sum, config) => sum + Buffer.byteLength(config.content), 0);
+  if (totalBytes > SESSION_MANAGED_INPUT_MAX_BYTES)
+    throw new Error("SESSION_REFRESH_INPUT_LIMIT: hosted instruction payload exceeds refresh byte bounds.");
+  const assetConfigs = await Promise.all([...new Set(assetBindings.map((binding) => binding.source_config_id))].map((id) => store.getConfigById(id)));
+  if (assetConfigs.reduce((sum, config) => sum + Buffer.byteLength(config.content), totalBytes) > SESSION_MANAGED_INPUT_MAX_BYTES)
+    throw new Error("SESSION_REFRESH_INPUT_LIMIT: hosted source and asset payload exceeds refresh byte bounds.");
+  let ownedClaudeAuthorities;
+  if (previous.manifest.tool === "claude") {
+    ownedClaudeAuthorities = (await store.listConfigs({ category: "rules", agent: "claude", kind: "file" })).filter((config) => config.target_path && basename(normalizeTargetPath(config.target_path)) === "AGENTS.md").map((config) => ({ slug: config.slug, targetPath: config.target_path, content: config.content }));
+  }
+  const station = selector.stationProfile ? stationProfileSource() : null;
+  const plan = planProfileSessionRender({
+    tool: previous.manifest.tool,
+    profile: previous.manifest.profile,
+    profile_id: profile.id,
+    provider_version: selector.providerVersion,
+    targetHome,
+    ...previous.manifest.targetKind === "project-root" ? { projectRoot: targetHome } : {},
+    sessionId: previous.manifest.sessionId ?? undefined,
+    refreshSelector: selector,
+    codewithNativeImports: selector.codewithNativeImports,
+    allowEmptySources: selector.allowEmptySources,
+    configs,
+    bindings,
+    asset_configs: assetConfigs,
+    asset_bindings: assetBindings,
+    asset_plan_mode: input.dryRun ? "dry-run" : "apply",
+    asset_scope: selector.assetScope,
+    asset_surface: selector.assetSurface,
+    extra_sources: station ? [station] : undefined,
+    ownedClaudeAuthorities,
+    graph_context: {
+      ...selector.providerVariant ? { provider_variant: selector.providerVariant } : {},
+      ...selector.model ? { model: selector.model } : {},
+      ...selector.path ? { path: selector.path } : {},
+      ...selector.manual.length ? { manual: selector.manual } : {}
+    }
+  });
+  if (selector.checkGlobalCoverage) {
+    const coverage = computeGlobalSourceCoverage(await store.listConfigs({}), accountedGlobalSourceSlugs(plan.manifest));
+    if (!coverage.complete)
+      throw new Error(`SESSION_REFRESH_COVERAGE_INCOMPLETE: ${coverage.missingSlugs.length} registered global sources are absent.`);
+  }
+  const preview = applySessionRender(plan, { dryRun: true, expectedManifestSha256: previous.sha256, ownedClaudeAuthorities });
+  const common = { checkedAt: new Date().toISOString(), targetHome, selector, sourceHash: plan.manifest.sourceHash };
+  if (preview.conflicts.length)
+    return { ...common, status: "blocked", apply: preview };
+  if (!preview.drift.clean)
+    throw new Error("SESSION_REFRESH_DRIFT: generated files changed or disappeared since their last managed render.");
+  const sameSources = previous.manifest.sourceHash === plan.manifest.sourceHash;
+  const samePayloads = preview.files.filter((file) => file.role !== "manifest").every((file) => file.action === "unchanged");
+  if (sameSources && samePayloads) {
+    if (readManagedManifest(targetHome).sha256 !== previous.sha256 || !checkSessionRenderDrift(targetHome).clean)
+      throw new Error("SESSION_REFRESH_DRIFT: managed target changed during refresh.");
+    return { ...common, status: "unchanged", apply: { ...preview, files: preview.files.map((file) => file.role === "manifest" ? { ...file, action: "unchanged", changed: false, newSha256: previous.sha256, reason: "hosted sources and generated payloads unchanged" } : file) } };
+  }
+  if (input.dryRun)
+    return { ...common, status: "dry-run", apply: preview };
+  const applied = applySessionRender(plan, { expectedManifestSha256: previous.sha256, ownedClaudeAuthorities });
+  if (applied.conflicts.length)
+    return { ...common, status: "blocked", apply: applied };
+  if (!applied.applied || !checkSessionRenderDrift(targetHome).clean)
+    throw new Error("SESSION_REFRESH_READBACK_FAILED: applied instructions did not verify against their manifest.");
+  return { ...common, status: "updated", apply: applied };
+}
+
 // src/lib/project-dashboard-standard.ts
 var PROJECT_DASHBOARD_STANDARD_SLUG = "agent-managed-project-dashboard-standard";
 var PROJECT_DASHBOARD_PROFILE_VARIABLES = {
@@ -5788,11 +6168,15 @@ async function ensureProjectDashboardStandardConfig(store = resolveConfigStore()
   };
   try {
     const existing = await store.getConfig(PROJECT_DASHBOARD_STANDARD_SLUG);
+    if (isRetiredInstructionSource(existing))
+      return existing;
     if (existing.content !== input.content || existing.description !== input.description || existing.category !== input.category || existing.agent !== input.agent || existing.format !== input.format || existing.kind !== input.kind) {
       return await store.updateConfig(existing.id, input);
     }
     return existing;
-  } catch {
+  } catch (error) {
+    if (!(error instanceof ConfigNotFoundError))
+      throw error;
     return await store.createConfig(input);
   }
 }
@@ -5805,10 +6189,9 @@ function profileHasSelectors(profile) {
 var PLATFORM_PROFILE_PRESETS = [
   {
     name: "linux-arm64",
-    description: "Default Linux arm64 profile for linux-node-a/linux-node-b-style machines",
-    selectors: { os: ["linux"], arch: ["arm64"], hostnames: ["linux-node-a", "linux-node-b", "station01"] },
+    description: "Default reviewed instruction profile for Linux arm64",
+    selectors: { os: ["linux"], arch: ["arm64"] },
     variables: {
-      WORKSPACE_ROOT: "{{HOME_DIR}}/workspace",
       BUN_BIN_DIR: "{{HOME_DIR}}/.bun/bin",
       BUN_PATH: "{{BUN_BIN_DIR}}/bun",
       PATH_PREFIX: "{{BUN_BIN_DIR}}",
@@ -5817,10 +6200,9 @@ var PLATFORM_PROFILE_PRESETS = [
   },
   {
     name: "macos-arm64",
-    description: "Default macOS arm64 profile for macos-node-a/macos-node-b-style machines",
-    selectors: { os: ["macos"], arch: ["arm64"], hostnames: ["macos-node-a", "macos-node-b"] },
+    description: "Default reviewed instruction profile for macOS arm64",
+    selectors: { os: ["macos"], arch: ["arm64"] },
     variables: {
-      WORKSPACE_ROOT: "{{HOME_DIR}}/Workspace",
       BUN_BIN_DIR: "{{HOME_DIR}}/.bun/bin",
       BUN_PATH: "/opt/homebrew/bin/bun",
       PATH_PREFIX: "/opt/homebrew/bin:{{BUN_BIN_DIR}}",
@@ -5829,12 +6211,21 @@ var PLATFORM_PROFILE_PRESETS = [
   }
 ];
 async function ensurePlatformProfiles(store = resolveConfigStore()) {
-  const configs = await store.listConfigs();
   const ensured = [];
-  for (const preset of PLATFORM_PROFILE_PRESETS) {
-    let profile;
+  const existingProfiles = await Promise.all(PLATFORM_PROFILE_PRESETS.map(async (preset) => {
     try {
-      profile = await store.getProfile(preset.name);
+      return await store.getProfile(preset.name);
+    } catch (error) {
+      if (error instanceof ProfileNotFoundError)
+        return null;
+      throw error;
+    }
+  }));
+  for (const [index, preset] of PLATFORM_PROFILE_PRESETS.entries()) {
+    let profile;
+    const existing = existingProfiles[index];
+    if (existing) {
+      profile = existing;
       const selectors = mergeProfileSelectors(preset.selectors, profile.selectors);
       const variables = mergeProfileVariables(preset.variables, profile.variables);
       if (JSON.stringify(selectors) !== JSON.stringify(profile.selectors) || JSON.stringify(variables) !== JSON.stringify(profile.variables)) {
@@ -5844,12 +6235,9 @@ async function ensurePlatformProfiles(store = resolveConfigStore()) {
           variables
         });
       }
-    } catch {
+    } else {
       profile = await store.createProfile(preset);
     }
-    for (const config of configs) {
-      await store.addConfigToProfile(profile.id, config.id);
-    }
     ensured.push(profile);
   }
   return ensured;
@@ -5990,29 +6378,33 @@ async function ensureDangerousOperationGuardStandardConfig(store = resolveConfig
   };
   try {
     const existing = await store.getConfig(DANGEROUS_OPERATION_GUARD_STANDARD_SLUG);
+    if (isRetiredInstructionSource(existing))
+      return existing;
     if (existing.content !== input.content || existing.description !== input.description || existing.category !== input.category || existing.agent !== input.agent || existing.format !== input.format || existing.kind !== input.kind || JSON.stringify(existing.tags) !== JSON.stringify(input.tags)) {
       return await store.updateConfig(existing.id, input);
     }
     return existing;
-  } catch {
+  } catch (error) {
+    if (!(error instanceof ConfigNotFoundError))
+      throw error;
     return await store.createConfig(input);
   }
 }
 
 // src/lib/managed-skill-runtimes.ts
-import { createHash as createHash4 } from "crypto";
+import { createHash as createHash5 } from "crypto";
 import { spawnSync as spawnSync2 } from "child_process";
 import {
   existsSync as existsSync7,
-  lstatSync as lstatSync3,
+  lstatSync as lstatSync4,
   mkdirSync as mkdirSync4,
-  readFileSync as readFileSync3,
+  readFileSync as readFileSync4,
   renameSync,
   rmSync as rmSync2,
   writeFileSync as writeFileSync3
 } from "fs";
 import { homedir as homedir3 } from "os";
-import { dirname as dirname4, join as join7, parse as parse2, relative as relative2, resolve as resolve5 } from "path";
+import { dirname as dirname5, join as join8, parse as parse3, relative as relative2, resolve as resolve6 } from "path";
 var INBOX_CONVERSATIONS_MINIMUM_VERSION = "0.5.28";
 var INBOX_SKILL_MARKERS = [
   [".claude", "skills", "inbox", "SKILL.md"],
@@ -6023,25 +6415,25 @@ var INBOX_SKILL_MARKERS = [
 ];
 var REQUIRED_WATCH_FLAGS = ["--from <agent>", "--all", "--full-content"];
 function sha2564(content) {
-  return createHash4("sha256").update(content).digest("hex");
+  return createHash5("sha256").update(content).digest("hex");
 }
 function lstatOrNull(path) {
   try {
-    return lstatSync3(path);
+    return lstatSync4(path);
   } catch {
     return null;
   }
 }
 function findSymlinkedAncestor(path) {
-  const normalized = resolve5(path);
-  const parsed = parse2(normalized);
+  const normalized = resolve6(path);
+  const parsed = parse3(normalized);
   let current = parsed.root;
   const rel = relative2(parsed.root, normalized);
   for (const segment of rel.split(/[\\/]+/).filter(Boolean)) {
-    current = join7(current, segment);
+    current = join8(current, segment);
     if (!existsSync7(current))
       return null;
-    if (lstatSync3(current).isSymbolicLink())
+    if (lstatSync4(current).isSymbolicLink())
       return current;
   }
   return null;
@@ -6063,7 +6455,7 @@ function readCanonicalSkill(explicitPath) {
   if (!stat?.isFile()) {
     throw new Error("packaged inbox skill contract is not a regular file");
   }
-  const content = readFileSync3(assetPath, "utf8");
+  const content = readFileSync4(assetPath, "utf8");
   if (!content.includes("conversations watch --from <agent> --all")) {
     throw new Error("packaged inbox skill contract does not declare the canonical conversations watcher");
   }
@@ -6101,7 +6493,7 @@ function compareVersions(left, right) {
   return 0;
 }
 function inspectSkillMarkers(homeDir2) {
-  return INBOX_SKILL_MARKERS.map((parts) => join7(homeDir2, ...parts)).map((path) => {
+  return INBOX_SKILL_MARKERS.map((parts) => join8(homeDir2, ...parts)).map((path) => {
     const stat = lstatOrNull(path);
     if (!stat)
       return null;
@@ -6110,7 +6502,7 @@ function inspectSkillMarkers(homeDir2) {
     }
     return {
       path,
-      content: readFileSync3(path, "utf8"),
+      content: readFileSync4(path, "utf8"),
       mode: stat.mode & 511,
       regular: true
     };
@@ -6145,7 +6537,7 @@ function inspectInbox(options) {
   let reason = "skill not installed";
   if (skillPresent) {
     const nonRegular = snapshots.some((snapshot) => !snapshot.regular);
-    const symlinkAncestor = snapshots.map((snapshot) => snapshot.path).map((path) => findSymlinkedAncestor(dirname4(path))).find((found) => found !== null);
+    const symlinkAncestor = snapshots.map((snapshot) => snapshot.path).map((path) => findSymlinkedAncestor(dirname5(path))).find((found) => found !== null);
     if (nonRegular)
       reason = "managed skill target is not a regular file";
     else if (symlinkAncestor)
@@ -6232,10 +6624,10 @@ function cleanup(path) {
   rmSync2(path, { force: true });
 }
 function writeAtomic(path, content, mode) {
-  assertNoSymlinkAncestors2(dirname4(path));
+  assertNoSymlinkAncestors2(dirname5(path));
   const tempPath = `${path}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`;
   try {
-    mkdirSync4(dirname4(path), { recursive: true, mode: 493 });
+    mkdirSync4(dirname5(path), { recursive: true, mode: 493 });
     writeFileSync3(tempPath, content, { mode, flag: "wx" });
     renameSync(tempPath, path);
   } finally {
@@ -6244,7 +6636,7 @@ function writeAtomic(path, content, mode) {
 }
 var DEFAULT_SKILL_WRITE_FILE_OPERATIONS = {
   lstat: lstatOrNull,
-  read: (path) => readFileSync3(path, "utf8"),
+  read: (path) => readFileSync4(path, "utf8"),
   write: writeAtomic
 };
 function writeSkillContractsTransactional(snapshots, canonicalContent, fileOperations = DEFAULT_SKILL_WRITE_FILE_OPERATIONS) {
@@ -6311,7 +6703,7 @@ async function reconcileManagedSkillRuntimes(options = {}) {
       dry_run: dryRun
     };
   }
-  const symlinkedAncestor = before.snapshots.map((snapshot) => snapshot.path).map((path) => findSymlinkedAncestor(dirname4(path))).find((found) => found !== null);
+  const symlinkedAncestor = before.snapshots.map((snapshot) => snapshot.path).map((path) => findSymlinkedAncestor(dirname5(path))).find((found) => found !== null);
   if (symlinkedAncestor) {
     return {
       runtimes: [{ ...status, action: "failed", dry_run: dryRun, skill_contracts_changed: 0 }],
@@ -6388,28 +6780,28 @@ async function reconcileManagedSkillRuntimes(options = {}) {
 }
 
 // src/status.ts
-import { existsSync as existsSync9, readFileSync as readFileSync5 } from "fs";
+import { existsSync as existsSync9, readFileSync as readFileSync6 } from "fs";
 
 // src/lib/package-version.ts
-import { existsSync as existsSync8, readFileSync as readFileSync4 } from "fs";
-import { dirname as dirname5, join as join8 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync5 } from "fs";
+import { dirname as dirname6, join as join9 } from "path";
 import { fileURLToPath } from "url";
 var cached = null;
 function getPackageVersion() {
   if (cached)
     return cached;
   try {
-    let dir = dirname5(fileURLToPath(import.meta.url));
+    let dir = dirname6(fileURLToPath(import.meta.url));
     for (let i = 0;i < 8; i++) {
-      const pkgPath = join8(dir, "package.json");
+      const pkgPath = join9(dir, "package.json");
       if (existsSync8(pkgPath)) {
-        const pkg = JSON.parse(readFileSync4(pkgPath, "utf8"));
+        const pkg = JSON.parse(readFileSync5(pkgPath, "utf8"));
         if (pkg.name === "@hasna/instructions" && pkg.version) {
           cached = pkg.version;
           return cached;
         }
       }
-      const parent = dirname5(dir);
+      const parent = dirname6(dir);
       if (parent === dir)
         break;
       dir = parent;
@@ -6482,7 +6874,7 @@ async function getConfigsStatus(store = resolveConfigStore(), options = {}) {
       missingTargets += 1;
       continue;
     }
-    const disk = readFileSync5(targetPath, "utf-8");
+    const disk = readFileSync6(targetPath, "utf-8");
     const { content: redactedDisk } = redactContent(disk, redactFormatForTarget(config.target_path, config.format));
     if (redactedDisk !== config.content) {
       driftedTargets += 1;
@@ -6574,9 +6966,9 @@ async function getConfigsStatus(store = resolveConfigStore(), options = {}) {
 }
 
 // src/lib/provider-context.ts
-import { createHash as createHash5 } from "crypto";
-import { existsSync as existsSync10, mkdirSync as mkdirSync5, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "fs";
-import { join as join9 } from "path";
+import { createHash as createHash6 } from "crypto";
+import { existsSync as existsSync10, mkdirSync as mkdirSync5, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "fs";
+import { join as join10 } from "path";
 var PROVIDER_CONTEXT_DIR = ".hasna/provider-context";
 var PROVIDER_CONTEXT_MANIFEST = "manifest.json";
 var PROVIDER_CONTEXT_SCHEMA = "hasna.instructions.provider-context/v1";
@@ -6712,7 +7104,7 @@ function renderProviderFragment(entry) {
   return entry ? renderPerEndpointFragment(entry) : INVARIANT_FRAGMENT;
 }
 function sha2565(content) {
-  return createHash5("sha256").update(content).digest("hex");
+  return createHash6("sha256").update(content).digest("hex");
 }
 function resolveAndRenderProviderContext(opts) {
   const entry = matchProviderEndpoint(opts.origin);
@@ -6721,18 +7113,18 @@ function resolveAndRenderProviderContext(opts) {
   const recordedEndpoint = originAccepted ? `${opts.origin.host}${opts.origin.pathPrefix || ""}` : null;
   const reason = entry === null && opts.rawEndpoint ? originAccepted ? `endpoint "${recordedEndpoint}" is not in the provider-context registry; using the invariant fragment` : "endpoint rejected (embedded credentials or unparseable); using the invariant fragment" : null;
   const content = renderProviderFragment(entry);
-  const dir = join9(opts.homeDir, PROVIDER_CONTEXT_DIR);
+  const dir = join10(opts.homeDir, PROVIDER_CONTEXT_DIR);
   if (!existsSync10(dir))
     mkdirSync5(dir, { recursive: true });
   const filename = `${entry ? entry.key : "invariant"}.md`;
-  const fragmentPath = join9(dir, filename);
+  const fragmentPath = join10(dir, filename);
   const fragmentSha256 = sha2565(content);
   writeFileSync4(fragmentPath, content, "utf8");
-  const manifestPath = join9(dir, PROVIDER_CONTEXT_MANIFEST);
+  const manifestPath = join10(dir, PROVIDER_CONTEXT_MANIFEST);
   let manifest = { schema: PROVIDER_CONTEXT_SCHEMA, fragments: {} };
   try {
     if (existsSync10(manifestPath)) {
-      const parsed = JSON.parse(readFileSync6(manifestPath, "utf8"));
+      const parsed = JSON.parse(readFileSync7(manifestPath, "utf8"));
       if (parsed && typeof parsed === "object")
         manifest = parsed;
     }
@@ -6798,6 +7190,9 @@ function printLine(text = "") {
 function printJson(value) {
   printLine(JSON.stringify(value, null, 2));
 }
+function printMachineJson(value, pretty = false) {
+  printLine(JSON.stringify(value, null, pretty ? 2 : undefined));
+}
 function printManagedSkillRuntimeReport(report) {
   for (const runtime of report.runtimes) {
     if (!runtime.skill_present)
@@ -6819,7 +7214,7 @@ function fmtConfig(c, format) {
     `  ${chalk.cyan("category:")} ${c.category}  ${chalk.cyan("agent:")} ${c.agent}  ${chalk.cyan("kind:")} ${c.kind}`,
     `  ${chalk.cyan("format:")} ${c.format}  ${chalk.cyan("version:")} ${c.version}${c.target_path ? `  ${chalk.cyan("path:")} ${c.target_path}` : ""}`,
     c.description ? `  ${chalk.dim(c.description)}` : "",
-    c.tags.length > 0 ? `  ${chalk.dim("tags: " + c.tags.join(", "))}` : ""
+    c.tags?.length ? `  ${chalk.dim("tags: " + c.tags.join(", "))}` : ""
   ].filter(Boolean).join(`
 `);
 }
@@ -6837,7 +7232,7 @@ function printConfigRows(configs) {
   for (const c of configs) {
     const type = `${c.category}/${c.agent}`;
     const path = c.kind === "reference" ? "(ref)" : c.target_path ?? "(no path)";
-    console.log(`${pad(c.slug, 32)} ${pad(type, 15)} ${pad(c.format, 8)} ${pad(truncateMiddle(path, 44), 44)} ${String(c.outputs.length).padStart(3)} ${c.version}`);
+    console.log(`${pad(c.slug, 32)} ${pad(type, 15)} ${pad(c.format, 8)} ${pad(truncateMiddle(path, 44), 44)} ${String(c.output_count).padStart(3)} ${c.version}`);
   }
 }
 function splitCsv(value) {
@@ -6879,7 +7274,7 @@ function parseSessionSource(value, order) {
     throw new Error(`Instruction source file not found: ${absPath}`);
   const content = readSessionInstructionSourceFile(absPath);
   const source = sourceFromFilePath(absPath, content, order);
-  const resolvedId = id || source.id || basename(absPath);
+  const resolvedId = id || source.id || basename2(absPath);
   return {
     ...source,
     id: resolvedId,
@@ -6919,7 +7314,7 @@ function sessionSourceReplacements(values) {
   return replacements;
 }
 function readSessionInstructionSourceFile(path) {
-  const stat = lstatSync4(path);
+  const stat = lstatSync5(path);
   if (stat.isSymbolicLink()) {
     throw new Error("SESSION_SOURCE_SYMLINK_REJECTED: instruction source file must be a regular non-symlink file");
   }
@@ -6929,7 +7324,7 @@ function readSessionInstructionSourceFile(path) {
   if (stat.size > SESSION_MANAGED_INPUT_MAX_BYTES) {
     throw new Error(`SESSION_SOURCE_INPUT_TOO_LARGE: instruction source file exceeds ${SESSION_MANAGED_INPUT_MAX_BYTES} bytes`);
   }
-  return readFileSync7(path, "utf-8");
+  return readFileSync8(path, "utf-8");
 }
 function parseLayeredReference(value) {
   const trimmed = value.trim();
@@ -6952,13 +7347,15 @@ async function collectSessionSources(opts, tool, store) {
   const sources = (opts.source ?? []).map((value, index) => parseSessionSource(value, index));
   for (const value of opts.config ?? []) {
     const { layer, id } = parseLayeredReference(value);
-    sources.push(sourceFromConfig(await store.getConfig(id), sources.length, layer));
+    const config = await store.getConfig(id);
+    assertInstructionSource(config);
+    sources.push(sourceFromConfig(config, sources.length, layer));
   }
   for (const value of opts.identityExport ?? []) {
     const path = resolveSessionPath(value);
     if (!existsSync11(path))
       throw new Error(`Identity instruction export not found: ${path}`);
-    const parsed = JSON.parse(readFileSync7(path, "utf-8"));
+    const parsed = JSON.parse(readFileSync8(path, "utf-8"));
     sources.push(...sourcesFromIdentityExport(parsed, { path, tool, orderOffset: sources.length }));
   }
   return sources.map((source) => {
@@ -6974,7 +7371,7 @@ async function collectSessionSources(opts, tool, store) {
 }
 async function loadOwnedClaudeAuthorities(store) {
   const configs = await store.listConfigs({ category: "rules", agent: "claude", kind: "file" });
-  return configs.filter((config) => config.target_path && basename(normalizeTargetPath(config.target_path)) === "AGENTS.md").map((config) => ({ slug: config.slug, targetPath: config.target_path, content: config.content }));
+  return configs.filter((config) => config.target_path && basename2(normalizeTargetPath(config.target_path)) === "AGENTS.md").map((config) => ({ slug: config.slug, targetPath: config.target_path, content: config.content }));
 }
 async function buildSessionRenderPlan(opts, tool, store, assetPlanMode = "dry-run") {
   const station = opts.stationProfile === false ? null : stationProfileSource();
@@ -7004,8 +7401,10 @@ async function buildSessionRenderPlan(opts, tool, store, assetPlanMode = "dry-ru
   }
   const profile = await store.getProfile(opts.compileProfile);
   const configs = await store.getProfileConfigs(profile.id);
-  const bindings = await store.getProfileConfigBindings(profile.id);
-  const assetBindings = await store.getProfileAssetBindings(profile.id);
+  const bindings = await store.getProfileConfigBindings(profile.id, { requireExplicit: store.mode === "api" });
+  if (store.mode === "api")
+    assertHostedProfileBindings(profile.id, configs, bindings);
+  const assetBindings = await store.getProfileAssetBindings(profile.id, { requireExplicit: store.mode === "api" });
   const assetConfigs = await Promise.all([...new Set(assetBindings.map((binding) => binding.source_config_id))].map((id) => store.getConfigById(id)));
   return planProfileSessionRender({
     profile_id: profile.id,
@@ -7015,6 +7414,24 @@ async function buildSessionRenderPlan(opts, tool, store, assetPlanMode = "dry-ru
     targetHome: opts.targetHome,
     projectRoot: opts.projectRoot,
     sessionId: opts.sessionId,
+    ...store.mode === "api" && store.v1BaseUrl ? {
+      refreshSelector: normalizeSessionHostedProfileSelector({
+        schema: "hasna.instructions.hosted-profile-selector/v1",
+        authority: store.v1BaseUrl,
+        profileId: profile.id,
+        providerVersion: opts.providerVersion,
+        ...opts.providerVariant ? { providerVariant: opts.providerVariant } : {},
+        ...opts.model ? { model: opts.model } : {},
+        ...opts.path ? { path: opts.path } : {},
+        manual: opts.manual ?? [],
+        codewithNativeImports: opts.codewithNativeImports === true || process.env[CODEWITH_NATIVE_IMPORTS_ENV] === "1" || process.env[CODEWITH_NATIVE_IMPORTS_ENV] === "true",
+        allowEmptySources: opts.allowEmptySources === true,
+        stationProfile: opts.stationProfile !== false,
+        checkGlobalCoverage: opts.checkGlobalCoverage === true,
+        ...opts.assetSurface ? { assetSurface: opts.assetSurface } : {},
+        ...opts.assetScope ? { assetScope: opts.assetScope } : {}
+      })
+    } : {},
     codewithNativeImports: opts.codewithNativeImports,
     allowEmptySources: opts.allowEmptySources,
     configs,
@@ -7095,14 +7512,14 @@ function readProjectContextBundleOption(value, allowMissing = false) {
       return {};
     throw new ProjectContextError("PROJECT_CONTEXT_INPUT_MISSING", `bundle file not found: ${path}`);
   }
-  const stat = lstatSync4(path);
+  const stat = lstatSync5(path);
   if (stat.isSymbolicLink() || !stat.isFile()) {
     throw new ProjectContextError("PROJECT_CONTEXT_SYMLINK_REJECTED", "bundle input must be a regular non-symlink file");
   }
   if (stat.size > PROJECT_CONTEXT_MAX_INPUT_BYTES) {
     throw new ProjectContextError("PROJECT_CONTEXT_INPUT_TOO_LARGE", `bundle exceeds ${PROJECT_CONTEXT_MAX_INPUT_BYTES} bytes`);
   }
-  return { json: readFileSync7(path, "utf8"), sourcePath: path };
+  return { json: readFileSync8(path, "utf8"), sourcePath: path };
 }
 function readBoundedProjectContextStdin() {
   const chunks = [];
@@ -7189,24 +7606,245 @@ async function getMachineProfileContext(opts, store, readOptions = {}) {
   const profile = resolution.profile;
   return { machine, profile, resolution, vars: resolveProfileVariables(profile, machine) };
 }
-program.command("list").alias("ls").description("List stored configs").option("-c, --category <cat>", "filter by category").option("-a, --agent <agent>", "filter by agent").option("-k, --kind <kind>", "filter by kind (file|reference)").option("-t, --tag <tag>", "filter by tag").option("-s, --search <query>", "search name/description/content").option("-f, --format <fmt>", "output format: compact|table|json", "compact").option("--brief", "shorthand for --format compact").option("--verbose", "show expanded metadata for each listed config").option("--json", "output full matching records as JSON").option("--limit <n>", `max rows for human output (default ${DEFAULT_LIST_LIMIT})`).option("--cursor <n>", "zero-based pagination cursor for human output").action(async (opts) => {
-  const fmt = opts.json ? "json" : opts.verbose ? "table" : opts.brief ? "compact" : opts.format;
-  const configs = await resolveConfigStore().listConfigs({
+var COMPACT_CONFIG_FIELDS = [
+  "id",
+  "slug",
+  "name",
+  "kind",
+  "category",
+  "agent",
+  "format",
+  "is_template",
+  "version",
+  "updated_at"
+];
+var OPTIONAL_CONFIG_IDENTITY_FIELDS = ["created_at", "synced_at"];
+var FULL_CONFIG_FIELDS = [
+  "id",
+  "name",
+  "slug",
+  "kind",
+  "category",
+  "agent",
+  "target_path",
+  "outputs",
+  "format",
+  "content",
+  "description",
+  "tags",
+  "is_template",
+  "version",
+  "created_at",
+  "updated_at",
+  "synced_at"
+];
+function parseConfigListDetail(value) {
+  if (value === undefined)
+    return;
+  if (value === "compact" || value === "full")
+    return value;
+  throw new Error('--detail must be "compact" or "full"');
+}
+function parseConfigListFields(value, detail) {
+  if (value === undefined)
+    return;
+  const raw = String(value);
+  if (raw.length > 1024)
+    throw new Error("--fields exceeds 1024 characters");
+  const fields = raw.split(",").map((field) => field.trim());
+  if (fields.length === 0 || fields.some((field) => field.length === 0)) {
+    throw new Error("--fields must contain non-empty comma-separated field names");
+  }
+  if (fields.length > 32)
+    throw new Error("--fields accepts at most 32 fields");
+  if (new Set(fields).size !== fields.length)
+    throw new Error("--fields must not contain duplicate names");
+  const allowed = new Set(detail === "full" ? FULL_CONFIG_FIELDS : [...COMPACT_CONFIG_FIELDS, ...OPTIONAL_CONFIG_IDENTITY_FIELDS]);
+  const unknown = fields.filter((field) => !allowed.has(field));
+  if (unknown.length > 0)
+    throw new Error(`Unknown ${detail} config field(s): ${unknown.join(", ")}`);
+  if (!fields.includes("id"))
+    throw new Error("--fields must include the immutable id field");
+  if (detail !== "full" && fields.includes("content")) {
+    throw new Error("Config content requires --detail full");
+  }
+  return fields;
+}
+function projectConfigFields(record, fields) {
+  return Object.fromEntries(fields.map((field) => [field, record[field]]));
+}
+async function readAllConfigIdentityPages(store, filter) {
+  const items = [];
+  const seen = new Set;
+  let cursor = 0;
+  let expectedTotal = null;
+  let sourceBounded = true;
+  let previousId = null;
+  while (true) {
+    const page = await store.listConfigIdentitiesPage(filter, { limit: 100, cursor });
+    sourceBounded = sourceBounded && page.source_bounded;
+    if (expectedTotal === null)
+      expectedTotal = page.total;
+    else if (page.total !== expectedTotal)
+      throw new Error("Config collection changed while paging");
+    for (const item of page.items) {
+      if (seen.has(item.id))
+        throw new Error(`Config collection repeated ${item.id} while paging`);
+      if (page.source_bounded && previousId !== null && item.id <= previousId)
+        throw new Error("Config collection order changed while paging");
+      seen.add(item.id);
+      previousId = page.source_bounded ? item.id : null;
+      items.push(item);
+    }
+    if (page.next_cursor === null)
+      break;
+    if (page.next_cursor <= cursor)
+      throw new Error("Config identity pagination did not advance");
+    cursor = page.next_cursor;
+  }
+  if (expectedTotal !== null && items.length !== expectedTotal) {
+    throw new Error(`Config collection returned ${items.length} of ${expectedTotal} rows`);
+  }
+  return { items, source_bounded: sourceBounded };
+}
+async function readAllConfigPages(store, filter) {
+  const items = [];
+  const seen = new Set;
+  let cursor = 0;
+  let expectedTotal = null;
+  let sourceBounded = true;
+  let previousId = null;
+  while (true) {
+    const page = await store.listConfigsPage(filter, { limit: 100, cursor });
+    sourceBounded = sourceBounded && page.source_bounded;
+    if (expectedTotal === null)
+      expectedTotal = page.total;
+    else if (page.total !== expectedTotal)
+      throw new Error("Config collection changed while paging");
+    for (const item of page.items) {
+      if (seen.has(item.id))
+        throw new Error(`Config collection repeated ${item.id} while paging`);
+      if (page.source_bounded && previousId !== null && item.id <= previousId)
+        throw new Error("Config collection order changed while paging");
+      seen.add(item.id);
+      previousId = page.source_bounded ? item.id : null;
+      items.push(item);
+    }
+    if (page.next_cursor === null)
+      break;
+    if (page.next_cursor <= cursor)
+      throw new Error("Config pagination did not advance");
+    cursor = page.next_cursor;
+  }
+  if (expectedTotal !== null && items.length !== expectedTotal) {
+    throw new Error(`Config collection returned ${items.length} of ${expectedTotal} rows`);
+  }
+  return { items, source_bounded: sourceBounded };
+}
+function configListEnvelope(records, page, detail, fields) {
+  const complete = page.cursor === 0 && !page.has_more;
+  const truncated = !complete;
+  const truncationReason = page.cursor > 0 ? page.has_more ? "cursor_and_limit" : "cursor" : page.has_more ? "limit" : null;
+  return {
+    configs: records,
+    _meta: {
+      schema_version: 1,
+      count: records.length,
+      total: page.total,
+      limit: page.limit,
+      cursor: page.cursor,
+      next_cursor: page.next_cursor,
+      has_more: page.has_more,
+      complete,
+      truncated,
+      truncation_reason: truncationReason,
+      detail,
+      fields: [...fields],
+      source_bounded: page.source_bounded
+    }
+  };
+}
+program.command("list").alias("ls").description("List stored configs").option("-c, --category <cat>", "filter by category").option("-a, --agent <agent>", "filter by agent").option("-k, --kind <kind>", "filter by kind (file|reference)").option("-t, --tag <tag>", "filter by tag").option("-s, --search <query>", "search name/description/content").option("-f, --format <fmt>", "output format: compact|table|json", "compact").option("--brief", "shorthand for --format compact").option("--verbose", "show expanded metadata for each listed config").option("--json", "output machine-readable records (legacy default: complete full array)").option("--detail <level>", "JSON detail: compact|full; enables a bounded metadata envelope").option("--fields <fields>", "comma-separated JSON fields; implies --detail compact").option("--all", "explicitly read every matching row").option("--pretty", "pretty-print modern JSON output (modern JSON is compact by default)").option("--limit <n>", `max rows (default ${DEFAULT_LIST_LIMIT} for bounded output)`).option("--cursor <n>", "zero-based pagination cursor").action(async (opts) => {
+  const requestedDetail = parseConfigListDetail(opts.detail);
+  const modernJson = requestedDetail !== undefined || opts.fields !== undefined;
+  const jsonRequested = Boolean(opts.json || opts.format === "json");
+  if (modernJson && !jsonRequested)
+    throw new Error("--detail and --fields require JSON output");
+  if (opts.all && !modernJson)
+    throw new Error("--all requires JSON output with --detail or --fields");
+  if (opts.pretty && !jsonRequested)
+    throw new Error("--pretty requires JSON output");
+  const detail = requestedDetail ?? "compact";
+  const fields = parseConfigListFields(opts.fields, detail) ?? (detail === "full" ? [...FULL_CONFIG_FIELDS] : [...COMPACT_CONFIG_FIELDS]);
+  const filter = {
     category: opts.category,
     agent: opts.agent,
     kind: opts.kind,
     tags: opts.tag ? [opts.tag] : undefined,
     search: opts.search
-  });
+  };
+  const store = resolveConfigStore();
+  if (modernJson) {
+    if (opts.all && (opts.cursor !== undefined || opts.limit !== undefined)) {
+      throw new Error("--all cannot be combined with --limit or --cursor");
+    }
+    let page2;
+    if (opts.all) {
+      if (detail === "full") {
+        const completeRead = await readAllConfigPages(store, filter);
+        page2 = {
+          items: completeRead.items,
+          total: completeRead.items.length,
+          limit: Math.max(completeRead.items.length, 1),
+          cursor: 0,
+          next_cursor: null,
+          has_more: false,
+          complete: true,
+          truncated: false,
+          source_bounded: completeRead.source_bounded
+        };
+      } else {
+        const completeRead = await readAllConfigIdentityPages(store, filter);
+        page2 = {
+          items: completeRead.items,
+          total: completeRead.items.length,
+          limit: Math.max(completeRead.items.length, 1),
+          cursor: 0,
+          next_cursor: null,
+          has_more: false,
+          complete: true,
+          truncated: false,
+          source_bounded: completeRead.source_bounded
+        };
+      }
+    } else {
+      page2 = detail === "full" ? await store.listConfigsPage(filter, { limit: opts.limit, cursor: opts.cursor }) : await store.listConfigIdentitiesPage(filter, { limit: opts.limit, cursor: opts.cursor });
+    }
+    const records = page2.items.map((item) => projectConfigFields(item, fields));
+    printMachineJson(configListEnvelope(records, {
+      total: page2.total,
+      limit: opts.all ? null : page2.limit,
+      cursor: page2.cursor,
+      next_cursor: page2.next_cursor,
+      has_more: page2.has_more,
+      complete: page2.complete,
+      source_bounded: page2.source_bounded
+    }, detail, fields), Boolean(opts.pretty));
+    return;
+  }
+  const fmt = opts.json ? "json" : opts.verbose ? "table" : opts.brief ? "compact" : opts.format;
   if (fmt === "json") {
+    const configs = opts.limit !== undefined || opts.cursor !== undefined ? (await store.listConfigsPage(filter, { limit: opts.limit, cursor: opts.cursor })).items : await store.listConfigs(filter);
     printJson(configs);
     return;
   }
-  if (configs.length === 0) {
+  const page = opts.all ? (() => {
+    throw new Error("--all is only available with --json and --detail");
+  })() : await store.listConfigSummariesPage(filter, { limit: opts.limit, cursor: opts.cursor });
+  if (page.total === 0) {
     console.log(chalk.dim("No configs found."));
     return;
   }
-  const page = paginate(configs, { limit: opts.limit, cursor: opts.cursor });
   if (fmt === "compact") {
     printConfigRows(page.items);
   } else {
@@ -7215,7 +7853,7 @@ program.command("list").alias("ls").description("List stored configs").option("-
       console.log();
     }
   }
-  pageFooter("configs list", page, "Use --verbose for expanded rows, --json for full records, or `configs show <slug>` for content.");
+  pageFooter("configs list", page, "Use --verbose for expanded rows, --json --detail compact for metadata, or `configs show <slug>` for content.");
 });
 program.command("show <id>").alias("inspect").description("Show a config's content and metadata").option("-f, --format <fmt>", "output format: table|json|content", "table").action(async (id, opts) => {
   try {
@@ -7260,13 +7898,18 @@ program.command("tag <id>").description("Add or remove tags on a stored config (
   }
   console.log(chalk.green("\u2713") + ` Tags on ${chalk.bold(updated.name)} ${chalk.dim(`(${updated.slug})`)}: ${nextTags.join(", ") || chalk.dim("(none)")}`);
 });
-program.command("add <path>").description("Ingest a file into the config DB").option("-n, --name <name>", "config name (defaults to filename)").option("-c, --category <cat>", "category override").option("-a, --agent <agent>", "agent override").option("-k, --kind <kind>", "kind: file|reference", "file").option("--template", "mark as template (has {{VAR}} placeholders)").option("--update", "if a config already owns this path, update that row in place instead of refusing").action(async (filePath, opts) => {
-  const abs = resolve6(filePath);
+program.command("add <path>").description("Ingest a file into the config DB").option("-n, --name <name>", "config name (defaults to filename)").option("-c, --category <cat>", "category override").option("-a, --agent <agent>", "agent override").option("-k, --kind <kind>", "kind: file|reference", "file").option("--template", "mark as template (has {{VAR}} placeholders)").option("--update", "if a config already owns this path, update that row in place instead of refusing").option("--expected-version <version>", "with --update, require the stored version to match atomically").action(async (filePath, opts) => {
+  const expectedVersion = opts.expectedVersion === undefined ? undefined : Number(opts.expectedVersion);
+  validateExpectedConfigVersion(expectedVersion);
+  if (expectedVersion !== undefined && !opts.update) {
+    throw new Error("--expected-version requires --update");
+  }
+  const abs = resolve7(filePath);
   if (!existsSync11(abs)) {
     console.error(chalk.red(`File not found: ${abs}`));
     process.exit(1);
   }
-  const rawContent = readFileSync7(abs, "utf-8");
+  const rawContent = readFileSync8(abs, "utf-8");
   const storedFmt = detectFormat(abs);
   const fmt = redactFormatForTarget(abs, storedFmt);
   const { content, redacted, isTemplate } = redactContent(rawContent, fmt);
@@ -7297,10 +7940,11 @@ program.command("add <path>").description("Ingest a file into the config DB").op
     const exactIndex = isReference ? existingOwners.findIndex((owner) => owner.name === name) : -1;
     const target = exactIndex >= 0 ? existingOwners[exactIndex] : existingOwners[0];
     const rest = existingOwners.filter((owner) => owner.id !== target.id);
-    if (content !== target.content) {
+    if (content !== target.content && expectedVersion === undefined) {
       await store.createSnapshot(target.id, target.content, target.version);
     }
     config = await store.updateConfig(target.id, {
+      expected_version: expectedVersion,
       content,
       format: storedFmt,
       is_template: (opts.template ?? false) || isTemplate,
@@ -7317,6 +7961,9 @@ program.command("add <path>").description("Ingest a file into the config DB").op
     }
     return;
   }
+  if (expectedVersion !== undefined) {
+    throw new Error("--expected-version requires an existing config; no config was created");
+  }
   config = await store.createConfig({
     name,
     kind: opts.kind ?? "file",
@@ -7445,7 +8092,7 @@ program.command("sync").description("Sync known AI coding configs from disk into
       for (const entry of entries) {
         if (!entry.isDirectory())
           continue;
-        const projDir = join10(absDir, entry.name);
+        const projDir = join11(absDir, entry.name);
         const hasAgentConfig = [
           "CLAUDE.md",
           ".mcp.json",
@@ -7458,7 +8105,7 @@ program.command("sync").description("Sync known AI coding configs from disk into
           ".aicopilot",
           ".cursor",
           ".agents"
-        ].some((marker) => existsSync11(join10(projDir, marker)));
+        ].some((marker) => existsSync11(join11(projDir, marker)));
         if (!hasAgentConfig)
           continue;
         const result2 = await syncProject({ projectDir: projDir, dryRun: opts.dryRun, store });
@@ -7506,7 +8153,7 @@ program.command("import <file>").description("Restore a v2 Instructions domain a
 });
 program.command("whoami").description("Show setup summary").action(async () => {
   const store = resolveConfigStore();
-  const dbPath = store.mode === "api" ? store.v1BaseUrl : process.env["HASNA_INSTRUCTIONS_DB_PATH"] || join10(getRawStoreRoot(), "instructions.db");
+  const dbPath = store.mode === "api" ? store.v1BaseUrl : process.env["HASNA_INSTRUCTIONS_DB_PATH"] || join11(getRawStoreRoot(), "instructions.db");
   const stats = await store.getConfigStats();
   console.log(chalk.bold("@hasna/instructions") + chalk.dim(" v" + pkg.version));
   console.log(chalk.cyan(store.mode === "api" ? "API:" : "DB:") + " " + dbPath);
@@ -7890,7 +8537,7 @@ projectContextCmd.command("apply").description("Atomically write project context
   }
 });
 var sessionCmd = program.command("session").description("Plan and apply session-scoped agent instruction files");
-sessionCmd.command("plan").description("Produce a dry-run render plan for profile-scoped instruction injection").requiredOption("--tool <tool>", `target tool (${SESSION_RENDER_TOOLS.join("|")})`).requiredOption("--profile <profile>", "account/profile name that owns the rendered instruction home").option("--target-home <path>", "native instruction home; Grok: GROK_HOME, Devin: user config directory (global AGENTS.md unless --project-root is set)").option("--project-root <path>", "repository root for project-scoped adapters such as Cursor").option("--session-id <id>", "session id to include in the manifest").option("--source <layer:id=path>", `instruction source file; layers: ${SESSION_SOURCE_LAYER_HELP}`, collectOption, []).option("--config <layer:id-or-slug>", "stored config source by id/slug; repeatable; layer aliases match --source", collectOption, []).option("--identity-export <path>", "OpenIdentities configs instruction export JSON; repeatable", collectOption, []).option("--replace-source <replacer-id>[=<target-source-id>]", "source id that broadly replaces earlier layers, or targets one earlier source", collectOption, []).option("--compile-profile <id-or-slug>", "compile persisted config bindings from this Instructions profile").option("--provider-version <semver>", "installed provider version used for capability matching").option("--provider-variant <variant>", "explicit provider capability variant (for example OpenCode v2-agents)").option("--model <model>", "active model used for model activation").option("--path <path>", "active path recorded in the graph context").option("--manual <config-id-or-slug>", "manually activate a binding; repeatable", collectOption, []).option("--asset-surface <surface>", "explicit provider asset surface (for example cline cli or ide)").option("--asset-scope <scope>", "asset scope (global|project|session)").option("--allow-asset-installers", "opt in to planned provider installers; planning never invokes them").option("--codewith-native-imports", "select the gated Codewith native @ import adapter").option("--allow-empty-sources", "allow an explicit empty render plan").option("--check-global-coverage", "verify every registered, non-retired global-* source is in this render (expected read fresh from the registry, independent of this plan); on shortfall warn, exit non-zero, and for apply refuse to write (todos 102d6d0a, O15-00694)").option("--no-station-profile", "do not inject the cached station-profile source").option("--json", "output dry-run JSON").action(async (opts) => {
+sessionCmd.command("plan").description("Produce a dry-run render plan for profile-scoped instruction injection").requiredOption("--tool <tool>", `target tool (${SESSION_RENDER_TOOLS.join("|")})`).requiredOption("--profile <profile>", "account/profile name that owns the rendered instruction home").option("--target-home <path>", "native instruction home; Sumi: resolved config from `sumi debug paths config`; Grok: GROK_HOME; Devin: user config directory (global AGENTS.md unless --project-root is set)").option("--project-root <path>", "repository root for project-scoped adapters such as Cursor").option("--session-id <id>", "session id to include in the manifest").option("--source <layer:id=path>", `instruction source file; layers: ${SESSION_SOURCE_LAYER_HELP}`, collectOption, []).option("--config <layer:id-or-slug>", "stored config source by id/slug; repeatable; layer aliases match --source", collectOption, []).option("--identity-export <path>", "OpenIdentities configs instruction export JSON; repeatable", collectOption, []).option("--replace-source <replacer-id>[=<target-source-id>]", "source id that broadly replaces earlier layers, or targets one earlier source", collectOption, []).option("--compile-profile <id-or-slug>", "compile persisted config bindings from this Instructions profile").option("--provider-version <semver>", "installed provider version used for capability matching").option("--provider-variant <variant>", "explicit provider capability variant (for example OpenCode v2-agents)").option("--model <model>", "active model used for model activation").option("--path <path>", "active path recorded in the graph context").option("--manual <config-id-or-slug>", "manually activate a binding; repeatable", collectOption, []).option("--asset-surface <surface>", "explicit provider asset surface (for example cline cli or ide)").option("--asset-scope <scope>", "asset scope (global|project|session)").option("--allow-asset-installers", "opt in to planned provider installers; planning never invokes them").option("--codewith-native-imports", "select the gated Codewith native @ import adapter").option("--allow-empty-sources", "allow an explicit empty render plan").option("--check-global-coverage", "verify every registered, non-retired global-* source is in this render (expected read fresh from the registry, independent of this plan); on shortfall warn, exit non-zero, and for apply refuse to write (todos 102d6d0a, O15-00694)").option("--no-station-profile", "do not inject the cached station-profile source").option("--json", "output dry-run JSON").action(async (opts) => {
   try {
     const tool = opts.tool;
     if (!SESSION_RENDER_TOOLS.includes(tool)) {
@@ -7945,7 +8592,7 @@ sessionCmd.command("plan").description("Produce a dry-run render plan for profil
     process.exit(1);
   }
 });
-sessionCmd.command("apply").description("Write a session render plan to its managed target home or explicit project root").requiredOption("--tool <tool>", `target tool (${SESSION_RENDER_TOOLS.join("|")})`).requiredOption("--profile <profile>", "account/profile name that owns the rendered instruction home").option("--target-home <path>", "native instruction home; Grok: GROK_HOME, Devin: user config directory (global AGENTS.md unless --project-root is set)").option("--project-root <path>", "repository root for project-scoped adapters such as Cursor").option("--session-id <id>", "session id to include in the manifest").option("--source <layer:id=path>", `instruction source file; layers: ${SESSION_SOURCE_LAYER_HELP}`, collectOption, []).option("--config <layer:id-or-slug>", "stored config source by id/slug; repeatable; layer aliases match --source", collectOption, []).option("--identity-export <path>", "OpenIdentities configs instruction export JSON; repeatable", collectOption, []).option("--replace-source <replacer-id>[=<target-source-id>]", "source id that broadly replaces earlier layers, or targets one earlier source", collectOption, []).option("--compile-profile <id-or-slug>", "compile persisted config bindings from this Instructions profile").option("--provider-version <semver>", "installed provider version used for capability matching").option("--provider-variant <variant>", "explicit provider capability variant (for example OpenCode v2-agents)").option("--model <model>", "active model used for model activation").option("--path <path>", "active path recorded in the graph context").option("--manual <config-id-or-slug>", "manually activate a binding; repeatable", collectOption, []).option("--asset-surface <surface>", "explicit provider asset surface (for example cline cli or ide)").option("--asset-scope <scope>", "asset scope (global|project|session)").option("--codewith-native-imports", "select the gated Codewith native @ import adapter").option("--allow-empty-sources", "allow an explicit empty render").option("--check-global-coverage", "verify every registered, non-retired global-* source is in this render (expected read fresh from the registry, independent of this plan); on shortfall warn, exit non-zero, and for apply refuse to write (todos 102d6d0a, O15-00694)").option("--no-station-profile", "do not inject the cached station-profile source").option("--dry-run", "preview writes and conflicts without writing").option("--force", "overwrite existing unmanaged files").option("--json", "output apply JSON").action(async (opts) => {
+sessionCmd.command("apply").description("Write a session render plan to its managed target home or explicit project root").requiredOption("--tool <tool>", `target tool (${SESSION_RENDER_TOOLS.join("|")})`).requiredOption("--profile <profile>", "account/profile name that owns the rendered instruction home").option("--target-home <path>", "native instruction home; Sumi: resolved config from `sumi debug paths config`; Grok: GROK_HOME; Devin: user config directory (global AGENTS.md unless --project-root is set)").option("--project-root <path>", "repository root for project-scoped adapters such as Cursor").option("--session-id <id>", "session id to include in the manifest").option("--source <layer:id=path>", `instruction source file; layers: ${SESSION_SOURCE_LAYER_HELP}`, collectOption, []).option("--config <layer:id-or-slug>", "stored config source by id/slug; repeatable; layer aliases match --source", collectOption, []).option("--identity-export <path>", "OpenIdentities configs instruction export JSON; repeatable", collectOption, []).option("--replace-source <replacer-id>[=<target-source-id>]", "source id that broadly replaces earlier layers, or targets one earlier source", collectOption, []).option("--compile-profile <id-or-slug>", "compile persisted config bindings from this Instructions profile").option("--provider-version <semver>", "installed provider version used for capability matching").option("--provider-variant <variant>", "explicit provider capability variant (for example OpenCode v2-agents)").option("--model <model>", "active model used for model activation").option("--path <path>", "active path recorded in the graph context").option("--manual <config-id-or-slug>", "manually activate a binding; repeatable", collectOption, []).option("--asset-surface <surface>", "explicit provider asset surface (for example cline cli or ide)").option("--asset-scope <scope>", "asset scope (global|project|session)").option("--codewith-native-imports", "select the gated Codewith native @ import adapter").option("--allow-empty-sources", "allow an explicit empty render").option("--check-global-coverage", "verify every registered, non-retired global-* source is in this render (expected read fresh from the registry, independent of this plan); on shortfall warn, exit non-zero, and for apply refuse to write (todos 102d6d0a, O15-00694)").option("--no-station-profile", "do not inject the cached station-profile source").option("--dry-run", "preview writes and conflicts without writing").option("--force", "overwrite existing unmanaged files").option("--adopt-file <relativepath=sha256>", "adopt one reviewed unmanaged generated target only at its exact observed SHA256; repeatable", collectOption, []).option("--reconcile-file <relativepath=sha256>", "reconcile one reviewed managed drifted target at its exact observed SHA256; requires --expected-manifest-sha256", collectOption, []).option("--expected-manifest-sha256 <sha256>", "require the previously reviewed manifest preimage to match exactly before applying").option("--json", "output apply JSON").action(async (opts) => {
   try {
     const tool = opts.tool;
     if (!SESSION_RENDER_TOOLS.includes(tool)) {
@@ -7971,7 +8618,15 @@ sessionCmd.command("apply").description("Write a session render plan to its mana
       return;
     }
     const ownedClaudeAuthorities = tool === "claude" ? await loadOwnedClaudeAuthorities(store) : undefined;
-    const result = applySessionRender(plan, { dryRun: opts.dryRun, force: opts.force, ownedClaudeAuthorities });
+    const parsePreimages = (values, option) => values.map((value) => {
+      const separator = value.lastIndexOf("=");
+      if (separator <= 0)
+        throw new Error(`${option} requires relativepath=sha256.`);
+      return { relativePath: value.slice(0, separator), sha256: value.slice(separator + 1) };
+    });
+    const adoptFiles = parsePreimages(opts.adoptFile, "--adopt-file");
+    const reconcileFiles = parsePreimages(opts.reconcileFile, "--reconcile-file");
+    const result = applySessionRender(plan, { dryRun: opts.dryRun, force: opts.force, adoptFiles, reconcileFiles, expectedManifestSha256: opts.expectedManifestSha256, ownedClaudeAuthorities });
     if (opts.json) {
       printJson({
         ...result,
@@ -8012,7 +8667,7 @@ sessionCmd.command("apply").description("Write a session render plan to its mana
         console.log(chalk.dim(`global source coverage: ${globalCoverage.expectedSlugs.length}/${globalCoverage.expectedSlugs.length} complete`));
     }
     if (result.conflicts.length > 0) {
-      console.error(chalk.red(`Conflicts: ${result.conflicts.length}. Re-run with --force to overwrite unmanaged files.`));
+      console.error(chalk.red(`Conflicts: ${result.conflicts.length}. Review and import existing instructions before adopting each exact preimage with --adopt-file.`));
       process.exitCode = 1;
     }
   } catch (e) {
@@ -8020,6 +8675,29 @@ sessionCmd.command("apply").description("Write a session render plan to its mana
     process.exit(1);
   }
 });
+sessionCmd.command("refresh").description("Fetch the recorded hosted profile, recompile and safely update a managed target; unchanged output is not rewritten").requiredOption("--target-home <path>", "existing managed global or project target containing its hosted profile selector").option("--dry-run", "fetch authoritative sources and preview without writing").option("--json", "output refresh receipt without instruction content").action(async (opts) => {
+  try {
+    const result = await refreshSessionRender({ targetHome: resolveSessionPath(opts.targetHome), store: resolveConfigStore(), dryRun: opts.dryRun });
+    if (opts.json)
+      printJson(result);
+    else {
+      console.log(`${result.status}: ${result.targetHome}`);
+      console.log(`hosted profile: ${result.selector.profileId}`);
+      console.log(`source hash: ${result.sourceHash}`);
+      if (result.apply.snapshotPath)
+        console.log(`snapshot: ${result.apply.snapshotPath}`);
+    }
+    if (result.status === "blocked")
+      process.exitCode = 1;
+  } catch (error) {
+    const message = formatCliError(error);
+    if (opts.json)
+      printJson({ status: "failed", error: message });
+    else
+      console.error(chalk.red(message));
+    process.exitCode = 1;
+  }
+});
 sessionCmd.command("restore <snapshot>").description("Restore a session render snapshot only when applied files have not drifted").option("--dry-run", "preview restore actions and conflicts without writing").option("--json", "output restore JSON").action(async (snapshot, opts) => {
   try {
     const result = restoreSessionRenderSnapshot(resolveSessionPath(snapshot), {
@@ -8214,7 +8892,7 @@ templateCmd.command("vars <id>").description("Show template variables").action(a
 });
 templateCmd.command("render <id>").description("Render a template config with variables and optionally apply to disk").option("--var <vars...>", "set variables as KEY=VALUE pairs").option("--env", "use environment variables to fill template vars").option("--apply", "write rendered output to target_path").option("--dry-run", "preview rendered output without writing").action(async (id, opts) => {
   try {
-    const { renderTemplate } = await import("../chunks/template-wgnzdn7h.js");
+    const { renderTemplate } = await import("../chunks/template-e4qrxs8p.js");
     const c = await resolveConfigStore().getConfig(id);
     const vars = {};
     if (opts.var) {
@@ -8228,7 +8906,7 @@ templateCmd.command("render <id>").description("Render a template config with va
       }
     }
     if (opts.env) {
-      const { extractTemplateVars: extractTemplateVars2 } = await import("../chunks/template-wgnzdn7h.js");
+      const { extractTemplateVars: extractTemplateVars2 } = await import("../chunks/template-e4qrxs8p.js");
       for (const v of extractTemplateVars2(c.content)) {
         if (!(v.name in vars) && process.env[v.name]) {
           vars[v.name] = process.env[v.name];
@@ -8277,7 +8955,7 @@ program.command("scan [id]").description("Scan configs for secrets. Defaults to
   } else if (opts.all) {
     configs = await store.listConfigs(opts.category ? { kind: "file", category: opts.category } : { kind: "file" });
   } else {
-    const { KNOWN_CONFIGS: KNOWN_CONFIGS2 } = await import("../chunks/sync-2075deve.js");
+    const { KNOWN_CONFIGS: KNOWN_CONFIGS2 } = await import("../chunks/sync-azd9t4p8.js");
     const slugs = [
       ...KNOWN_CONFIGS2.filter((k) => !k.rulesDir).map((k) => k.name)
     ];
@@ -8571,7 +9249,7 @@ command = "${mcpBinary}"
 args = []
 `;
         if (ex(configPath)) {
-          const content = readFileSync7(configPath, "utf-8");
+          const content = readFileSync8(configPath, "utf-8");
           if (findTomlTableLines(content.split(`
 `), "mcp_servers.configs")) {
             console.log(chalk.dim("= Already installed in Codex"));
@@ -8633,7 +9311,7 @@ mcpCmd.command("uninstall").alias("remove").description("Remove configs MCP serv
           console.log(chalk.dim("= Not installed in Codex (no config.toml)"));
           continue;
         }
-        const content = readFileSync7(configPath, "utf-8");
+        const content = readFileSync8(configPath, "utf-8");
         const lines = content.split(`
 `);
         const table = findTomlTableLines(lines, "mcp_servers.configs");
@@ -8652,7 +9330,7 @@ mcpCmd.command("uninstall").alias("remove").description("Remove configs MCP serv
         console.log(chalk.green("\u2713") + " Removed from Codex");
       } else if (target === "antigravity") {
         const { existsSync: ex, readFileSync: rf, writeFileSync: wf } = await import("fs");
-        const configPath = join10(homedir4(), ".gemini", "config", "mcp_config.json");
+        const configPath = join11(homedir4(), ".gemini", "config", "mcp_config.json");
         if (!ex(configPath)) {
           console.log(chalk.dim("= Not installed in Antigravity (no mcp_config.json)"));
           continue;
@@ -8687,15 +9365,15 @@ program.command("migrate-legacy").description("Migrate the historical ~/.hasna/c
   if (!opts.confirmLocal) {
     throw new Error("migrate-legacy requires --confirm-local");
   }
-  const destinationPath = resolve6(opts.destination || process.env["HASNA_INSTRUCTIONS_DB_PATH"] || join10(getRawStoreRoot(), "instructions.db"));
+  const destinationPath = resolve7(opts.destination || process.env["HASNA_INSTRUCTIONS_DB_PATH"] || join11(getRawStoreRoot(), "instructions.db"));
   const database = await import("../chunks/database-wstmr56z.js");
   database.getDatabase(destinationPath);
   database.resetDatabase();
   const { migrateLegacyInstructionsStore } = await import("../chunks/legacy-store-migration-z2m5yzyk.js");
   const result = migrateLegacyInstructionsStore({
-    ...opts.source ? { sourcePath: resolve6(opts.source) } : {},
+    ...opts.source ? { sourcePath: resolve7(opts.source) } : {},
     destinationPath,
-    ...opts.backup ? { backupPath: resolve6(opts.backup) } : {},
+    ...opts.backup ? { backupPath: resolve7(opts.backup) } : {},
     dryRun: !opts.apply,
     ...opts.mergePreserveDestination ? { mergePolicy: "preserve-destination" } : {},
     operatorConfirmed: true
@@ -8714,7 +9392,7 @@ program.command("migrate-legacy").description("Migrate the historical ~/.hasna/c
   if (result.backupCreated)
     console.log(chalk.dim("  destination backup created before mutation"));
 });
-program.command("init").description("First-time setup: sync all known configs, create default profile").option("--force", "delete existing DB and start fresh").action(async (opts) => {
+program.command("init").description("First-time setup: create default profiles; local file import into a hosted authority is explicit").option("--force", "delete existing DB and start fresh").option("--import-local", "explicitly import known local config files into the configured hosted authority").action(async (opts) => {
   const store = resolveConfigStore();
   if (opts.force) {
     try {
@@ -8728,26 +9406,28 @@ program.command("init").description("First-time setup: sync all known configs, c
   }
   console.log(chalk.bold(`@hasna/instructions \u2014 initializing
 `));
-  const result = await syncKnown({ store });
-  console.log(chalk.green("\u2713") + ` Synced: +${result.added} updated:${result.updated} unchanged:${result.unchanged}`);
-  if (result.skipped.length > 0) {
-    console.log(chalk.dim("  skipped: " + result.skipped.join(", ")));
+  if (store.mode === "local" || opts.importLocal) {
+    const result = await syncKnown({ store });
+    console.log(chalk.green("\u2713") + ` Synced: +${result.added} updated:${result.updated} unchanged:${result.unchanged}`);
+    if (result.skipped.length > 0)
+      console.log(chalk.dim("  skipped: " + result.skipped.join(", ")));
+  } else {
+    console.log(chalk.dim("Hosted authority retained; use --import-local for an intentional local-file migration."));
   }
   const refs = [
     { slug: "workspace-structure", name: "Workspace Structure", category: "workspace", content: `# Workspace Structure
 
-See ~/.claude/rules/workspace.md for full conventions.`, desc: "~/Workspace/ hierarchy and naming" },
-    { slug: "secrets-schema", name: "Secrets Schema", category: "secrets_schema", content: `# .secrets Schema
-
-Location: ~/.secrets (sourced by ~/.zshrc)
-Format: export KEY_NAME="value"
+Resolve repositories and task worktrees through the configured repository manager. Use the configured scratch workspace for temporary execution artifacts. Keep durable project records in their owning application and follow the current project conventions.`, desc: "Repository, worktree, and execution scratch responsibilities" },
+    { slug: "secrets-schema", name: "Secrets Schema", category: "secrets_schema", content: `# Credential References
 
-Keys: ANTHROPIC_API_KEY, OPENAI_API_KEY, EXA_API_KEY, NPM_TOKEN, GITHUB_TOKEN`, desc: "Shape of ~/.secrets (no values)" }
+Store credential values in the configured Secrets authority. Application configuration records contain credential names and supported resolver references only. Resolve values through the approved consuming application at execution time; never embed values in instruction content, generated prompts, or shell profiles.`, desc: "Secret reference and runtime resolution conventions; no credential values" }
   ];
   for (const ref of refs) {
     try {
       await store.getConfig(ref.slug);
-    } catch {
+    } catch (error) {
+      if (!(error instanceof ConfigNotFoundError))
+        throw error;
       await store.createConfig({ name: ref.name, category: ref.category, agent: "global", format: "markdown", content: ref.content, kind: "reference", description: ref.desc });
     }
   }
@@ -8757,12 +9437,11 @@ Keys: ANTHROPIC_API_KEY, OPENAI_API_KEY, EXA_API_KEY, NPM_TOKEN, GITHUB_TOKEN`,
   await ensureProjectDashboardStandardConfig(store);
   try {
     await store.getProfile("my-setup");
-  } catch {
-    const p = await store.createProfile({ name: "my-setup", description: "Default profile with all known configs" });
-    const allConfigs = await store.listConfigs();
-    for (const c of allConfigs)
-      await store.addConfigToProfile(p.id, c.id);
-    console.log(chalk.green("\u2713") + ` Created profile "my-setup" with ${allConfigs.length} configs`);
+  } catch (error) {
+    if (!(error instanceof ProfileNotFoundError))
+      throw error;
+    await store.createProfile({ name: "my-setup", description: "Instruction profile; add explicitly reviewed and scoped source bindings" });
+    console.log(chalk.green("\u2713") + ' Created empty profile "my-setup"; bind reviewed instruction sources explicitly.');
   }
   const machineProfiles = await ensurePlatformProfiles(store);
   console.log(chalk.green("\u2713") + ` Ensured ${machineProfiles.length} machine-aware profile(s)`);
@@ -8773,7 +9452,7 @@ DB stats:`));
     if (count > 0)
       console.log(`  ${key.padEnd(18)} ${count}`);
   }
-  const location = store.mode === "api" ? store.v1BaseUrl : process.env["HASNA_INSTRUCTIONS_DB_PATH"] || join10(getRawStoreRoot(), "instructions.db");
+  const location = store.mode === "api" ? store.v1BaseUrl : process.env["HASNA_INSTRUCTIONS_DB_PATH"] || join11(getRawStoreRoot(), "instructions.db");
   console.log(chalk.dim(`
 ${store.mode === "api" ? "API" : "DB"}: ${location}`));
 });
@@ -8874,13 +9553,13 @@ storageCmd.command("status").description("Show redacted S3 configuration status
 });
 var storageBackupCmd = storageCmd.command("backup").description("Push, pull, and verify immutable Instructions backup objects");
 storageBackupCmd.command("push <file>").description("Upload an immutable backup archive and integrity manifest").requiredOption("--id <backup-id>", "stable immutable backup identifier").option("--content-type <type>", "payload content type", "application/gzip").option("--dry-run", "plan keys and hashes without contacting S3").option("--json", "output JSON").action(async (file, opts) => {
-  const abs = resolve6(file);
-  if (!existsSync11(abs) || !lstatSync4(abs).isFile())
+  const abs = resolve7(file);
+  if (!existsSync11(abs) || !lstatSync5(abs).isFile())
     throw new Error(`Backup file not found: ${abs}`);
   const [{ loadInstructionsS3Config }, backup, objectStore] = await Promise.all([
     import("../chunks/s3-config-hhght91k.js"),
-    import("../chunks/s3-backup-n2z4fwyh.js"),
-    import("../chunks/s3-object-store-90tgbh6k.js")
+    import("../chunks/s3-backup-hxe3zpfz.js"),
+    import("../chunks/s3-object-store-n0s82swt.js")
   ]);
   const config = loadInstructionsS3Config(process.env);
   if (!config)
@@ -8927,8 +9606,8 @@ storageBackupCmd.command("verify <backup-id>").description("Verify the immutable
   const versions = normalizeBackupVersionOptions(opts);
   const [{ loadInstructionsS3Config }, backup, objectStore] = await Promise.all([
     import("../chunks/s3-config-hhght91k.js"),
-    import("../chunks/s3-backup-n2z4fwyh.js"),
-    import("../chunks/s3-object-store-90tgbh6k.js")
+    import("../chunks/s3-backup-hxe3zpfz.js"),
+    import("../chunks/s3-object-store-n0s82swt.js")
   ]);
   const config = loadInstructionsS3Config(process.env);
   if (!config)
@@ -8953,8 +9632,8 @@ storageBackupCmd.command("pull <backup-id>").description("Download and verify an
   const versions = normalizeBackupVersionOptions(opts);
   const [{ loadInstructionsS3Config }, backup, objectStore] = await Promise.all([
     import("../chunks/s3-config-hhght91k.js"),
-    import("../chunks/s3-backup-n2z4fwyh.js"),
-    import("../chunks/s3-object-store-90tgbh6k.js")
+    import("../chunks/s3-backup-hxe3zpfz.js"),
+    import("../chunks/s3-object-store-n0s82swt.js")
   ]);
   const config = loadInstructionsS3Config(process.env);
   if (!config)
@@ -8965,16 +9644,16 @@ storageBackupCmd.command("pull <backup-id>").description("Download and verify an
     backupId,
     ...versions
   });
-  const output = resolve6(opts.output);
+  const output = resolve7(opts.output);
   if (existsSync11(output)) {
     if (!opts.force)
       throw new Error(`Refusing to overwrite existing backup file: ${output}`);
-    if (!lstatSync4(output).isFile() || lstatSync4(output).isSymbolicLink()) {
+    if (!lstatSync5(output).isFile() || lstatSync5(output).isSymbolicLink()) {
       throw new Error(`Refusing to replace a non-regular backup destination: ${output}`);
     }
   }
-  mkdirSync6(dirname6(output), { recursive: true, mode: 448 });
-  const temp = join10(dirname6(output), `.${basename(output)}.tmp-${process.pid}-${Date.now()}`);
+  mkdirSync6(dirname7(output), { recursive: true, mode: 448 });
+  const temp = join11(dirname7(output), `.${basename2(output)}.tmp-${process.pid}-${Date.now()}`);
   try {
     writeFileSync5(temp, pulled.bytes, { flag: "wx", mode: 384 });
     renameSync2(temp, output);
@@ -8999,10 +9678,10 @@ storageBackupCmd.command("pull <backup-id>").description("Download and verify an
 });
 program.command("backup").description("Export configs to a timestamped backup file").action(async () => {
   const { mkdirSync: mk } = await import("fs");
-  const backupDir = join10(getRawStoreRoot(), "backups");
+  const backupDir = join11(getRawStoreRoot(), "backups");
   mk(backupDir, { recursive: true });
   const ts = new Date().toISOString().replace(/[:.]/g, "-").replace("T", "-").slice(0, 19);
-  const outPath = join10(backupDir, `configs-${ts}.tar.gz`);
+  const outPath = join11(backupDir, `configs-${ts}.tar.gz`);
   const result = await exportConfigs(outPath, { store: resolveConfigStore() });
   const { statSync: st } = await import("fs");
   const size = st(outPath).size;
@@ -9176,7 +9855,7 @@ program.command("watch").description("Watch known config files for changes and a
   const store = resolveConfigStore();
   const interval = Number(opts.interval);
   const { statSync: st } = await import("fs");
-  const { expandPath: expandPath2 } = await import("../chunks/apply-jp13sa1e.js");
+  const { expandPath: expandPath2 } = await import("../chunks/apply-wj7wh5km.js");
   console.log(chalk.bold("@hasna/instructions watch") + chalk.dim(` \u2014 polling every ${interval}ms`));
   console.log(chalk.dim(`Watching known config files for changes\u2026
 `));
@@ -9188,7 +9867,7 @@ program.command("watch").description("Watch known config files for changes and a
         continue;
       const { readdirSync: readdirSync3 } = await import("fs");
       for (const f of readdirSync3(absDir).filter((f2) => f2.endsWith(".md"))) {
-        const abs = join10(absDir, f);
+        const abs = join11(absDir, f);
         mtimes.set(abs, st(abs).mtimeMs);
       }
     } else {
@@ -9216,7 +9895,7 @@ program.command("watch").description("Watch known config files for changes and a
         if (!existsSync11(absDir))
           continue;
         for (const f of rd(absDir).filter((f2) => f2.endsWith(".md"))) {
-          const abs = join10(absDir, f);
+          const abs = join11(absDir, f);
           if (!mtimes.has(abs)) {
             mtimes.set(abs, st(abs).mtimeMs);
             changed++;
@@ -9256,7 +9935,7 @@ program.command("report").description("Summary of stored configs, drift, and eco
       missing++;
       continue;
     }
-    const disk = readFileSync7(abs, "utf-8");
+    const disk = readFileSync8(abs, "utf-8");
     const { content: redactedDisk } = redactContent(disk, redactFormatForTarget(c.target_path, c.format));
     if (redactedDisk !== c.content)
       drifted++;