@hasna/instructions 0.7.2 → 0.7.5

package/dist/index.js

@@ -7823,6 +7823,10 @@ function normalizeProfileAssetBinding(value) {
   const rollback = record["rollback"];
   if (!ASSET_ROLLBACK_POLICIES.includes(rollback))
     throw new Error(`Invalid asset rollback policy: ${String(rollback)}`);
+  const nativeAgent = record["nativeAgent"] === undefined ? undefined : normalizeNativeAgentMetadata(record["nativeAgent"]);
+  if (nativeAgent && (kind !== "custom-agent" || strategy !== "emit-file" || !["claude", "sumi", "opencode"].includes(provider))) {
+    throw new Error("nativeAgent metadata requires a supported emitted custom-agent definition.");
+  }
   return {
     schema: PROFILE_ASSET_BINDING_SCHEMA,
     assetKey,
@@ -7842,6 +7846,7 @@ function normalizeProfileAssetBinding(value) {
       root,
       relativePath: nonEmptyString(destinationRecord["relativePath"], "destination.relativePath")
     },
+    ...nativeAgent ? { nativeAgent } : {},
     uninstall,
     rollback
   };
@@ -7917,6 +7922,7 @@ function compileAssetPlan(input) {
         allowed: binding.source.allowed
       },
       destination: binding.destination,
+      ...binding.nativeAgent ? { nativeAgent: binding.nativeAgent } : {},
       support,
       action,
       mutationMode: input.mode,
@@ -7972,6 +7978,18 @@ function validateAssetSourceAndDestination(bundle, binding, diagnostics) {
     pathSafe = false;
     diagnostics.push(diagnostic("error", "ASSET_DESTINATION_UNSAFE", binding.assetKey, error.message));
   }
+  if (pathSafe && binding.kind === "custom-agent" && binding.destination.strategy === "emit-file" && (binding.selector.provider === "claude" || binding.selector.provider === "sumi" || binding.nativeAgent) && (binding.destination.root !== "target-home" || !/^agents\/[A-Za-z0-9][A-Za-z0-9_-]*\.md$/.test(safeRelativePath(binding.destination.relativePath)))) {
+    pathSafe = false;
+    diagnostics.push(diagnostic("error", "ASSET_CUSTOM_AGENT_DESTINATION_UNSUPPORTED", binding.assetKey, "Native custom-agent definitions require agents/<name>.md beneath an explicit target-home."));
+  }
+  if (binding.nativeAgent) {
+    if (posix.basename(binding.destination.relativePath, ".md") !== binding.nativeAgent.name) {
+      diagnostics.push(diagnostic("error", "ASSET_NATIVE_AGENT_NAME_MISMATCH", binding.assetKey, "Native role name must match its destination filename."));
+    }
+    if (/^\uFEFF?---[ \t]*\r?\n/.test(bundle.content)) {
+      diagnostics.push(diagnostic("error", "ASSET_NATIVE_AGENT_DOUBLE_HEADER", binding.assetKey, "Canonical role prose must not already contain frontmatter when nativeAgent metadata is supplied."));
+    }
+  }
   const expectedLocator = bundle.locator;
   if (!binding.source.immutable || binding.source.locator !== expectedLocator) {
     diagnostics.push(diagnostic("error", "ASSET_SOURCE_MUTABLE_OR_UNPINNED", binding.assetKey, `Asset source must be pinned to ${expectedLocator}.`));
@@ -8027,6 +8045,72 @@ function safeRelativePath(value) {
   }
   return normalized;
 }
+function normalizeNativeAgentMetadata(value) {
+  const record = objectRecord(value, "nativeAgent");
+  if (Object.keys(record).some((key) => !["name", "description", "frontmatter"].includes(key)))
+    throw new Error("Unknown nativeAgent metadata field.");
+  const name = nonEmptyString(record["name"], "nativeAgent.name");
+  const description = nonEmptyString(record["description"], "nativeAgent.description");
+  if (!/^[A-Za-z0-9][A-Za-z0-9_-]*$/.test(name) || name.length > 128)
+    throw new Error("Invalid nativeAgent.name.");
+  if (description.length > 4096 || /[\r\n\0]/.test(description))
+    throw new Error("Invalid nativeAgent.description.");
+  if (record["frontmatter"] === undefined)
+    return { name, description };
+  const frontmatter = record["frontmatter"];
+  if (typeof frontmatter !== "string" || frontmatter.length > 16384 || frontmatter.includes("\x00"))
+    throw new Error("Invalid nativeAgent.frontmatter.");
+  const match = /^---\r?\n([\s\S]*?)\r?\n---\r?\n$/.exec(frontmatter);
+  if (!match)
+    throw new Error("nativeAgent.frontmatter requires one complete newline-terminated YAML header.");
+  const scalar = (raw) => {
+    if (raw.startsWith('"')) {
+      try {
+        const parsed = JSON.parse(raw);
+        return typeof parsed === "string" ? parsed : undefined;
+      } catch {
+        return;
+      }
+    }
+    if (!/^[A-Za-z0-9][A-Za-z0-9 _.,:;()/?@+-]*$/.test(raw) || /:(?:\s|$)/.test(raw))
+      return;
+    if (/^(?:true|yes|on|y)$/i.test(raw))
+      return true;
+    if (/^(?:false|no|off|n)$/i.test(raw))
+      return false;
+    if (/^null$/i.test(raw))
+      return null;
+    if (/^-?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?$/.test(raw))
+      return Number(raw);
+    if (/^[0-9]/.test(raw))
+      return;
+    return raw;
+  };
+  const fields = new Map;
+  for (const line of match[1].split(/\r?\n/)) {
+    if (!line.trim() || line.startsWith("#"))
+      continue;
+    const field = /^([A-Za-z][A-Za-z0-9_-]*):[ \t]+(.+)$/.exec(line);
+    if (!field || fields.has(field[1]) || scalar(field[2]) === undefined)
+      throw new Error("nativeAgent.frontmatter requires unambiguous, unique flat scalar fields.");
+    fields.set(field[1], scalar(field[2]));
+  }
+  if (fields.get("name") !== name || fields.get("description") !== description)
+    throw new Error("nativeAgent.frontmatter name and description must match explicit metadata.");
+  return { name, description, frontmatter };
+}
+function renderNativeAgentContent(content, metadata) {
+  if (!metadata)
+    return content;
+  const value = normalizeNativeAgentMetadata(metadata);
+  if (/^\uFEFF?---[ \t]*\r?\n/.test(content))
+    throw new Error("Canonical role prose already contains frontmatter.");
+  return (value.frontmatter ?? `---
+name: ${JSON.stringify(value.name)}
+description: ${JSON.stringify(value.description)}
+---
+`) + content;
+}
 function diagnostic(severity, code, assetKey, message) {
   return { severity, code, assetKey, message };
 }
@@ -8072,6 +8156,7 @@ var init_asset_plan = __esm(() => {
   ASSET_CAPABILITY_DESCRIPTORS = Object.freeze([
     assetCapability("claude", "code", "skill", "supported", ["emit-file"], "Claude Code project or profile skill files."),
     assetCapability("claude", "code", "workflow", "supported", ["emit-file"], "Claude Code command and workflow files."),
+    assetCapability("claude", "code", "custom-agent", "supported", ["emit-file"], "Claude Code Markdown subagents with native frontmatter in agents/.", ">=2.1.276 <3.0.0"),
     assetCapability("claude", "code", "hook", "supported", ["emit-file"], "Claude Code hook configuration fragments."),
     assetCapability("claude", "code", "plugin", "conditional", ["install-marketplace"], "Claude marketplace installation requires an explicit installer."),
     assetCapability("codex", "cli", "skill", "supported", ["emit-file"], "Codex skill bundle files."),
@@ -8082,6 +8167,7 @@ var init_asset_plan = __esm(() => {
     assetCapability("opencode", "cli", "workflow", "supported", ["emit-file"], "OpenCode command/workflow files."),
     assetCapability("opencode", "cli", "plugin", "supported", ["emit-file"], "OpenCode local plugin modules."),
     assetCapability("opencode", "cli", "custom-agent", "supported", ["emit-file"], "OpenCode custom agent files."),
+    assetCapability("sumi", "cli", "custom-agent", "supported", ["emit-file"], "Sumi Markdown agent definitions in its explicit resolved config or project directory.", ">=0.2.22 <0.3.0"),
     assetCapability("codewith", "cli", "skill", "supported", ["emit-file"], "Codewith skill bundle files."),
     assetCapability("codewith", "cli", "plugin", "conditional", ["install-local", "install-marketplace"], "Codewith plugin installation requires an explicit installer."),
     assetCapability("aicopilot", "cli", "skill", "supported", ["emit-file"], "AICopilot discovered skill files."),
@@ -9230,7 +9316,7 @@ function buildCursorRuleFiles(targetHome, adapter, sources) {
     return [sourceFile, ...ruleFiles];
   });
 }
-function buildOpenCodeFiles(targetHome, adapter, profile, sources, providerConfig) {
+function buildOpenCodeFiles(targetHome, adapter, profile, sources, providerConfig, projectRoot) {
   const surface = adapter.providerSurface ?? "legacy-dual";
   const fragments = sources.flatMap((source, index) => [
     makeFile(targetHome, fragmentPath(adapter, index, source), "fragment", sectionForSource(source), [source.id]),
@@ -9250,13 +9336,13 @@ function buildOpenCodeFiles(targetHome, adapter, profile, sources, providerConfi
   ]);
   const existingConfigPath = joinTarget(targetHome, adapter.configFile);
   const selectedConfig = existsSync5(existingConfigPath) ? readOpenCodeConfig(readFileSync4(existingConfigPath, "utf8"), existingConfigPath) : providerConfig ? readOpenCodeConfig(providerConfig.content, providerConfig.sourceId) : {};
-  const preservedInstructions = normalizeOpenCodeInstructions(selectedConfig["instructions"]).filter((path) => !pathIsManagedOpenCodeInstruction(path, adapter.managedDir));
+  const preservedInstructions = normalizeOpenCodeInstructions(selectedConfig["instructions"]).filter((path) => !pathIsManagedOpenCodeInstruction(path, adapter.managedDir, targetHome, projectRoot));
   const config = {
     ...selectedConfig,
     $schema: typeof selectedConfig["$schema"] === "string" ? selectedConfig["$schema"] : "https://opencode.ai/config.json",
     instructions: [
       ...preservedInstructions,
-      ...fragments.map((file) => file.relativePath)
+      ...fragments.map((file) => file.path)
     ]
   };
   const configSourceIds = [
@@ -9299,9 +9385,99 @@ function normalizeOpenCodeInstructions(value) {
   }
   return value;
 }
-function pathIsManagedOpenCodeInstruction(path, managedDir) {
-  const normalized = posix2.normalize(path.replaceAll("\\", "/")).replace(/^\.\//, "");
-  return normalized === managedDir || normalized.startsWith(`${managedDir}/`);
+function pathIsManagedOpenCodeInstruction(reference, managedDir, targetHome, projectRoot) {
+  const normalizedManagedDir = posix2.normalize(managedDir.replaceAll("\\", "/"));
+  const candidates = canonicalOpenCodeInstructionPaths(reference, targetHome, projectRoot);
+  return candidates.some((candidate) => {
+    const path = candidate.caseInsensitive ? candidate.path.toLowerCase() : candidate.path;
+    const namespace = candidate.caseInsensitive ? normalizedManagedDir.toLowerCase() : normalizedManagedDir;
+    return path === namespace || path.endsWith(`/${namespace}`) || path.includes(`/${namespace}/`);
+  });
+}
+function canonicalOpenCodeInstructionPaths(reference, targetHome, projectRoot) {
+  const decodedReference = decodeOpenCodePathEscapes(reference);
+  const portable = decodedReference.replaceAll("\\", "/");
+  if (portable.includes("\x00")) {
+    throw new Error("OpenCode config instruction references cannot contain NUL bytes.");
+  }
+  if (/^[A-Za-z]:(?!\/)/.test(portable)) {
+    throw new Error("OpenCode config instruction references cannot use Win32 drive-relative paths.");
+  }
+  const windowsAbsolute = /^[A-Za-z]:\//.test(portable);
+  const uncAbsolute = portable.startsWith("//");
+  const windowsRootRelative = /^\\(?![\\/])/.test(decodedReference);
+  const uriScheme = windowsAbsolute || uncAbsolute || windowsRootRelative ? null : /^([A-Za-z][A-Za-z0-9+.-]*):/.exec(portable)?.[1]?.toLowerCase();
+  if (uriScheme && uriScheme !== "file")
+    return [];
+  if (uriScheme === "file") {
+    const fileReference = reference.replaceAll("\\", "/");
+    if (!/^file:\/\//i.test(fileReference)) {
+      throw new Error("OpenCode config contains an invalid file URL instruction reference.");
+    }
+    let url;
+    try {
+      url = new URL(fileReference);
+    } catch {
+      throw new Error("OpenCode config contains an invalid file URL instruction reference.");
+    }
+    if (url.protocol !== "file:" || url.username || url.password || url.port || url.search || url.hash) {
+      throw new Error("OpenCode config contains an invalid file URL instruction reference.");
+    }
+    const pathname = decodeOpenCodePathEscapes(url.pathname).replaceAll("\\", "/");
+    if (pathname.includes("\x00")) {
+      throw new Error("OpenCode config instruction references cannot contain NUL bytes.");
+    }
+    if (/^\/[A-Za-z]:(?!\/)/.test(pathname)) {
+      throw new Error("OpenCode config instruction references cannot use Win32 drive-relative paths.");
+    }
+    const host = url.hostname && url.hostname !== "localhost" ? `//${url.hostname}` : "";
+    return [{
+      path: normalizePortableOpenCodePath(`${host}${pathname}`, true),
+      caseInsensitive: true
+    }];
+  }
+  if (posix2.isAbsolute(portable) || windowsAbsolute || uncAbsolute || windowsRootRelative) {
+    const windowsPathSemantics = windowsAbsolute || uncAbsolute || windowsRootRelative;
+    return [{
+      path: normalizePortableOpenCodePath(portable, windowsPathSemantics),
+      caseInsensitive: windowsPathSemantics
+    }];
+  }
+  const roots = [
+    ...projectRoot ? [resolveSessionPath(projectRoot)] : [],
+    resolveSessionPath(targetHome)
+  ];
+  const candidates = new Map;
+  for (const root of roots) {
+    const portableRoot = root.replaceAll("\\", "/");
+    const caseInsensitive = /^[A-Za-z]:\//.test(portableRoot) || portableRoot.startsWith("//");
+    const path = normalizePortableOpenCodePath(posix2.join(portableRoot, portable));
+    candidates.set(`${caseInsensitive ? "i" : "s"}:${path}`, { path, caseInsensitive });
+  }
+  return [...candidates.values()];
+}
+function decodeOpenCodePathEscapes(value) {
+  return value.replace(/(?:%[a-fA-F0-9]{2})+/g, (encoded) => {
+    try {
+      return decodeURIComponent(encoded);
+    } catch {
+      return encoded;
+    }
+  });
+}
+function normalizePortableOpenCodePath(value, windowsPathSemantics = false) {
+  const portable = value.replaceAll("\\", "/");
+  const componentNormalized = windowsPathSemantics ? portable.split("/").map(normalizeWin32PathComponent).join("/") : portable;
+  const normalized = posix2.normalize(componentNormalized);
+  return normalized.startsWith("//") ? `/${normalized.replace(/^\/+/u, "")}` : normalized;
+}
+function normalizeWin32PathComponent(component) {
+  if (!component || /^[A-Za-z]:$/.test(component))
+    return component;
+  const withoutTrailingSpaces = component.replace(/ +$/u, "");
+  if (withoutTrailingSpaces === "." || withoutTrailingSpaces === "..")
+    return withoutTrailingSpaces;
+  return component.replace(/[ .]+$/u, "");
 }
 function buildAntigravityRuleFiles(targetHome, adapter, sources) {
   return sources.flatMap((source, index) => {
@@ -9355,7 +9531,7 @@ function makeAntigravityRuleFile(targetHome, relativePath, content, sourceIds) {
   }
   return file;
 }
-function buildFiles(targetHome, adapter, profile, sources, providerConfig, providerVersion) {
+function buildFiles(targetHome, adapter, profile, sources, providerConfig, providerVersion, projectRoot) {
   switch (adapter.mode) {
     case "native-imports":
       return buildNativeImportFiles(targetHome, adapter, profile, sources, providerVersion);
@@ -9364,7 +9540,7 @@ function buildFiles(targetHome, adapter, profile, sources, providerConfig, provi
     case "cursor-mdc":
       return buildCursorRuleFiles(targetHome, adapter, sources);
     case "opencode-instructions":
-      return buildOpenCodeFiles(targetHome, adapter, profile, sources, providerConfig);
+      return buildOpenCodeFiles(targetHome, adapter, profile, sources, providerConfig, projectRoot);
     case "antigravity-rules":
       return buildAntigravityRuleFiles(targetHome, adapter, sources);
     case "provider-rules":
@@ -9393,12 +9569,13 @@ function buildAssetFiles(input, targetHome, blocked) {
     if (!relativePath || relativePath === ".." || relativePath.startsWith("../") || isAbsolute3(relativePath)) {
       throw new Error(`Asset ${item.assetKey} is outside the session snapshot root; use a project-scoped session plan for atomic application.`);
     }
+    const renderedContent = renderNativeAgentContent(content, item.nativeAgent);
     return {
       path,
       relativePath: assertSafeRelativePath(relativePath),
       role: "asset",
-      content,
-      sha256: sha2566(content),
+      content: renderedContent,
+      sha256: sha2566(renderedContent),
       sourceIds: [item.sourceConfigId, item.assetId]
     };
   });
@@ -9577,7 +9754,7 @@ function resolveSessionTargetOwnership(input, target) {
     tool: input.tool,
     profile: input.profile,
     targetHome: target.targetHome,
-    projectRoot: null,
+    projectRoot: input.tool === "opencode" && input.projectRoot ? resolveSessionPath(input.projectRoot) : null,
     ownedBy: "open-configs",
     canonicalOwner: "instructions",
     writer: {
@@ -9638,7 +9815,7 @@ function planSessionRender(input) {
   if (input.providerConfig && input.tool !== "opencode") {
     throw new Error("Provider base config is supported only for OpenCode session renders.");
   }
-  const baseFiles = blocked ? [] : buildFiles(targetHome, adapter, input.profile, orderedSources, input.providerConfig, input.provider_version);
+  const baseFiles = blocked ? [] : buildFiles(targetHome, adapter, input.profile, orderedSources, input.providerConfig, input.provider_version, input.projectRoot);
   const projectContext = blocked ? null : composeProjectContextSessionRender({
     tool: input.tool,
     adapter_mode: adapter.mode,
@@ -9739,6 +9916,7 @@ function planSessionRender(input) {
           mutationMode: item.mutationMode,
           destination: item.destination,
           digest: item.source.digest,
+          ...item.nativeAgent ? { nativeAgent: item.nativeAgent } : {},
           exactOnceKey: item.exactOnceKey
         }))
       }
@@ -13768,7 +13946,7 @@ function detectMachineContext(overrides = {}) {
     created_at: "",
     os_family: osFamily,
     home_dir: homeDir6,
-    workspace_root: overrides.workspace_root ?? join10(homeDir6, osFamily === "macos" ? "Workspace" : "workspace"),
+    workspace_root: overrides.workspace_root ?? "",
     bun_bin_dir: bunBinDir,
     bun_path: overrides.bun_path ?? defaultBunPath,
     path_prefix: overrides.path_prefix ?? (osFamily === "macos" ? `${join10("/opt", "homebrew", "bin")}:${bunBinDir}` : bunBinDir)
@@ -13781,7 +13959,7 @@ function machineContextToVariables(machine) {
     OS_FAMILY: machine.os_family,
     ARCH: machine.arch ?? "",
     HOME_DIR: machine.home_dir,
-    WORKSPACE_ROOT: machine.workspace_root,
+    ...machine.workspace_root ? { WORKSPACE_ROOT: machine.workspace_root } : {},
     BUN_BIN_DIR: machine.bun_bin_dir,
     BUN_PATH: machine.bun_path,
     PATH_PREFIX: machine.path_prefix
@@ -14845,7 +15023,7 @@ init_types();
 
 // src/status.ts
 init_config_store();
-import { existsSync as existsSync12, readFileSync as readFileSync11 } from "fs";
+import { existsSync as existsSync11, readFileSync as readFileSync10 } from "fs";
 
 // src/lib/apply.ts
 init_types();
@@ -15395,19 +15573,9 @@ function getPackageVersion() {
 }
 
 // src/lib/managed-skill-runtimes.ts
-import { createHash as createHash8 } from "crypto";
-import { spawnSync as spawnSync3 } from "child_process";
-import {
-  existsSync as existsSync11,
-  lstatSync as lstatSync4,
-  mkdirSync as mkdirSync4,
-  readFileSync as readFileSync10,
-  renameSync as renameSync2,
-  rmSync as rmSync3,
-  writeFileSync as writeFileSync3
-} from "fs";
+import { lstatSync as lstatSync4 } from "fs";
 import { homedir as homedir8 } from "os";
-import { dirname as dirname8, join as join14, parse as parse4, relative as relative5, resolve as resolve10 } from "path";
+import { join as join14, resolve as resolve10 } from "path";
 var INBOX_CONVERSATIONS_MINIMUM_VERSION = "0.5.28";
 var INBOX_SKILL_MARKERS = [
   [".claude", "skills", "inbox", "SKILL.md"],
@@ -15416,369 +15584,67 @@ var INBOX_SKILL_MARKERS = [
   [".config", "opencode", "skills", "inbox", "SKILL.md"],
   [".cursor", "skills", "inbox", "SKILL.md"]
 ];
-var REQUIRED_WATCH_FLAGS = ["--from <agent>", "--all", "--full-content"];
-function sha2568(content) {
-  return createHash8("sha256").update(content).digest("hex");
-}
-function lstatOrNull(path) {
-  try {
-    return lstatSync4(path);
-  } catch {
-    return null;
-  }
-}
-function findSymlinkedAncestor(path) {
-  const normalized = resolve10(path);
-  const parsed = parse4(normalized);
-  let current = parsed.root;
-  const rel = relative5(parsed.root, normalized);
-  for (const segment of rel.split(/[\\/]+/).filter(Boolean)) {
+function needsMigrationReview(homeDir6, parts) {
+  let current = resolve10(homeDir6);
+  const absolute = join14(current, ...parts);
+  for (const segment of parts) {
     current = join14(current, segment);
-    if (!existsSync11(current))
-      return null;
-    if (lstatSync4(current).isSymbolicLink())
-      return current;
-  }
-  return null;
-}
-function assertNoSymlinkAncestors2(path) {
-  const found = findSymlinkedAncestor(path);
-  if (found !== null) {
-    throw new Error(`managed skill path uses a symlink ancestor: ${found}`);
-  }
-}
-function packagedInboxSkillPath(explicitPath) {
-  if (explicitPath)
-    return explicitPath;
-  throw new Error("Bundled skill contracts are retired; use the Skills CLI to manage private skills");
-}
-function readCanonicalSkill(explicitPath) {
-  const assetPath = packagedInboxSkillPath(explicitPath);
-  const stat = lstatOrNull(assetPath);
-  if (!stat?.isFile()) {
-    throw new Error("packaged inbox skill contract is not a regular file");
-  }
-  const content = readFileSync10(assetPath, "utf8");
-  if (!content.includes("conversations watch --from <agent> --all")) {
-    throw new Error("packaged inbox skill contract does not declare the canonical conversations watcher");
-  }
-  if (!content.includes("There is no separate")) {
-    throw new Error("packaged inbox skill contract does not retire the legacy executable");
-  }
-  return { content, sha256: sha2568(content) };
-}
-function runProbe(command, args) {
-  const result = spawnSync3(command, args, {
-    encoding: "utf8",
-    timeout: 5000,
-    stdio: ["ignore", "pipe", "pipe"]
-  });
-  if (result.error || result.status !== 0) {
-    return { ok: false, output: "" };
-  }
-  return {
-    ok: true,
-    output: `${result.stdout ?? ""}
-${result.stderr ?? ""}`.trim()
-  };
-}
-function parseVersion(output) {
-  return output.match(/\b(\d+\.\d+\.\d+)\b/)?.[1] ?? null;
-}
-function compareVersions(left, right) {
-  const a = left.split(".").map(Number);
-  const b = right.split(".").map(Number);
-  for (let i = 0;i < Math.max(a.length, b.length); i++) {
-    const delta = (a[i] ?? 0) - (b[i] ?? 0);
-    if (delta !== 0)
-      return delta;
-  }
-  return 0;
-}
-function inspectSkillMarkers(homeDir6) {
-  return INBOX_SKILL_MARKERS.map((parts) => join14(homeDir6, ...parts)).map((path) => {
-    const stat = lstatOrNull(path);
-    if (!stat)
-      return null;
-    if (!stat.isFile()) {
-      return { path, content: null, mode: null, regular: false };
+    let stat;
+    try {
+      stat = lstatSync4(current);
+    } catch (error) {
+      if (error.code === "ENOENT")
+        return false;
+      throw error;
     }
-    return {
-      path,
-      content: readFileSync10(path, "utf8"),
-      mode: stat.mode & 511,
-      regular: true
-    };
-  }).filter((snapshot) => snapshot !== null);
+    if (stat.isSymbolicLink() || current !== absolute && !stat.isDirectory())
+      return true;
+  }
+  return true;
 }
-function inspectInbox(options) {
+function inspectLegacyInbox(options) {
   const homeDir6 = options.homeDir ?? homedir8();
-  const runtimeCommand = options.conversationsCommand ?? "conversations";
-  const snapshots = inspectSkillMarkers(homeDir6);
-  const skillPresent = snapshots.length > 0;
-  let canonicalContent = null;
-  let canonicalSha256 = null;
-  let assetError = null;
-  try {
-    const canonical = readCanonicalSkill(options.assetPath);
-    canonicalContent = canonical.content;
-    canonicalSha256 = canonical.sha256;
-  } catch (error) {
-    assetError = error instanceof Error ? error.message : String(error);
-  }
-  const versionProbe = skillPresent ? runProbe(runtimeCommand, ["--version"]) : { ok: false, output: "" };
-  const helpProbe = versionProbe.ok ? runProbe(runtimeCommand, ["watch", "--help"]) : { ok: false, output: "" };
-  const runtimeVersion = versionProbe.ok ? parseVersion(versionProbe.output) : null;
-  const supportsFrom = helpProbe.ok && helpProbe.output.includes(REQUIRED_WATCH_FLAGS[0]);
-  const supportsAll = helpProbe.ok && helpProbe.output.includes(REQUIRED_WATCH_FLAGS[1]);
-  const supportsFullContent = helpProbe.ok && helpProbe.output.includes(REQUIRED_WATCH_FLAGS[2]);
-  const packageReady = versionProbe.ok && runtimeVersion !== null && compareVersions(runtimeVersion, INBOX_CONVERSATIONS_MINIMUM_VERSION) >= 0 && helpProbe.ok && supportsFrom && supportsAll && supportsFullContent;
-  const heartbeatProbe = skillPresent && packageReady && options.agent ? runProbe(runtimeCommand, ["agents", "heartbeat", "--from", options.agent, "--json"]) : null;
-  const hostedHeartbeat = heartbeatProbe === null ? "unverified" : heartbeatProbe.ok ? "passed" : "failed";
-  const deliveryVerified = hostedHeartbeat === "passed" && options.deliveryVerified === true;
-  const staleMarkers = canonicalContent === null ? snapshots.map((snapshot) => snapshot.path) : snapshots.filter((snapshot) => !snapshot.regular || snapshot.content !== canonicalContent).map((snapshot) => snapshot.path);
-  let reason = "skill not installed";
-  if (skillPresent) {
-    const nonRegular = snapshots.some((snapshot) => !snapshot.regular);
-    const symlinkAncestor = snapshots.map((snapshot) => snapshot.path).map((path) => findSymlinkedAncestor(dirname8(path))).find((found) => found !== null);
-    if (nonRegular)
-      reason = "managed skill target is not a regular file";
-    else if (symlinkAncestor)
-      reason = `managed skill path uses a symlink ancestor: ${symlinkAncestor}`;
-    else if (assetError)
-      reason = assetError;
-    else if (!versionProbe.ok)
-      reason = "conversations command unavailable";
-    else if (!runtimeVersion)
-      reason = "conversations version is unreadable";
-    else if (compareVersions(runtimeVersion, INBOX_CONVERSATIONS_MINIMUM_VERSION) < 0) {
-      reason = `conversations ${runtimeVersion} is older than ${INBOX_CONVERSATIONS_MINIMUM_VERSION}`;
-    } else if (!helpProbe.ok)
-      reason = "conversations watch help is unavailable";
-    else if (!supportsFrom || !supportsAll || !supportsFullContent) {
-      const missing = [
-        !supportsFrom ? "--from" : null,
-        !supportsAll ? "--all" : null,
-        !supportsFullContent ? "--full-content" : null
-      ].filter((flag) => flag !== null);
-      reason = `conversations watch is missing required flags: ${missing.join(", ")}`;
-    } else if (staleMarkers.length > 0)
-      reason = "skill contract stale";
-    else if (hostedHeartbeat === "failed")
-      reason = "hosted heartbeat failed; manual fallback required";
-    else if (hostedHeartbeat === "unverified")
-      reason = "hosted heartbeat unverified; manual fallback required";
-    else if (!deliveryVerified)
-      reason = "hosted heartbeat passed; channel and DM delivery verification required";
-    else
-      reason = "ready";
-  }
+  const markers = INBOX_SKILL_MARKERS.filter((parts) => needsMigrationReview(homeDir6, parts)).map((parts) => join14(homeDir6, ...parts));
+  const present = markers.length > 0;
   return {
-    status: {
-      skill: "inbox",
-      runtime: "conversations watch",
-      minimum_version: INBOX_CONVERSATIONS_MINIMUM_VERSION,
-      skill_present: skillPresent,
-      skill_markers: snapshots.map((snapshot) => snapshot.path),
-      skill_contracts_current: snapshots.length - staleMarkers.length,
-      stale_skill_markers: staleMarkers,
-      expected_skill_sha256: canonicalSha256,
-      runtime_command: runtimeCommand,
-      runtime_present: versionProbe.ok,
-      runtime_version: runtimeVersion,
-      watch_supports_from: supportsFrom,
-      watch_supports_all: supportsAll,
-      watch_supports_full_content: supportsFullContent,
-      hosted_heartbeat: hostedHeartbeat,
-      delivery_verified: deliveryVerified,
-      manual_fallback_ready: skillPresent && staleMarkers.length === 0 && packageReady,
-      healthy: !skillPresent || reason === "ready",
-      reason
-    },
-    canonicalContent,
-    snapshots
+    skill: "inbox",
+    runtime: "conversations watch",
+    minimum_version: INBOX_CONVERSATIONS_MINIMUM_VERSION,
+    skill_present: present,
+    skill_markers: markers,
+    skill_contracts_current: 0,
+    stale_skill_markers: markers,
+    expected_skill_sha256: null,
+    runtime_command: options.conversationsCommand ?? "conversations",
+    runtime_present: false,
+    runtime_version: null,
+    watch_supports_from: false,
+    watch_supports_all: false,
+    watch_supports_full_content: false,
+    hosted_heartbeat: "unverified",
+    delivery_verified: false,
+    manual_fallback_ready: false,
+    healthy: !present,
+    reason: present ? "Native Inbox skill management is retired; use the Skills CLI to review skills migrate native, then sync and load the selected skills" : "No legacy native Inbox skill found; skill availability is managed by the Skills CLI"
   };
 }
 function inspectManagedSkillRuntimes(options = {}) {
-  const runtime = inspectInbox(options).status;
-  const installed = runtime.skill_present ? [runtime] : [];
+  const runtime = inspectLegacyInbox(options);
   return {
     runtimes: [runtime],
-    skills_present: installed.length,
-    healthy: installed.filter((item) => item.healthy).length,
-    missing: installed.filter((item) => !item.healthy).length
-  };
-}
-function runtimeReadyForWrite(status) {
-  return status.runtime_present && status.runtime_version !== null && compareVersions(status.runtime_version, INBOX_CONVERSATIONS_MINIMUM_VERSION) >= 0 && status.watch_supports_from && status.watch_supports_all && status.watch_supports_full_content;
-}
-function projectUpdatedStatus(status, contractCount) {
-  const healthy = status.hosted_heartbeat === "passed" && status.delivery_verified;
-  return {
-    ...status,
-    skill_contracts_current: contractCount,
-    stale_skill_markers: [],
-    manual_fallback_ready: true,
-    healthy,
-    reason: healthy ? "ready" : status.hosted_heartbeat === "failed" ? "hosted heartbeat failed; manual fallback required" : status.hosted_heartbeat === "unverified" ? "hosted heartbeat unverified; manual fallback required" : "hosted heartbeat passed; channel and DM delivery verification required"
+    skills_present: runtime.skill_present ? 1 : 0,
+    healthy: 0,
+    missing: runtime.skill_present ? 1 : 0
   };
 }
-function cleanup(path) {
-  rmSync3(path, { force: true });
-}
-function writeAtomic(path, content, mode) {
-  assertNoSymlinkAncestors2(dirname8(path));
-  const tempPath = `${path}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`;
-  try {
-    mkdirSync4(dirname8(path), { recursive: true, mode: 493 });
-    writeFileSync3(tempPath, content, { mode, flag: "wx" });
-    renameSync2(tempPath, path);
-  } finally {
-    cleanup(tempPath);
-  }
-}
-var DEFAULT_SKILL_WRITE_FILE_OPERATIONS = {
-  lstat: lstatOrNull,
-  read: (path) => readFileSync10(path, "utf8"),
-  write: writeAtomic
-};
-function writeSkillContractsTransactional(snapshots, canonicalContent, fileOperations = DEFAULT_SKILL_WRITE_FILE_OPERATIONS) {
-  const written = [];
-  try {
-    for (const snapshot of snapshots) {
-      const currentStat = fileOperations.lstat(snapshot.path);
-      if (!currentStat?.isFile() || fileOperations.read(snapshot.path) !== snapshot.content) {
-        throw new Error("managed skill changed after inspection; refusing a stale write");
-      }
-      fileOperations.write(snapshot.path, canonicalContent, snapshot.mode);
-      written.push(snapshot);
-    }
-    return { ok: true, error: null, rollback_conflicts: [] };
-  } catch (error) {
-    const rollbackConflicts = [];
-    for (const snapshot of written.reverse()) {
-      const currentStat = fileOperations.lstat(snapshot.path);
-      if (!currentStat?.isFile()) {
-        rollbackConflicts.push(`${snapshot.path}: no longer a regular file`);
-        continue;
-      }
-      let currentContent;
-      try {
-        currentContent = fileOperations.read(snapshot.path);
-      } catch {
-        rollbackConflicts.push(`${snapshot.path}: could not read the current file`);
-        continue;
-      }
-      if (currentContent !== canonicalContent) {
-        rollbackConflicts.push(`${snapshot.path}: changed after this reconciliation wrote it`);
-        continue;
-      }
-      try {
-        fileOperations.write(snapshot.path, snapshot.content, snapshot.mode);
-      } catch {
-        rollbackConflicts.push(`${snapshot.path}: still owned but could not be restored`);
-      }
-    }
-    return {
-      ok: false,
-      error: error instanceof Error ? error.message : String(error),
-      rollback_conflicts: rollbackConflicts
-    };
-  }
-}
 async function reconcileManagedSkillRuntimes(options = {}) {
+  const runtime = inspectLegacyInbox(options);
   const dryRun = options.dryRun ?? false;
-  const before = inspectInbox(options);
-  const status = before.status;
-  if (!status.skill_present) {
-    return {
-      runtimes: [{ ...status, action: "skipped", dry_run: dryRun, skill_contracts_changed: 0 }],
-      changed: 0,
-      failed: 0,
-      dry_run: dryRun
-    };
-  }
-  if (before.snapshots.some((snapshot) => !snapshot.regular)) {
-    return {
-      runtimes: [{ ...status, action: "failed", dry_run: dryRun, skill_contracts_changed: 0 }],
-      changed: 0,
-      failed: 1,
-      dry_run: dryRun
-    };
-  }
-  const symlinkedAncestor = before.snapshots.map((snapshot) => snapshot.path).map((path) => findSymlinkedAncestor(dirname8(path))).find((found) => found !== null);
-  if (symlinkedAncestor) {
-    return {
-      runtimes: [{ ...status, action: "failed", dry_run: dryRun, skill_contracts_changed: 0 }],
-      changed: 0,
-      failed: 1,
-      dry_run: dryRun
-    };
-  }
-  if (!before.canonicalContent || !runtimeReadyForWrite(status)) {
-    return {
-      runtimes: [{ ...status, action: "failed", dry_run: dryRun, skill_contracts_changed: 0 }],
-      changed: 0,
-      failed: 1,
-      dry_run: dryRun
-    };
-  }
-  const staleSnapshots = before.snapshots.filter((snapshot) => snapshot.content !== before.canonicalContent);
-  if (staleSnapshots.length === 0) {
-    return {
-      runtimes: [{ ...status, action: "unchanged", dry_run: dryRun, skill_contracts_changed: 0 }],
-      changed: 0,
-      failed: 0,
-      dry_run: dryRun
-    };
-  }
-  if (dryRun) {
-    const projected = projectUpdatedStatus(status, before.snapshots.length);
-    return {
-      runtimes: [{
-        ...projected,
-        action: "update",
-        dry_run: true,
-        skill_contracts_changed: staleSnapshots.length
-      }],
-      changed: 1,
-      failed: 0,
-      dry_run: true
-    };
-  }
-  const transaction = writeSkillContractsTransactional(staleSnapshots.map((snapshot) => ({
-    path: snapshot.path,
-    content: snapshot.content,
-    mode: snapshot.mode ?? 420
-  })), before.canonicalContent);
-  if (!transaction.ok) {
-    const rollbackConflictReason = transaction.rollback_conflicts.length > 0 ? `; rollback conflicts: ${transaction.rollback_conflicts.join("; ")}` : "";
-    const reason = `${transaction.error ?? "managed skill reconciliation failed"}${rollbackConflictReason}`;
-    return {
-      runtimes: [{
-        ...status,
-        action: "failed",
-        dry_run: false,
-        skill_contracts_changed: 0,
-        reason
-      }],
-      changed: 0,
-      failed: 1,
-      dry_run: false
-    };
-  }
-  const after = inspectInbox(options).status;
-  const accepted = after.healthy || after.manual_fallback_ready;
   return {
-    runtimes: [{
-      ...after,
-      action: accepted ? "update" : "failed",
-      dry_run: false,
-      skill_contracts_changed: accepted ? staleSnapshots.length : 0
-    }],
-    changed: accepted ? 1 : 0,
-    failed: accepted ? 0 : 1,
-    dry_run: false
+    runtimes: [{ ...runtime, action: runtime.skill_present ? "failed" : "skipped", dry_run: dryRun, skill_contracts_changed: 0 }],
+    changed: 0,
+    failed: runtime.skill_present ? 1 : 0,
+    dry_run: dryRun
   };
 }
 
@@ -15842,11 +15708,11 @@ async function getConfigsStatus(store = resolveConfigStore(), options = {}) {
       continue;
     knownTargets += 1;
     const targetPath = expandPath(config.target_path);
-    if (!existsSync12(targetPath)) {
+    if (!existsSync11(targetPath)) {
       missingTargets += 1;
       continue;
     }
-    const disk = readFileSync11(targetPath, "utf-8");
+    const disk = readFileSync10(targetPath, "utf-8");
     const { content: redactedDisk } = redactContent(disk, redactFormatForTarget(config.target_path, config.format));
     if (redactedDisk !== config.content) {
       driftedTargets += 1;
@@ -15937,8 +15803,8 @@ async function getConfigsStatus(store = resolveConfigStore(), options = {}) {
   };
 }
 // src/lib/provider-context.ts
-import { createHash as createHash9 } from "crypto";
-import { existsSync as existsSync13, mkdirSync as mkdirSync5, readFileSync as readFileSync12, writeFileSync as writeFileSync4 } from "fs";
+import { createHash as createHash8 } from "crypto";
+import { existsSync as existsSync12, mkdirSync as mkdirSync4, readFileSync as readFileSync11, writeFileSync as writeFileSync3 } from "fs";
 import { join as join15 } from "path";
 var PROVIDER_CONTEXT_DIR = ".hasna/provider-context";
 var PROVIDER_CONTEXT_MANIFEST = "manifest.json";
@@ -16074,8 +15940,8 @@ function renderPerEndpointFragment(entry) {
 function renderProviderFragment(entry) {
   return entry ? renderPerEndpointFragment(entry) : INVARIANT_FRAGMENT;
 }
-function sha2569(content) {
-  return createHash9("sha256").update(content).digest("hex");
+function sha2568(content) {
+  return createHash8("sha256").update(content).digest("hex");
 }
 function resolveAndRenderProviderContext(opts) {
   const entry = matchProviderEndpoint(opts.origin);
@@ -16085,17 +15951,17 @@ function resolveAndRenderProviderContext(opts) {
   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 = join15(opts.homeDir, PROVIDER_CONTEXT_DIR);
-  if (!existsSync13(dir))
-    mkdirSync5(dir, { recursive: true });
+  if (!existsSync12(dir))
+    mkdirSync4(dir, { recursive: true });
   const filename = `${entry ? entry.key : "invariant"}.md`;
   const fragmentPath2 = join15(dir, filename);
-  const fragmentSha256 = sha2569(content);
-  writeFileSync4(fragmentPath2, content, "utf8");
+  const fragmentSha256 = sha2568(content);
+  writeFileSync3(fragmentPath2, content, "utf8");
   const manifestPath = join15(dir, PROVIDER_CONTEXT_MANIFEST);
   let manifest = { schema: PROVIDER_CONTEXT_SCHEMA, fragments: {} };
   try {
-    if (existsSync13(manifestPath)) {
-      const parsed = JSON.parse(readFileSync12(manifestPath, "utf8"));
+    if (existsSync12(manifestPath)) {
+      const parsed = JSON.parse(readFileSync11(manifestPath, "utf8"));
       if (parsed && typeof parsed === "object")
         manifest = parsed;
     }
@@ -16110,7 +15976,7 @@ function resolveAndRenderProviderContext(opts) {
     rawModel: opts.rawModel || null
   };
   manifest.fragments = fragmentsObj;
-  writeFileSync4(manifestPath, JSON.stringify(manifest, null, 2), "utf8");
+  writeFileSync3(manifestPath, JSON.stringify(manifest, null, 2), "utf8");
   return {
     entry,
     rawEndpoint: opts.rawEndpoint,
@@ -16210,10 +16076,10 @@ init_session_render();
 
 // src/lib/station-profile.ts
 init_raw_store_root();
-import { spawnSync as spawnSync4 } from "child_process";
-import { existsSync as existsSync14, lstatSync as lstatSync5, mkdirSync as mkdirSync6, readFileSync as readFileSync13, readdirSync as readdirSync2, writeFileSync as writeFileSync5 } from "fs";
+import { spawnSync as spawnSync3 } from "child_process";
+import { existsSync as existsSync13, lstatSync as lstatSync5, mkdirSync as mkdirSync5, readFileSync as readFileSync12, readdirSync as readdirSync2, writeFileSync as writeFileSync4 } from "fs";
 import { arch as osArch, homedir as homedir9, hostname as osHostname3, platform as osPlatform, userInfo as osUserInfo } from "os";
-import { dirname as dirname9, join as join16 } from "path";
+import { dirname as dirname8, join as join16 } from "path";
 var STATION_PROFILE_CACHE_FILENAME = "station-profile.md";
 var STATION_PROFILE_SOURCE_ID = "station-profile";
 var STATION_PROFILE_LAYER = "machine";
@@ -16237,9 +16103,9 @@ function getBunGlobalModulesDir(env = process.env) {
 }
 function readMachinesManifest(path) {
   try {
-    if (!existsSync14(path))
+    if (!existsSync13(path))
       return null;
-    const parsed = JSON.parse(readFileSync13(path, "utf8"));
+    const parsed = JSON.parse(readFileSync12(path, "utf8"));
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
       return null;
     const machines = parsed["machines"];
@@ -16269,7 +16135,7 @@ function metadataUser(record) {
 }
 function probeMachineStatus(machineId) {
   try {
-    const result = spawnSync4("machines", ["details", "--json", "--machine", machineId], {
+    const result = spawnSync3("machines", ["details", "--json", "--machine", machineId], {
       encoding: "utf8",
       timeout: 3000,
       stdio: ["ignore", "pipe", "pipe"]
@@ -16295,7 +16161,7 @@ function resolveStationProfileMachine(env = process.env, options = {}) {
   const record = findLocalManifestMachine(readMachinesManifest(getMachinesManifestPath(env)), hostname2);
   const home = homeDir6(env);
   const platform = stringField(record, "platform") ?? osPlatform();
-  const workspacePath = stringField(record, "workspacePath") ?? join16(home, platform === "darwin" ? "Workspace" : "workspace");
+  const workspacePath = stringField(record, "workspacePath");
   const machine = {
     id: stringField(record, "id") ?? hostname2,
     hostname: stringField(record, "hostname") ?? hostname2,
@@ -16314,7 +16180,7 @@ function resolveStationProfileMachine(env = process.env, options = {}) {
 function scopedPackageNames(modulesDir, scope) {
   const scopeDir = join16(modulesDir, scope);
   try {
-    if (!existsSync14(scopeDir))
+    if (!existsSync13(scopeDir))
       return null;
     return readdirNames(scopeDir).sort();
   } catch {
@@ -16334,7 +16200,7 @@ function resolveStationProfilePackages(env = process.env) {
   const modulesDir = getBunGlobalModulesDir(env);
   let scopeDirs;
   try {
-    if (!existsSync14(modulesDir))
+    if (!existsSync13(modulesDir))
       return null;
     scopeDirs = readdirNames(modulesDir).filter((name) => name.startsWith("@") && name.toLowerCase().includes("hasna"));
   } catch {
@@ -16409,10 +16275,10 @@ function refreshStationProfile(options = {}) {
   const path = getStationProfileCachePath(env);
   const generatedAt = new Date().toISOString();
   if (!options.dryRun) {
-    const existing = existsSync14(path) ? readFileSync13(path, "utf8") : null;
+    const existing = existsSync13(path) ? readFileSync12(path, "utf8") : null;
     if (existing !== content) {
-      mkdirSync6(dirname9(path), { recursive: true });
-      writeFileSync5(path, content, "utf8");
+      mkdirSync5(dirname8(path), { recursive: true });
+      writeFileSync4(path, content, "utf8");
     }
   }
   return {
@@ -16428,9 +16294,9 @@ function refreshStationProfile(options = {}) {
 function readStationProfile(env = process.env) {
   const path = getStationProfileCachePath(env);
   try {
-    if (!existsSync14(path))
+    if (!existsSync13(path))
       return null;
-    return readFileSync13(path, "utf8");
+    return readFileSync12(path, "utf8");
   } catch {
     return null;
   }
@@ -16454,22 +16320,172 @@ function stationProfileSource(env = process.env) {
 init_instruction_graph();
 init_asset_plan();
 
+// src/lib/harness-discovery.ts
+import { accessSync, constants as constants2, lstatSync as lstatSync6, realpathSync as realpathSync4, statSync as statSync5 } from "fs";
+import { homedir as homedir10 } from "os";
+import { delimiter, dirname as dirname9, isAbsolute as isAbsolute7, join as join17, resolve as resolve11 } from "path";
+var HARNESS_DISCOVERY_SCHEMA = "hasna.instructions.harness-discovery/v1";
+var DISCOVERABLE_HARNESSES = ["claude", "codex", "opencode", "sumi"];
+function pathInput(value, home) {
+  if (!value || value !== value.trim() || /[\x00-\x1f\x7f]/.test(value))
+    throw new Error("Harness paths must be nonempty and contain no surrounding whitespace or control characters.");
+  if (value.split("/").some((segment) => segment === "." || segment === ".."))
+    throw new Error("Harness paths must not contain dot segments; normalizing them can change a symlink destination.");
+  let path = value;
+  if (home) {
+    for (const prefix of ["~", "{{HOME}}", "{{HOME_DIR}}", "${HOME}"]) {
+      if (path === prefix)
+        path = home;
+      else if (path.startsWith(`${prefix}/`))
+        path = join17(home, path.slice(prefix.length + 1));
+    }
+  }
+  if (!isAbsolute7(path))
+    throw new Error("Harness paths must be absolute or explicitly relative to the owner home (~/ or {{HOME_DIR}}/).");
+  return resolve11(path);
+}
+function observe(path) {
+  let symlink = false;
+  let viaSymlink = false;
+  for (let parent = dirname9(path);parent !== dirname9(parent); parent = dirname9(parent)) {
+    try {
+      if (lstatSync6(parent).isSymbolicLink()) {
+        viaSymlink = true;
+        break;
+      }
+    } catch {}
+  }
+  try {
+    symlink = lstatSync6(path).isSymbolicLink();
+    const stat = statSync5(path);
+    return { path, state: "present", realPath: realpathSync4(path), symlink, viaSymlink: viaSymlink || symlink, type: stat.isFile() ? "file" : stat.isDirectory() ? "directory" : "other" };
+  } catch (error) {
+    const missing = error.code === "ENOENT";
+    return { path, state: missing ? symlink ? "dangling-symlink" : "missing" : "unreadable", realPath: null, symlink, viaSymlink: viaSymlink || symlink, type: null };
+  }
+}
+function executableAt(path) {
+  const observation = observe(path);
+  if (observation.type !== "file")
+    return null;
+  try {
+    accessSync(path, constants2.X_OK);
+    return observation;
+  } catch {
+    return null;
+  }
+}
+function configSelection(tool, home, env, override) {
+  if (override !== undefined)
+    return { path: pathInput(override, home), source: "override" };
+  const key = { claude: "CLAUDE_CONFIG_DIR", codex: "CODEX_HOME", opencode: "OPENCODE_CONFIG_DIR", sumi: "SUMI_CONFIG_DIR" }[tool];
+  const nativePath = (value, selector) => {
+    try {
+      return pathInput(value);
+    } catch {
+      throw new Error(`${selector} is present but is not an unambiguous absolute native path; supply the reviewed runtime path explicitly.`);
+    }
+  };
+  if (env[key] !== undefined && !(tool === "codex" && env[key] === ""))
+    return { path: nativePath(env[key], key), source: key };
+  if (tool === "claude" || tool === "codex")
+    return { path: join17(home, `.${tool}`), source: "native-default" };
+  if (env.XDG_CONFIG_HOME !== undefined)
+    return { path: join17(nativePath(env.XDG_CONFIG_HOME, "XDG_CONFIG_HOME"), tool), source: "XDG_CONFIG_HOME" };
+  if (tool === "sumi") {
+    if (env.SUMI_HOME !== undefined)
+      return { path: join17(nativePath(env.SUMI_HOME, "SUMI_HOME"), "config"), source: "SUMI_HOME" };
+    return null;
+  }
+  return { path: join17(home, ".config", tool), source: "native-default" };
+}
+function discoverHarnesses(options = {}) {
+  const env = options.env ?? process.env;
+  const home = pathInput(options.ownerHome ?? env.HOME ?? env.USERPROFILE ?? homedir10());
+  const project = options.projectRoot === undefined ? null : observe(pathInput(options.projectRoot, home));
+  const variables = { HOME_DIR: home };
+  if (project)
+    variables.PROJECT_ROOT = project.path;
+  const tools = DISCOVERABLE_HARNESSES.map((tool) => {
+    const diagnostics = [];
+    const override = options.overrides?.[tool];
+    let executable = null;
+    let executableSource = null;
+    if (override?.executable !== undefined) {
+      executable = executableAt(pathInput(override.executable, home));
+      executableSource = "override";
+      if (!executable)
+        diagnostics.push("Explicit executable is missing, unreadable, not a file, or not executable; PATH fallback is disabled.");
+    } else {
+      for (const directory of (env.PATH ?? "").split(delimiter)) {
+        if (!isAbsolute7(directory)) {
+          const warning = "Relative or empty PATH entries were ignored; this is an absolute-path candidate inventory, not proof of the launcher's selected executable.";
+          if (!diagnostics.includes(warning))
+            diagnostics.push(warning);
+          continue;
+        }
+        let validated;
+        try {
+          validated = pathInput(directory);
+        } catch {
+          diagnostics.push("An ambiguous PATH directory was ignored; use an explicit executable override after reviewing its native path.");
+          continue;
+        }
+        executable = executableAt(join17(validated, tool));
+        if (executable) {
+          executableSource = "PATH";
+          break;
+        }
+      }
+    }
+    let selected = null;
+    let configError = false;
+    try {
+      selected = configSelection(tool, home, env, override?.configDir);
+    } catch (error) {
+      if (override?.configDir !== undefined)
+        throw error;
+      configError = true;
+      diagnostics.push(`Config root unresolved: ${error.message}`);
+    }
+    const config = selected ? { ...observe(selected.path), source: selected.source } : null;
+    const filename = tool === "claude" ? "CLAUDE.md" : "AGENTS.md";
+    const globalPrompt = config ? observe(join17(config.path, filename)) : null;
+    const promptOverrides = tool === "codex" ? [...new Set([config?.path, project?.path].filter((path) => !!path))].map((path) => observe(join17(path, "AGENTS.override.md"))) : [];
+    if (!config && !configError)
+      diagnostics.push("Config root unresolved: supply the actual `sumi debug paths config` result as a configDir override; no runtime or migration was invoked.");
+    if (executable) {
+      variables[`${tool.toUpperCase()}_EXECUTABLE`] = executable.path;
+      if (config)
+        variables[`${tool.toUpperCase()}_CONFIG_DIR`] = config.path;
+    }
+    const linkedGlobal = !!globalPrompt?.viaSymlink || !!config?.viaSymlink;
+    const hasOverride = promptOverrides.some((path) => path.state !== "missing" || path.viaSymlink);
+    const scopeReviewRequired = linkedGlobal || hasOverride;
+    if (linkedGlobal)
+      diagnostics.push("Global config or prompt resolves through a symlink; preserve its lexical path and review the destination scope before planning writes.");
+    if (hasOverride)
+      diagnostics.push("A Codex AGENTS.override.md candidate may take precedence; review its native loader behavior and scope before applying AGENTS.md.");
+    return { tool, status: executable ? "executable-found" : "absent", executable, executableSource, versionEvidence: "not-probed", config, globalPrompt, projectPrompt: project ? observe(join17(project.path, filename)) : null, promptOverrides, scopeReviewRequired, diagnostics };
+  });
+  return { schema: HARNESS_DISCOVERY_SCHEMA, ownerHome: observe(home), projectRoot: project, tools, templateVariables: variables };
+}
 // src/lib/session-apply.ts
 init_project_context();
 init_session_render_state();
 init_session_render();
 init_cursor_authority();
 init_session_authority();
-import { createHash as createHash10, randomUUID as randomUUID4 } from "crypto";
+import { createHash as createHash9, randomUUID as randomUUID4 } from "crypto";
 import {
-  existsSync as existsSync15,
-  lstatSync as lstatSync6,
-  mkdirSync as mkdirSync7,
-  readFileSync as readFileSync14,
+  existsSync as existsSync14,
+  lstatSync as lstatSync7,
+  mkdirSync as mkdirSync6,
+  readFileSync as readFileSync13,
   readdirSync as readdirSync3,
-  statSync as statSync5
+  statSync as statSync6
 } from "fs";
-import { dirname as dirname10, isAbsolute as isAbsolute7, join as join17, parse as parse5, relative as relative6, resolve as resolve11 } from "path";
+import { dirname as dirname10, isAbsolute as isAbsolute8, join as join18, parse as parse4, posix as posix3, relative as relative5, resolve as resolve12 } from "path";
 class SessionApplyError extends Error {
   constructor(message) {
     super(message);
@@ -16499,13 +16515,15 @@ function applySessionRenderUnlocked(plan, options, coordination) {
   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 retirements = validateFileRetirements(plan, targetHome, previousManifest, options);
+  const retiredHashes = new Map(retirements.map((entry) => [entry.relativePath, entry.preimageSha256]));
+  const manifestFile = manifestWithFileProvenance(plan, previousManifest, adoptions, reconciliations, retirements);
   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, adoptedHashes, reconciledHashes)),
-    ...planStaleFileResults(plan, targetHome, previousManifest, currentRelativePaths, options)
+    ...planStaleFileResults(plan, targetHome, previousManifest, currentRelativePaths, options, retiredHashes)
   ];
   assertNotSilentManagedWipeout(plan, results);
   const conflicts = results.filter((result) => result.action === "conflict");
@@ -16529,7 +16547,8 @@ function applySessionRenderUnlocked(plan, options, coordination) {
       conflicts,
       drift,
       adoptions,
-      reconciliations
+      reconciliations,
+      retirements
     };
   }
   let snapshotPath = null;
@@ -16544,10 +16563,14 @@ function applySessionRenderUnlocked(plan, options, coordination) {
     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, adoptions, reconciliations);
+    rollback = writeSessionSnapshot(plan, targetHome, manifestPath, results, previousManifest, coordination, allowPortableFallback, forcePortableFileOps, adoptions, reconciliations, retirements);
     snapshotPath = rollback.snapshotPath;
     options.test_hooks?.before_apply_writes?.({ plan, results });
     assertManifestPrecondition(manifestPath, targetHome, options.expectedManifestSha256);
+    for (const result of results) {
+      assertExpectedSessionFileHash(result.path, targetHome, result.previousSha256);
+      coordination?.assert_held();
+    }
     const resultsByPath = new Map(results.map((result) => [result.path, result]));
     for (const file of payloadFiles) {
       applyPlannedFile(plan, file, targetHome, resultsByPath, coordination, allowPortableFallback, forcePortableFileOps);
@@ -16583,7 +16606,8 @@ function applySessionRenderUnlocked(plan, options, coordination) {
     conflicts,
     drift,
     adoptions,
-    reconciliations
+    reconciliations,
+    retirements
   };
 }
 function assertManifestPrecondition(path, targetHome, expected) {
@@ -16612,7 +16636,7 @@ function validateFileAdoptions(plan, targetHome, previousHashes, options) {
       throw new SessionApplyError(`Duplicate file adoption target: ${request.relativePath}`);
     }
     seen.add(request.relativePath);
-    const candidates = plan.files.filter((file2) => file2.relativePath === request.relativePath);
+    const candidates = exactPreimageCandidates(plan).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}`);
     }
@@ -16631,15 +16655,19 @@ function validateFileAdoptions(plan, targetHome, previousHashes, options) {
     };
   });
 }
+function exactPreimageCandidates(plan) {
+  const customAgentPaths = new Set((plan.assetPlan?.assets ?? []).filter((asset) => asset.kind === "custom-agent" && asset.support === "supported" && asset.action === "write" && asset.destination.strategy === "emit-file").map((asset) => posix3.normalize(asset.destination.relativePath)));
+  return [...plan.files, ...(plan.assetFiles ?? []).filter((file) => customAgentPaths.has(file.relativePath))];
+}
 function readExactFilePreimage(path, targetHome, request, operation) {
   if (currentSessionFileHash(path, targetHome) === null) {
     throw new SessionApplyError(`File ${operation} target does not exist: ${request.relativePath}`);
   }
-  const bytes = readFileSync14(path);
+  const bytes = readFileSync13(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 = createHash10("sha256").update(bytes).digest("hex");
+  const observedSha256 = createHash9("sha256").update(bytes).digest("hex");
   if (observedSha256 !== request.sha256) {
     throw new SessionApplyError(`File ${operation} SHA-256 precondition failed: ${request.relativePath}`);
   }
@@ -16668,7 +16696,7 @@ function validateFileReconciliations(plan, targetHome, previousManifest, options
       throw new SessionApplyError(`Duplicate file reconciliation target: ${request.relativePath}`);
     }
     seen.add(request.relativePath);
-    const candidates = plan.files.filter((file2) => file2.relativePath === request.relativePath);
+    const candidates = exactPreimageCandidates(plan).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}`);
     }
@@ -16695,8 +16723,47 @@ function validateFileReconciliations(plan, targetHome, previousManifest, options
     };
   });
 }
-function manifestWithFileProvenance(plan, previousManifest, adoptions, reconciliations) {
-  if (adoptions.length === 0 && previousManifest?.adoptions === undefined && reconciliations.length === 0 && previousManifest?.reconciliations === undefined)
+function validateFileRetirements(plan, targetHome, previousManifest, options) {
+  const requests = options.retireFiles ?? [];
+  if (!Array.isArray(requests))
+    throw new SessionApplyError("Session file retirements must be an array.");
+  if (requests.length === 0)
+    return [];
+  if (options.force)
+    throw new SessionApplyError("Exact file retirement cannot be combined with force.");
+  if (options.expectedManifestSha256 === undefined) {
+    throw new SessionApplyError("Exact file retirement 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 retirement 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 retirement requires a plan-relative path and a 64-character lowercase SHA-256.");
+    }
+    if (seen.has(request.relativePath))
+      throw new SessionApplyError(`Duplicate file retirement target: ${request.relativePath}`);
+    seen.add(request.relativePath);
+    if (plan.allFiles.some((file) => file.relativePath === request.relativePath)) {
+      throw new SessionApplyError(`File retirement target is retained by the new plan: ${request.relativePath}`);
+    }
+    const owned = previousManifest.files.filter((entry) => entry.relativePath === request.relativePath);
+    const path = resolveManifestRelativePath(request.relativePath, targetHome);
+    if (owned.length !== 1 || owned[0].path !== path || !/^[a-f0-9]{64}$/.test(owned[0].sha256) || !Array.isArray(owned[0].sourceIds) || owned[0].sourceIds.some((id) => typeof id !== "string") || !isPlanManagedFile(plan, request.relativePath, owned[0].role) && owned[0].role !== "asset") {
+      throw new SessionApplyError(`File retirement target is not an obsolete managed fragment, rule, or asset: ${request.relativePath}`);
+    }
+    return {
+      path,
+      relativePath: request.relativePath,
+      preimageSha256: readExactFilePreimage(path, targetHome, request, "retirement"),
+      previousManagedSha256: owned[0].sha256,
+      sourceIds: [...owned[0].sourceIds]
+    };
+  });
+}
+function manifestWithFileProvenance(plan, previousManifest, adoptions, reconciliations, retirements) {
+  if (adoptions.length === 0 && previousManifest?.adoptions === undefined && reconciliations.length === 0 && previousManifest?.reconciliations === undefined && retirements.length === 0 && previousManifest?.retirements === undefined)
     return plan.manifestFile;
   if (previousManifest?.adoptions !== undefined && !Array.isArray(previousManifest.adoptions)) {
     throw new SessionApplyError("Previous session manifest adoption provenance is invalid.");
@@ -16737,14 +16804,32 @@ function manifestWithFileProvenance(plan, previousManifest, adoptions, reconcili
     };
     reconciledEntries.set(JSON.stringify(canonical), canonical);
   }
+  if (previousManifest?.retirements !== undefined && !Array.isArray(previousManifest.retirements)) {
+    throw new SessionApplyError("Previous session manifest retirement provenance is invalid.");
+  }
+  const retiredEntries = new Map;
+  for (const entry of [...previousManifest?.retirements ?? [], ...retirements.map(({ path: _path, ...receipt }) => receipt)]) {
+    if (!entry || typeof entry.relativePath !== "string" || !/^[a-f0-9]{64}$/.test(entry.preimageSha256) || !/^[a-f0-9]{64}$/.test(entry.previousManagedSha256) || !Array.isArray(entry.sourceIds) || entry.sourceIds.some((id) => typeof id !== "string")) {
+      throw new SessionApplyError("Previous session manifest retirement provenance is invalid.");
+    }
+    resolveManifestRelativePath(entry.relativePath, plan.targetHome);
+    const canonical = {
+      relativePath: entry.relativePath,
+      preimageSha256: entry.preimageSha256,
+      previousManagedSha256: entry.previousManagedSha256,
+      sourceIds: [...entry.sourceIds]
+    };
+    retiredEntries.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()] } : {}
+    ...reconciliations.length > 0 || previousManifest?.reconciliations !== undefined ? { reconciliations: [...reconciledEntries.values()] } : {},
+    ...retirements.length > 0 || previousManifest?.retirements !== undefined ? { retirements: [...retiredEntries.values()] } : {}
   };
   const content = `${JSON.stringify(manifest, null, 2)}
 `;
-  return { ...plan.manifestFile, content, sha256: sha25610(content) };
+  return { ...plan.manifestFile, content, sha256: sha2569(content) };
 }
 function assertCursorAuthorityUnchanged(plan) {
   if (plan.tool !== "cursor" || plan.targetKind === "blocked")
@@ -16772,13 +16857,13 @@ function assertClaudeAuthorityStillClear(plan, targetHome, ownedClaudeAuthoritie
   throw new SessionApplyError(`Claude authority changed after planning; refusing to apply: ${summary}`);
 }
 function ensureSessionTargetHome(targetHome) {
-  if (!existsSync15(targetHome))
-    mkdirSync7(targetHome, { recursive: true, mode: 448 });
+  if (!existsSync14(targetHome))
+    mkdirSync6(targetHome, { recursive: true, mode: 448 });
   assertSafeTargetHome(targetHome);
 }
 function checkSessionRenderDrift(targetHome, manifestPath) {
   const safeTargetHome = assertSafeTargetHome(targetHome);
-  const resolvedManifestPath = manifestPath ? resolveManifestRelativePath(relative6(safeTargetHome, resolve11(manifestPath)), safeTargetHome) : resolve11(safeTargetHome, ".hasna", "session-render-manifest.json");
+  const resolvedManifestPath = manifestPath ? resolveManifestRelativePath(relative5(safeTargetHome, resolve12(manifestPath)), safeTargetHome) : resolve12(safeTargetHome, ".hasna", "session-render-manifest.json");
   const checkedAt = new Date().toISOString();
   const previousManifest = readPreviousManifest(resolvedManifestPath);
   if (!previousManifest) {
@@ -16795,7 +16880,7 @@ function checkSessionRenderDrift(targetHome, manifestPath) {
   const drifted = [];
   for (const file of previousManifest.files) {
     const target = resolveManifestRelativePath(file.relativePath, safeTargetHome);
-    if (!existsSync15(target)) {
+    if (!existsSync14(target)) {
       missing.push({
         path: target,
         relativePath: file.relativePath,
@@ -16805,7 +16890,7 @@ function checkSessionRenderDrift(targetHome, manifestPath) {
       });
       continue;
     }
-    const actualSha256 = sha25610(readFileSync14(target, "utf-8"));
+    const actualSha256 = sha2569(readFileSync13(target, "utf-8"));
     if (actualSha256 !== file.sha256) {
       drifted.push({
         path: target,
@@ -16828,13 +16913,13 @@ function checkSessionRenderDrift(targetHome, manifestPath) {
 function restoreSessionRenderSnapshot(snapshotPath, options = {}) {
   const snapshot = readSessionRenderSnapshot(snapshotPath);
   const targetHome = assertSafeTargetHome(snapshot.targetHome);
-  const resolvedSnapshotPath = resolve11(snapshotPath);
+  const resolvedSnapshotPath = resolve12(snapshotPath);
   const snapshotDir = getSessionRenderSnapshotDir(targetHome);
-  const snapshotDirRelative = relative6(snapshotDir, resolvedSnapshotPath);
-  const insideSnapshotDir = snapshotDirRelative !== ".." && !snapshotDirRelative.startsWith("../") && !isAbsolute7(snapshotDirRelative);
+  const snapshotDirRelative = relative5(snapshotDir, resolvedSnapshotPath);
+  const insideSnapshotDir = snapshotDirRelative !== ".." && !snapshotDirRelative.startsWith("../") && !isAbsolute8(snapshotDirRelative);
   if (!insideSnapshotDir) {
-    const snapshotRelativePath = relative6(targetHome, resolvedSnapshotPath);
-    if (snapshotRelativePath === "" || snapshotRelativePath === ".." || snapshotRelativePath.startsWith("../") || isAbsolute7(snapshotRelativePath)) {
+    const snapshotRelativePath = relative5(targetHome, resolvedSnapshotPath);
+    if (snapshotRelativePath === "" || snapshotRelativePath === ".." || snapshotRelativePath.startsWith("../") || isAbsolute8(snapshotRelativePath)) {
       throw new SessionApplyError("Session snapshot must be stored inside its session-render snapshot location.");
     }
   }
@@ -16951,19 +17036,19 @@ function requiredRestoreHash(file) {
   return file.previousSha256;
 }
 function readSessionRenderSnapshot(snapshotPath) {
-  const resolved = resolve11(snapshotPath);
-  if (!existsSync15(resolved))
+  const resolved = resolve12(snapshotPath);
+  if (!existsSync14(resolved))
     throw new SessionApplyError(`Session snapshot not found: ${snapshotPath}`);
-  const stat = lstatSync6(resolved);
+  const stat = lstatSync7(resolved);
   if (stat.isSymbolicLink() || !stat.isFile()) {
     throw new SessionApplyError(`Session snapshot is not a regular file: ${snapshotPath}`);
   }
-  if (statSync5(resolved).size > 32 * 1024 * 1024) {
+  if (statSync6(resolved).size > 32 * 1024 * 1024) {
     throw new SessionApplyError(`Session snapshot exceeds the 32 MiB restore limit: ${snapshotPath}`);
   }
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync14(resolved, "utf8"));
+    parsed = JSON.parse(readFileSync13(resolved, "utf8"));
   } catch {
     throw new SessionApplyError(`Session snapshot is not valid JSON: ${snapshotPath}`);
   }
@@ -16985,7 +17070,7 @@ function readSessionRenderSnapshot(snapshotPath) {
   const previousManifest = snapshot.previousManifest;
   const previousFiles = new Map;
   for (const file of snapshot.files) {
-    if (!file || typeof file.relativePath !== "string" || typeof file.path !== "string" || typeof file.sha256 !== "string" || typeof file.content !== "string" || sha25610(file.content) !== file.sha256) {
+    if (!file || typeof file.relativePath !== "string" || typeof file.path !== "string" || typeof file.sha256 !== "string" || typeof file.content !== "string" || sha2569(file.content) !== file.sha256) {
       throw new SessionApplyError(`Session snapshot previous file metadata is invalid: ${snapshotPath}`);
     }
     resolveSnapshotFilePath(file.relativePath, file.path, targetHome);
@@ -17032,8 +17117,8 @@ function readSessionRenderSnapshot(snapshotPath) {
 }
 function reconstructPreRollbackLegacyV1Snapshot(snapshot, previousFiles, previousManifestFiles, targetHome, snapshotPath) {
   assertNoNewerSessionSnapshot(snapshotPath, snapshot.createdAt, targetHome);
-  const manifestPath = resolve11(snapshot.manifestPath);
-  const manifestRelativePath = relative6(targetHome, manifestPath).replaceAll("\\", "/");
+  const manifestPath = resolve12(snapshot.manifestPath);
+  const manifestRelativePath = relative5(targetHome, manifestPath).replaceAll("\\", "/");
   resolveSnapshotFilePath(manifestRelativePath, snapshot.manifestPath, targetHome);
   const manifestSha256 = currentSessionFileHash(manifestPath, targetHome);
   if (manifestSha256 === null) {
@@ -17041,7 +17126,7 @@ function reconstructPreRollbackLegacyV1Snapshot(snapshot, previousFiles, previou
   }
   let parsedManifest;
   try {
-    parsedManifest = JSON.parse(readFileSync14(manifestPath, "utf8"));
+    parsedManifest = JSON.parse(readFileSync13(manifestPath, "utf8"));
   } catch {
     throw new SessionApplyError(`Pre-rollback legacy v1 applied manifest is not valid JSON: ${snapshotPath}`);
   }
@@ -17049,7 +17134,7 @@ function reconstructPreRollbackLegacyV1Snapshot(snapshot, previousFiles, previou
     throw new SessionApplyError(`Pre-rollback legacy v1 applied manifest is invalid: ${snapshotPath}`);
   }
   const appliedManifest = parsedManifest;
-  if (appliedManifest.schema !== SESSION_RENDER_SCHEMA || appliedManifest.tool !== snapshot.tool || appliedManifest.profile !== snapshot.profile || typeof appliedManifest.targetHome !== "string" || resolve11(appliedManifest.targetHome) !== targetHome || appliedManifest.targetKind !== "session-home" && appliedManifest.targetKind !== "project-root" || !Array.isArray(appliedManifest.files)) {
+  if (appliedManifest.schema !== SESSION_RENDER_SCHEMA || appliedManifest.tool !== snapshot.tool || appliedManifest.profile !== snapshot.profile || typeof appliedManifest.targetHome !== "string" || resolve12(appliedManifest.targetHome) !== targetHome || appliedManifest.targetKind !== "session-home" && appliedManifest.targetKind !== "project-root" || !Array.isArray(appliedManifest.files)) {
     throw new SessionApplyError(`Pre-rollback legacy v1 applied manifest does not match its snapshot: ${snapshotPath}`);
   }
   const afterFiles = [];
@@ -17134,16 +17219,16 @@ function assertNoNewerSessionSnapshot(snapshotPath, createdAt, targetHome) {
     throw new SessionApplyError(`Pre-rollback legacy v1 snapshot has an invalid creation time: ${snapshotPath}`);
   }
   for (const entry of readdirSync3(dirname10(snapshotPath))) {
-    const candidatePath = resolve11(dirname10(snapshotPath), entry);
-    if (candidatePath === resolve11(snapshotPath) || !entry.endsWith(".json"))
+    const candidatePath = resolve12(dirname10(snapshotPath), entry);
+    if (candidatePath === resolve12(snapshotPath) || !entry.endsWith(".json"))
       continue;
-    const candidateStat = lstatSync6(candidatePath);
+    const candidateStat = lstatSync7(candidatePath);
     if (candidateStat.isSymbolicLink() || !candidateStat.isFile() || candidateStat.size > 32 * 1024 * 1024)
       continue;
     try {
-      const candidate = JSON.parse(readFileSync14(candidatePath, "utf8"));
+      const candidate = JSON.parse(readFileSync13(candidatePath, "utf8"));
       const candidateCreatedAtMs = typeof candidate.createdAt === "string" ? Date.parse(candidate.createdAt) : Number.NaN;
-      if ((candidate.schema === "hasna.configs.session-render-snapshot/v1" || candidate.schema === "hasna.configs.session-render-snapshot/v2") && typeof candidate.targetHome === "string" && resolve11(candidate.targetHome) === targetHome && Number.isFinite(candidateCreatedAtMs) && candidateCreatedAtMs >= createdAtMs) {
+      if ((candidate.schema === "hasna.configs.session-render-snapshot/v1" || candidate.schema === "hasna.configs.session-render-snapshot/v2") && typeof candidate.targetHome === "string" && resolve12(candidate.targetHome) === targetHome && Number.isFinite(candidateCreatedAtMs) && candidateCreatedAtMs >= createdAtMs) {
         throw new SessionApplyError(`Cannot restore pre-rollback legacy v1 snapshot after a newer session snapshot exists: ${candidatePath}`);
       }
     } catch (error) {
@@ -17201,7 +17286,7 @@ function inferLegacySnapshotAction(file, previousFiles, previousManifestFiles, p
     return "create";
   }
   if (file.role === "manifest" && previousManifest) {
-    const previousManifestSha256 = sha25610(`${JSON.stringify(previousManifest, null, 2)}
+    const previousManifestSha256 = sha2569(`${JSON.stringify(previousManifest, null, 2)}
 `);
     if (previousManifestSha256 !== file.sha256) {
       throw new SessionApplyError(`Cannot infer legacy v1 manifest action without a before-image: ${file.relativePath}`);
@@ -17212,15 +17297,15 @@ function inferLegacySnapshotAction(file, previousFiles, previousManifestFiles, p
 }
 function resolveSnapshotFilePath(relativePath, recordedPath, targetHome) {
   const path = resolveManifestRelativePath(relativePath, targetHome);
-  if (resolve11(recordedPath) !== path) {
+  if (resolve12(recordedPath) !== path) {
     throw new SessionApplyError(`Session snapshot file path mismatch for ${relativePath}`);
   }
   return path;
 }
 function planFileResult(plan, file, targetHome, previousHashes, previousManifest, options, adoptedHashes, reconciledHashes) {
   const target = resolvePlannedFilePath(plan, file, targetHome);
-  const previousContent = existsSync15(target) ? readFileSync14(target, "utf-8") : null;
-  const previousSha256 = previousContent === null ? null : sha25610(previousContent);
+  const previousContent = existsSync14(target) ? readFileSync13(target, "utf-8") : null;
+  const previousSha256 = previousContent === null ? null : sha2569(previousContent);
   const previouslyManaged = isPreviouslyManaged(file, previousSha256, previousHashes, previousManifest);
   const changed = previousContent !== file.content;
   const exactSha256 = adoptedHashes.get(file.relativePath) ?? reconciledHashes.get(file.relativePath);
@@ -17328,17 +17413,55 @@ function isPlanManagedFile(plan, relativePath, role) {
     return true;
   return plan.tool === "claude" && role === "rule" && relativePath.startsWith("rules/");
 }
-function planStaleFileResults(plan, targetHome, previousManifest, currentRelativePaths, options) {
+function planStaleFileResults(plan, targetHome, previousManifest, currentRelativePaths, options, retiredHashes) {
   if (!previousManifest)
     return [];
-  return previousManifest.files.filter((file) => !currentRelativePaths.has(file.relativePath)).filter((file) => isPlanManagedFile(plan, file.relativePath, file.role)).map((file) => planStaleFileResult(file, targetHome, options)).filter((result) => result !== null);
+  return previousManifest.files.filter((file) => !currentRelativePaths.has(file.relativePath)).filter((file) => isPlanManagedFile(plan, file.relativePath, file.role) || file.role === "asset" || retiredHashes.has(file.relativePath)).map((file) => planStaleFileResult(file, targetHome, options, retiredHashes.get(file.relativePath))).filter((result) => result !== null);
 }
-function planStaleFileResult(file, targetHome, options) {
+function planStaleFileResult(file, targetHome, options, retiredHash) {
   const target = resolveManifestRelativePath(file.relativePath, targetHome);
-  if (!existsSync15(target))
-    return null;
-  const previousContent = readFileSync14(target, "utf-8");
-  const previousSha256 = sha25610(previousContent);
+  if (!existsSync14(target)) {
+    if (file.role !== "asset")
+      return null;
+    return {
+      path: target,
+      relativePath: file.relativePath,
+      role: file.role,
+      action: "conflict",
+      changed: true,
+      previousSha256: null,
+      newSha256: "",
+      reason: "obsolete managed asset is missing; preserve manifest ownership until its reviewed preimage is restored and retired exactly"
+    };
+  }
+  const previousContent = readFileSync13(target, "utf-8");
+  const previousSha256 = sha2569(previousContent);
+  if (retiredHash !== undefined) {
+    if (previousSha256 !== retiredHash)
+      throw new SessionApplyError(`File retirement preimage changed after validation: ${file.relativePath}`);
+    return {
+      path: target,
+      relativePath: file.relativePath,
+      role: file.role,
+      action: "delete",
+      changed: true,
+      previousSha256,
+      newSha256: "",
+      reason: "exact reviewed obsolete managed file retired"
+    };
+  }
+  if (file.role === "asset") {
+    return {
+      path: target,
+      relativePath: file.relativePath,
+      role: file.role,
+      action: "conflict",
+      changed: true,
+      previousSha256,
+      newSha256: "",
+      reason: "obsolete managed asset requires exact retirement; preserve ownership until --retire-file and --expected-manifest-sha256 are supplied"
+    };
+  }
   if (!options.force && previousSha256 !== file.sha256) {
     return {
       path: target,
@@ -17382,31 +17505,31 @@ function isPreviouslyManaged(file, previousSha256, previousHashes, previousManif
   return previousHashes.get(file.relativePath) === previousSha256;
 }
 function resolvePlannedFilePath(plan, file, targetHome) {
-  const target = resolve11(targetHome, ...file.relativePath.split("/"));
-  const rel = relative6(targetHome, target);
-  if (rel === "" || rel === ".." || rel.startsWith("../") || isAbsolute7(rel)) {
+  const target = resolve12(targetHome, ...file.relativePath.split("/"));
+  const rel = relative5(targetHome, target);
+  if (rel === "" || rel === ".." || rel.startsWith("../") || isAbsolute8(rel)) {
     throw new SessionApplyError(`Session file escapes target home: ${file.relativePath}`);
   }
-  if (resolve11(file.path) !== target) {
+  if (resolve12(file.path) !== target) {
     throw new SessionApplyError(`Session file path mismatch for ${file.relativePath}: ${file.path}`);
   }
   assertNoSymlinkSegments2(targetHome, target);
   return target;
 }
 function resolveManifestRelativePath(relativePath, targetHome) {
-  const target = resolve11(targetHome, ...relativePath.split(/[\\/]+/));
-  const rel = relative6(targetHome, target);
-  if (rel === "" || rel === ".." || rel.startsWith("../") || isAbsolute7(rel)) {
+  const target = resolve12(targetHome, ...relativePath.split(/[\\/]+/));
+  const rel = relative5(targetHome, target);
+  if (rel === "" || rel === ".." || rel.startsWith("../") || isAbsolute8(rel)) {
     throw new SessionApplyError(`Session manifest file escapes target home: ${relativePath}`);
   }
   assertNoSymlinkSegments2(targetHome, target);
   return target;
 }
 function readPreviousManifest(path) {
-  if (!existsSync15(path))
+  if (!existsSync14(path))
     return null;
   try {
-    const parsed = JSON.parse(readFileSync14(path, "utf-8"));
+    const parsed = JSON.parse(readFileSync13(path, "utf-8"));
     if (parsed.schema !== SESSION_RENDER_SCHEMA)
       return null;
     if (!Array.isArray(parsed.files))
@@ -17440,18 +17563,18 @@ function applyPlannedFile(plan, file, targetHome, resultsByPath, coordination, a
 function assertExpectedSessionFileHash(path, targetHome, expectedHash) {
   const actualHash = currentSessionFileHash(path, targetHome);
   if (actualHash !== expectedHash) {
-    throw new SessionApplyError(`Session apply path changed after planning: ${relative6(targetHome, path)}`);
+    throw new SessionApplyError(`Session apply path changed after planning: ${relative5(targetHome, path)}`);
   }
 }
 function currentSessionFileHash(path, targetHome) {
   assertNoSymlinkSegments2(targetHome, path);
-  if (!existsSync15(path))
+  if (!existsSync14(path))
     return null;
-  const stat = lstatSync6(path);
+  const stat = lstatSync7(path);
   if (stat.isSymbolicLink() || !stat.isFile()) {
     throw new SessionApplyError(`Session apply path is not a regular file: ${path}`);
   }
-  return sha25610(readFileSync14(path, "utf-8"));
+  return sha2569(readFileSync13(path, "utf-8"));
 }
 function requiredPreviousHash(result) {
   if (result.previousSha256 === null) {
@@ -17459,18 +17582,18 @@ function requiredPreviousHash(result) {
   }
   return result.previousSha256;
 }
-function writeSessionSnapshot(plan, targetHome, manifestPath, results, previousManifest, coordination, allowPortableFallback, forcePortableFileOps, adoptions, reconciliations) {
+function writeSessionSnapshot(plan, targetHome, manifestPath, results, previousManifest, coordination, allowPortableFallback, forcePortableFileOps, adoptions, reconciliations, retirements) {
   const existingFiles = results.filter((result) => result.action === "update" || result.action === "delete").map((result) => {
     assertExpectedSessionFileHash(result.path, targetHome, result.previousSha256);
-    const content = readFileSync14(result.path, "utf-8");
-    if (sha25610(content) !== result.previousSha256) {
+    const content = readFileSync13(result.path, "utf-8");
+    if (sha2569(content) !== result.previousSha256) {
       throw new SessionApplyError(`Session snapshot preimage changed after planning: ${result.relativePath}`);
     }
     return {
       path: result.path,
       relativePath: result.relativePath,
       role: result.role,
-      sha256: sha25610(content),
+      sha256: sha2569(content),
       content
     };
   });
@@ -17483,7 +17606,7 @@ function writeSessionSnapshot(plan, targetHome, manifestPath, results, previousM
     };
   }
   const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-  const snapshotPath = join17(getSessionRenderSnapshotDir(targetHome), `${timestamp}-${randomUUID4()}.json`);
+  const snapshotPath = join18(getSessionRenderSnapshotDir(targetHome), `${timestamp}-${randomUUID4()}.json`);
   const afterFiles = results.map((result) => {
     if (result.action === "conflict") {
       throw new SessionApplyError(`Cannot snapshot unresolved conflict: ${result.relativePath}`);
@@ -17508,11 +17631,12 @@ function writeSessionSnapshot(plan, targetHome, manifestPath, results, previousM
     files: existingFiles,
     afterFiles,
     ...adoptions.length > 0 ? { adoptions } : {},
-    ...reconciliations.length > 0 ? { reconciliations } : {}
+    ...reconciliations.length > 0 ? { reconciliations } : {},
+    ...retirements.length > 0 ? { retirements } : {}
   };
   const snapshotContent = `${JSON.stringify(snapshot, null, 2)}
 `;
-  if ((adoptions.length > 0 || reconciliations.length > 0) && Buffer.byteLength(snapshotContent, "utf8") > 32 * 1024 * 1024) {
+  if ((adoptions.length > 0 || reconciliations.length > 0 || retirements.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();
@@ -17535,51 +17659,51 @@ function writeSessionSnapshot(plan, targetHome, manifestPath, results, previousM
   };
 }
 function assertSafeTargetHome(targetHome) {
-  if (!isAbsolute7(targetHome))
+  if (!isAbsolute8(targetHome))
     throw new SessionApplyError(`Session target home must be absolute: ${targetHome}`);
-  const normalized = resolve11(targetHome);
-  if (normalized === parse5(normalized).root) {
+  const normalized = resolve12(targetHome);
+  if (normalized === parse4(normalized).root) {
     throw new SessionApplyError(`Session target home cannot be the filesystem root: ${targetHome}`);
   }
-  assertNoSymlinkAncestors3(normalized);
-  if (existsSync15(normalized) && lstatSync6(normalized).isSymbolicLink()) {
+  assertNoSymlinkAncestors2(normalized);
+  if (existsSync14(normalized) && lstatSync7(normalized).isSymbolicLink()) {
     throw new SessionApplyError(`Session target home cannot be a symlink: ${normalized}`);
   }
   return normalized;
 }
 function assertNoSymlinkSegments2(root, target) {
-  assertNoSymlinkAncestors3(root);
-  const rel = relative6(root, target);
+  assertNoSymlinkAncestors2(root);
+  const rel = relative5(root, target);
   let current = root;
   for (const segment of rel.split(/[\\/]+/).filter(Boolean)) {
-    current = join17(current, segment);
-    if (existsSync15(current) && lstatSync6(current).isSymbolicLink()) {
+    current = join18(current, segment);
+    if (existsSync14(current) && lstatSync7(current).isSymbolicLink()) {
       throw new SessionApplyError(`Session apply path uses a symlink: ${current}`);
     }
   }
 }
-function assertNoSymlinkAncestors3(path) {
-  const normalized = resolve11(path);
-  const parsed = parse5(normalized);
+function assertNoSymlinkAncestors2(path) {
+  const normalized = resolve12(path);
+  const parsed = parse4(normalized);
   let current = parsed.root;
-  const rel = relative6(parsed.root, normalized);
+  const rel = relative5(parsed.root, normalized);
   for (const segment of rel.split(/[\\/]+/).filter(Boolean)) {
-    current = join17(current, segment);
-    if (!existsSync15(current))
+    current = join18(current, segment);
+    if (!existsSync14(current))
       return;
-    if (lstatSync6(current).isSymbolicLink()) {
+    if (lstatSync7(current).isSymbolicLink()) {
       throw new SessionApplyError(`Session apply path uses a symlink ancestor: ${current}`);
     }
   }
 }
-function sha25610(content) {
-  return createHash10("sha256").update(content).digest("hex");
+function sha2569(content) {
+  return createHash9("sha256").update(content).digest("hex");
 }
 // src/lib/session-refresh.ts
 init_zod();
-import { createHash as createHash11 } from "crypto";
-import { closeSync as closeSync4, constants as constants2, fstatSync as fstatSync4, lstatSync as lstatSync7, openSync as openSync4, readFileSync as readFileSync15 } from "fs";
-import { dirname as dirname11, join as join18, parse as parse6, resolve as resolve12 } from "path";
+import { createHash as createHash10 } from "crypto";
+import { closeSync as closeSync4, constants as constants3, fstatSync as fstatSync4, lstatSync as lstatSync8, openSync as openSync4, readFileSync as readFileSync14 } from "fs";
+import { basename as basename6, dirname as dirname11, isAbsolute as isAbsolute9, join as join19, parse as parse5, resolve as resolve13 } from "path";
 
 // src/lib/global-source-coverage.ts
 var GLOBAL_SOURCE_SLUG_PREFIX = "global-";
@@ -17612,7 +17736,6 @@ function computeGlobalSourceCoverage(registryConfigs, configuredSlugs) {
 init_instruction_graph();
 init_project_context();
 init_session_render();
-import { basename as basename6 } 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"),
@@ -17663,10 +17786,10 @@ function assertHostedProfileBindings(profileId, configs, bindings) {
   }
 }
 function readManagedManifest(targetHome) {
-  const path = join18(targetHome, SESSION_RENDER_MANIFEST_RELATIVE_PATH);
+  const path = join19(targetHome, SESSION_RENDER_MANIFEST_RELATIVE_PATH);
   let ancestor = dirname11(path);
   while (true) {
-    const stat = lstatSync7(ancestor);
+    const stat = lstatSync8(ancestor);
     if (stat.isSymbolicLink() || !stat.isDirectory())
       throw new Error("SESSION_REFRESH_PATH_INVALID: managed target uses a symlink or non-directory ancestor.");
     const parent = dirname11(ancestor);
@@ -17674,13 +17797,13 @@ function readManagedManifest(targetHome) {
       break;
     ancestor = parent;
   }
-  const fd = openSync4(path, constants2.O_RDONLY | constants2.O_NOFOLLOW);
+  const fd = openSync4(path, constants3.O_RDONLY | constants3.O_NOFOLLOW);
   let raw;
   try {
     const stat = fstatSync4(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 = readFileSync15(fd);
+    raw = readFileSync14(fd);
     if (raw.byteLength > SESSION_MANAGED_INPUT_MAX_BYTES)
       throw new Error("SESSION_REFRESH_MANIFEST_INVALID: manifest grew beyond the read limit.");
   } finally {
@@ -17690,15 +17813,28 @@ function readManagedManifest(targetHome) {
   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.");
   }
+  const recordedProjectRoot = manifest.targetOwner.projectRoot;
+  if (recordedProjectRoot !== null && recordedProjectRoot !== undefined) {
+    if (typeof recordedProjectRoot !== "string" || !isAbsolute9(recordedProjectRoot)) {
+      throw new Error("SESSION_REFRESH_MANIFEST_INVALID: recorded project root must be an absolute path.");
+    }
+    const normalizedProjectRoot = resolve13(recordedProjectRoot);
+    if (normalizedProjectRoot === parse5(normalizedProjectRoot).root || manifest.targetKind === "project-root" && normalizedProjectRoot !== targetHome || manifest.targetKind === "session-home" && manifest.tool !== "opencode") {
+      throw new Error("SESSION_REFRESH_MANIFEST_INVALID: recorded project root does not match the managed target.");
+    }
+    manifest.targetOwner.projectRoot = normalizedProjectRoot;
+  } else if (manifest.targetKind === "project-root") {
+    throw new Error("SESSION_REFRESH_MANIFEST_INVALID: project-scoped render is missing its recorded project root.");
+  }
   manifest.refreshSelector = normalizeSessionHostedProfileSelector(manifest.refreshSelector);
-  return { manifest, sha256: createHash11("sha256").update(raw).digest("hex") };
+  return { manifest, sha256: createHash10("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 = resolve12(input.targetHome);
-  if (targetHome === parse6(targetHome).root)
+  const targetHome = resolve13(input.targetHome);
+  if (targetHome === parse5(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;
@@ -17732,7 +17868,7 @@ async function refreshSessionRender(input) {
     profile_id: profile.id,
     provider_version: selector.providerVersion,
     targetHome,
-    ...previous.manifest.targetKind === "project-root" ? { projectRoot: targetHome } : {},
+    ...previous.manifest.targetKind === "project-root" ? { projectRoot: targetHome } : previous.manifest.targetOwner.projectRoot ? { projectRoot: previous.manifest.targetOwner.projectRoot } : {},
     sessionId: previous.manifest.sessionId ?? undefined,
     refreshSelector: selector,
     codewithNativeImports: selector.codewithNativeImports,
@@ -17741,7 +17877,7 @@ async function refreshSessionRender(input) {
     bindings,
     asset_configs: assetConfigs,
     asset_bindings: assetBindings,
-    asset_plan_mode: input.dryRun ? "dry-run" : "apply",
+    asset_plan_mode: "apply",
     asset_scope: selector.assetScope,
     asset_surface: selector.assetSurface,
     extra_sources: station ? [station] : undefined,
@@ -18117,8 +18253,8 @@ init_codewith_shared_todos_storage_standard();
 
 // src/lib/sync.ts
 init_config_store();
-import { existsSync as existsSync17, readdirSync as readdirSync5, readFileSync as readFileSync17 } from "fs";
-import { basename as basename7, extname as extname3, join as join20 } from "path";
+import { existsSync as existsSync16, readdirSync as readdirSync5, readFileSync as readFileSync16 } from "fs";
+import { basename as basename7, extname as extname3, join as join21 } from "path";
 init_config_agents();
 init_redact();
 init_machine();
@@ -18126,8 +18262,8 @@ init_transforms();
 
 // src/lib/sync-dir.ts
 init_config_store();
-import { existsSync as existsSync16, readdirSync as readdirSync4, readFileSync as readFileSync16, statSync as statSync6 } from "fs";
-import { join as join19, relative as relative7 } from "path";
+import { existsSync as existsSync15, readdirSync as readdirSync4, readFileSync as readFileSync15, statSync as statSync7 } from "fs";
+import { join as join20, relative as relative6 } from "path";
 init_redact();
 var SKIP = [".db", ".db-shm", ".db-wal", ".log", ".lock", ".DS_Store", "node_modules", ".git"];
 function shouldSkip(p) {
@@ -18136,9 +18272,9 @@ function shouldSkip(p) {
 async function syncFromDir(dir, opts = {}) {
   const store = opts.store ?? resolveConfigStore();
   const absDir = expandPath(dir);
-  if (!existsSync16(absDir))
+  if (!existsSync15(absDir))
     return { added: 0, updated: 0, unchanged: 0, skipped: [`Not found: ${absDir}`] };
-  const files = opts.recursive !== false ? walkDir(absDir) : readdirSync4(absDir).map((f) => join19(absDir, f)).filter((f) => statSync6(f).isFile());
+  const files = opts.recursive !== false ? walkDir(absDir) : readdirSync4(absDir).map((f) => join20(absDir, f)).filter((f) => statSync7(f).isFile());
   const result = { added: 0, updated: 0, unchanged: 0, skipped: [] };
   const allConfigs = await store.listConfigs();
   for (const file of files) {
@@ -18147,7 +18283,7 @@ async function syncFromDir(dir, opts = {}) {
       continue;
     }
     try {
-      const content = readFileSync16(file, "utf-8");
+      const content = readFileSync15(file, "utf-8");
       if (content.length > 500000) {
         result.skipped.push(file + " (too large)");
         continue;
@@ -18157,7 +18293,7 @@ async function syncFromDir(dir, opts = {}) {
       const existing = allConfigs.find((c) => c.target_path === targetPath);
       if (!existing) {
         if (!opts.dryRun)
-          await store.createConfig({ name: relative7(absDir, file), category: detectCategory(file), agent: detectAgent(file), target_path: targetPath, format: detectFormat(file), content: redacted.content });
+          await store.createConfig({ name: relative6(absDir, file), category: detectCategory(file), agent: detectAgent(file), target_path: targetPath, format: detectFormat(file), content: redacted.content });
         result.added++;
       } else if (existing.content !== redacted.content) {
         if (!opts.dryRun)
@@ -18197,7 +18333,7 @@ async function syncToDir(dir, opts = {}) {
 }
 function walkDir(dir, files = []) {
   for (const entry of readdirSync4(dir, { withFileTypes: true })) {
-    const full = join19(dir, entry.name);
+    const full = join20(dir, entry.name);
     if (shouldSkip(full))
       continue;
     if (entry.isDirectory())
@@ -18258,7 +18394,7 @@ function isGeneratedOutputTarget2(config, owners) {
   return !!ownerIds && !ownerIds.has(config.id);
 }
 function hasClaudePromptSource() {
-  return existsSync17(expandPath("~/.claude/CLAUDE.md"));
+  return existsSync16(expandPath("~/.claude/CLAUDE.md"));
 }
 function hasClaudeRuleSourceForCursorTarget(targetPath) {
   const absoluteTargetPath = expandPath(targetPath);
@@ -18266,7 +18402,7 @@ function hasClaudeRuleSourceForCursorTarget(targetPath) {
   if (!absoluteTargetPath.startsWith(`${absolutePrefix}/`) || !absoluteTargetPath.endsWith(".mdc"))
     return false;
   const stem = basename7(absoluteTargetPath, ".mdc");
-  return existsSync17(expandPath(`~/.claude/rules/${stem}.md`)) || existsSync17(expandPath(`~/.claude/rules/${stem}.mdc`));
+  return existsSync16(expandPath(`~/.claude/rules/${stem}.md`)) || existsSync16(expandPath(`~/.claude/rules/${stem}.mdc`));
 }
 function isKnownGeneratedTargetPath(targetPath) {
   const normalizedTargetPath = normalizeTargetPath(targetPath);
@@ -18331,11 +18467,11 @@ async function syncProject(opts) {
   const allConfigs = await store.listConfigs();
   const machine = detectMachineContext();
   for (const pf of PROJECT_CONFIG_FILES) {
-    const abs = join20(absDir, pf.file);
-    if (!existsSync17(abs))
+    const abs = join21(absDir, pf.file);
+    if (!existsSync16(abs))
       continue;
     try {
-      const rawContent = readFileSync17(abs, "utf-8");
+      const rawContent = readFileSync16(abs, "utf-8");
       if (rawContent.length > 500000) {
         result.skipped.push(pf.file);
         continue;
@@ -18364,20 +18500,20 @@ async function syncProject(opts) {
     }
   }
   for (const ruleDir of [
-    { dir: join20(absDir, ".claude", "rules"), agent: "claude", namePrefix: "rules" },
-    { dir: join20(absDir, ".agents", "rules"), agent: "antigravity", namePrefix: "antigravity-rules" },
-    { dir: join20(absDir, ".cursor", "rules"), agent: "cursor", namePrefix: "cursor-rules" },
-    { dir: join20(absDir, ".github", "instructions"), agent: "copilot", namePrefix: "copilot-instructions" },
-    { dir: join20(absDir, ".devin", "rules"), agent: "devin", namePrefix: "devin-rules" },
-    { dir: join20(absDir, ".windsurf", "rules"), agent: "windsurf-legacy", namePrefix: "windsurf-rules" },
-    { dir: join20(absDir, ".clinerules"), agent: "cline", namePrefix: "cline-rules" }
+    { dir: join21(absDir, ".claude", "rules"), agent: "claude", namePrefix: "rules" },
+    { dir: join21(absDir, ".agents", "rules"), agent: "antigravity", namePrefix: "antigravity-rules" },
+    { dir: join21(absDir, ".cursor", "rules"), agent: "cursor", namePrefix: "cursor-rules" },
+    { dir: join21(absDir, ".github", "instructions"), agent: "copilot", namePrefix: "copilot-instructions" },
+    { dir: join21(absDir, ".devin", "rules"), agent: "devin", namePrefix: "devin-rules" },
+    { dir: join21(absDir, ".windsurf", "rules"), agent: "windsurf-legacy", namePrefix: "windsurf-rules" },
+    { dir: join21(absDir, ".clinerules"), agent: "cline", namePrefix: "cline-rules" }
   ]) {
-    if (!existsSync17(ruleDir.dir))
+    if (!existsSync16(ruleDir.dir))
       continue;
     const mdFiles = readdirSync5(ruleDir.dir).filter((f) => f.endsWith(".md") || f.endsWith(".mdc"));
     for (const f of mdFiles) {
-      const abs = join20(ruleDir.dir, f);
-      const raw = readFileSync17(abs, "utf-8");
+      const abs = join21(ruleDir.dir, f);
+      const raw = readFileSync16(abs, "utf-8");
       const redacted = redactContent(raw, "markdown");
       const machineAware = templateizeMachineContent(redacted.content, machine);
       const content = machineAware.content;
@@ -18416,20 +18552,20 @@ async function syncKnown(opts = {}) {
   for (const known of targets) {
     if (known.rulesDir) {
       const absDir = expandPath(known.rulesDir);
-      if (!existsSync17(absDir)) {
+      if (!existsSync16(absDir)) {
         result.skipped.push(known.rulesDir);
         continue;
       }
       const extensions = known.rulesExtensions ?? [".md", ".mdc"];
       const ruleFiles = readdirSync5(absDir).filter((f) => extensions.some((ext) => f.endsWith(ext)));
       for (const f of ruleFiles) {
-        const abs2 = join20(absDir, f);
+        const abs2 = join21(absDir, f);
         const targetPath = abs2.replace(home, "~");
         if (existingOutputOwners.has(normalizeTargetPath(targetPath)) || isKnownGeneratedTargetPath(targetPath)) {
           result.skipped.push(`${targetPath} (generated output)`);
           continue;
         }
-        const raw = readFileSync17(abs2, "utf-8");
+        const raw = readFileSync16(abs2, "utf-8");
         const redacted = redactContent(raw, "markdown");
         const machineAware = templateizeMachineContent(redacted.content, machine);
         const content = machineAware.content;
@@ -18457,12 +18593,12 @@ async function syncKnown(opts = {}) {
       continue;
     }
     const abs = expandPath(known.path);
-    if (!existsSync17(abs)) {
+    if (!existsSync16(abs)) {
       result.skipped.push(known.path);
       continue;
     }
     try {
-      const rawContent = normalizeKnownConfigSource(known, readFileSync17(abs, "utf-8"));
+      const rawContent = normalizeKnownConfigSource(known, readFileSync16(abs, "utf-8"));
       if (rawContent.length > 500000) {
         result.skipped.push(known.path + " (too large)");
         continue;
@@ -18565,9 +18701,9 @@ function storedPlaceholderIsLiteralOnDisk(storedLine, diskLine) {
 }
 function buildDiff(expectedContent, targetPath, storedFormat, showSecrets) {
   const path = expandPath(targetPath);
-  if (!existsSync17(path))
+  if (!existsSync16(path))
     return `(file not found on disk: ${path})`;
-  const diskContent = readFileSync17(path, "utf-8");
+  const diskContent = readFileSync16(path, "utf-8");
   if (diskContent === expectedContent)
     return "(no diff \u2014 identical)";
   const format = redactFormatForTarget(targetPath, storedFormat);
@@ -18727,9 +18863,9 @@ function detectFormat(filePath) {
 // src/lib/export.ts
 init_types();
 init_config_store();
-import { createHash as createHash12 } from "crypto";
-import { existsSync as existsSync18, mkdirSync as mkdirSync8, mkdtempSync, rmSync as rmSync4, writeFileSync as writeFileSync6 } from "fs";
-import { dirname as dirname12, join as join21, resolve as resolve13 } from "path";
+import { createHash as createHash11 } from "crypto";
+import { existsSync as existsSync17, mkdirSync as mkdirSync7, mkdtempSync, rmSync as rmSync3, writeFileSync as writeFileSync5 } from "fs";
+import { dirname as dirname12, join as join22, resolve as resolve14 } from "path";
 import { tmpdir } from "os";
 var ARCHIVE_EXCLUSIONS = [
   {
@@ -18751,8 +18887,8 @@ var ARCHIVE_EXCLUSIONS = [
 function compareText(left, right) {
   return left < right ? -1 : left > right ? 1 : 0;
 }
-function sha25611(value) {
-  return createHash12("sha256").update(value).digest("hex");
+function sha25610(value) {
+  return createHash11("sha256").update(value).digest("hex");
 }
 function canonicalize(value) {
   if (Array.isArray(value))
@@ -18876,19 +19012,19 @@ function computeIntegrity(domain, options) {
     machines: collections.machines.length
   };
   const hashes = {
-    configs: sha25611(canonicalDomainJson(collections.configs)),
-    config_snapshots: sha25611(canonicalDomainJson(collections.config_snapshots)),
-    profiles: sha25611(canonicalDomainJson(collections.profiles)),
-    profile_config_bindings: sha25611(canonicalDomainJson(collections.profile_config_bindings)),
-    profile_asset_bindings: sha25611(canonicalDomainJson(collections.profile_asset_bindings)),
-    machines: sha25611(canonicalDomainJson(collections.machines))
+    configs: sha25610(canonicalDomainJson(collections.configs)),
+    config_snapshots: sha25610(canonicalDomainJson(collections.config_snapshots)),
+    profiles: sha25610(canonicalDomainJson(collections.profiles)),
+    profile_config_bindings: sha25610(canonicalDomainJson(collections.profile_config_bindings)),
+    profile_asset_bindings: sha25610(canonicalDomainJson(collections.profile_asset_bindings)),
+    machines: sha25610(canonicalDomainJson(collections.machines))
   };
   return {
     algorithm: "sha256",
     canonicalization: options.canonicalization,
     counts,
     hashes,
-    domain_sha256: sha25611(canonicalDomainJson({ counts, hashes }))
+    domain_sha256: sha25610(canonicalDomainJson({ counts, hashes }))
   };
 }
 function computeDomainIntegrity(domain) {
@@ -19059,19 +19195,19 @@ async function exportConfigs(outputPath, opts = {}) {
     exported_at: new Date().toISOString(),
     payload: {
       path: "domain.json",
-      sha256: sha25611(payload),
+      sha256: sha25610(payload),
       size_bytes: Buffer.byteLength(payload)
     },
     integrity,
     exclusions: ARCHIVE_EXCLUSIONS
   };
-  const absOutput = resolve13(outputPath);
-  mkdirSync8(dirname12(absOutput), { recursive: true });
-  const stagingDir = mkdtempSync(join21(tmpdir(), "instructions-domain-export-"));
+  const absOutput = resolve14(outputPath);
+  mkdirSync7(dirname12(absOutput), { recursive: true });
+  const stagingDir = mkdtempSync(join22(tmpdir(), "instructions-domain-export-"));
   try {
-    writeFileSync6(join21(stagingDir, "manifest.json"), `${JSON.stringify(manifest, null, 2)}
+    writeFileSync5(join22(stagingDir, "manifest.json"), `${JSON.stringify(manifest, null, 2)}
 `, "utf-8");
-    writeFileSync6(join21(stagingDir, "domain.json"), payload, "utf-8");
+    writeFileSync5(join22(stagingDir, "domain.json"), payload, "utf-8");
     const proc = Bun.spawn(["tar", "czf", absOutput, "-C", stagingDir, "manifest.json", "domain.json"], {
       stdout: "pipe",
       stderr: "pipe"
@@ -19083,15 +19219,15 @@ async function exportConfigs(outputPath, opts = {}) {
     }
     return { path: absOutput, count: domain.configs.length, counts: integrity.counts, integrity };
   } finally {
-    if (existsSync18(stagingDir))
-      rmSync4(stagingDir, { recursive: true, force: true });
+    if (existsSync17(stagingDir))
+      rmSync3(stagingDir, { recursive: true, force: true });
   }
 }
 // src/lib/import.ts
 init_types();
 init_config_store();
-import { createHash as createHash13 } from "crypto";
-import { resolve as resolve14 } from "path";
+import { createHash as createHash12 } from "crypto";
+import { resolve as resolve15 } from "path";
 function compareText2(left, right) {
   return left < right ? -1 : left > right ? 1 : 0;
 }
@@ -19115,8 +19251,8 @@ function emptyResult() {
     integrity: null
   };
 }
-function sha25612(value) {
-  return createHash13("sha256").update(value).digest("hex");
+function sha25611(value) {
+  return createHash12("sha256").update(value).digest("hex");
 }
 function normalizeMemberName(name) {
   let normalized = name;
@@ -19186,7 +19322,7 @@ async function readV2(reader, manifest) {
     throw new Error("Invalid v2 archive manifest");
   }
   const payload = await reader.read("domain.json");
-  if (Buffer.byteLength(payload) !== manifest.payload.size_bytes || sha25612(payload) !== manifest.payload.sha256) {
+  if (Buffer.byteLength(payload) !== manifest.payload.size_bytes || sha25611(payload) !== manifest.payload.sha256) {
     throw new Error("Archive integrity failure: domain payload hash or size does not match the manifest");
   }
   const domain = validateInstructionsDomainArchive(JSON.parse(payload));
@@ -19379,7 +19515,7 @@ async function importV1(reader, manifest, store, conflict) {
 async function importConfigs(bundlePath, opts = {}) {
   const store = opts.store ?? resolveConfigStore();
   const conflict = opts.conflict ?? "skip";
-  const reader = await openArchive(resolve14(bundlePath));
+  const reader = await openArchive(resolve15(bundlePath));
   const manifestText = await reader.read("manifest.json");
   let manifest;
   try {
@@ -19407,9 +19543,9 @@ init_redact();
 
 // src/lib/package-manager-guard.ts
 import { execFileSync as execFileSync2 } from "child_process";
-import { existsSync as existsSync19, lstatSync as lstatSync8, readdirSync as readdirSync6, readFileSync as readFileSync18 } from "fs";
-import { homedir as homedir10 } from "os";
-import { basename as basename8, dirname as dirname13, isAbsolute as isAbsolute8, join as join22, relative as relative8, resolve as resolve15 } from "path";
+import { existsSync as existsSync18, lstatSync as lstatSync9, readdirSync as readdirSync6, readFileSync as readFileSync17 } from "fs";
+import { homedir as homedir11 } from "os";
+import { basename as basename8, dirname as dirname13, isAbsolute as isAbsolute10, join as join23, relative as relative7, resolve as resolve16 } from "path";
 var SKIP_DIRS = new Set([
   ".git",
   "node_modules",
@@ -19446,14 +19582,14 @@ var TOKEN_VALUE_PATTERNS = [
   { re: /xoxb-[0-9]+-[A-Za-z0-9-]+/, rule: "literal-slack-token", detail: "literal Slack token-like value" }
 ];
 function scanPackageManagerSecrets(options = {}) {
-  const cwd = options.cwd ? resolve15(options.cwd) : process.cwd();
-  const roots = (options.roots && options.roots.length > 0 ? options.roots : [cwd]).map((root) => resolve15(cwd, root));
+  const cwd = options.cwd ? resolve16(options.cwd) : process.cwd();
+  const roots = (options.roots && options.roots.length > 0 ? options.roots : [cwd]).map((root) => resolve16(cwd, root));
   const findings = [];
   let scannedFiles = 0;
   for (const root of roots) {
-    if (!existsSync19(root))
+    if (!existsSync18(root))
       continue;
-    const stat = lstatSync8(root);
+    const stat = lstatSync9(root);
     if (stat.isFile()) {
       if (!shouldScanRepoFile(root))
         continue;
@@ -19468,7 +19604,7 @@ function scanPackageManagerSecrets(options = {}) {
       continue;
     const tracked = trackedFiles(root);
     for (const file of collectRepoFiles(root)) {
-      const rel = toPosix(relative8(root, file));
+      const rel = toPosix(relative7(root, file));
       const isTracked = tracked.has(rel);
       const text = readTextFile(file);
       if (text === null)
@@ -19478,10 +19614,10 @@ function scanPackageManagerSecrets(options = {}) {
     }
   }
   if (options.includeHome) {
-    const home = homedir10();
+    const home = homedir11();
     for (const name of HOME_FILES) {
-      const file = join22(home, name);
-      if (!existsSync19(file))
+      const file = join23(home, name);
+      if (!existsSync18(file))
         continue;
       const text = readTextFile(file);
       if (text === null)
@@ -19505,12 +19641,12 @@ function collectRepoFiles(root) {
       if (entry.isDirectory()) {
         if (SKIP_DIRS.has(entry.name))
           continue;
-        visit(join22(dir, entry.name));
+        visit(join23(dir, entry.name));
         continue;
       }
       if (!entry.isFile())
         continue;
-      const file = join22(dir, entry.name);
+      const file = join23(dir, entry.name);
       if (shouldScanRepoFile(file))
         out.push(file);
     }
@@ -19545,10 +19681,10 @@ function isNpmrcName(name) {
 }
 function readTextFile(file) {
   try {
-    const stat = lstatSync8(file);
+    const stat = lstatSync9(file);
     if (!stat.isFile() || stat.size > 5000000)
       return null;
-    const buf = readFileSync18(file);
+    const buf = readFileSync17(file);
     if (buf.includes(0))
       return null;
     return buf.toString("utf-8");
@@ -19752,7 +19888,7 @@ function isTrackedFile(file) {
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "ignore"]
     }).trim();
-    const rel = toPosix(relative8(repoRoot, file));
+    const rel = toPosix(relative7(repoRoot, file));
     execFileSync2("git", ["-C", repoRoot, "ls-files", "--error-unmatch", "--", rel], {
       stdio: ["ignore", "ignore", "ignore"]
     });
@@ -19778,13 +19914,13 @@ function stripInlineComment(value) {
   return value.replace(/\s[#;].*$/, "").trim();
 }
 function displayPath(file, root) {
-  const home = homedir10();
+  const home = homedir11();
   if (root === home && (file === home || file.startsWith(home + "/")))
-    return "~/" + toPosix(relative8(home, file));
-  if (isAbsolute8(root) && file.startsWith(root + "/"))
-    return toPosix(relative8(root, file));
+    return "~/" + toPosix(relative7(home, file));
+  if (isAbsolute10(root) && file.startsWith(root + "/"))
+    return toPosix(relative7(root, file));
   if (file === home || file.startsWith(home + "/"))
-    return "~/" + toPosix(relative8(home, file));
+    return "~/" + toPosix(relative7(home, file));
   return file;
 }
 function toPosix(path) {
@@ -19824,6 +19960,7 @@ export {
   renderTemplatePreview,
   renderTemplate,
   renderProviderFragment,
+  renderNativeAgentContent,
   renderMachineAwareContentPreview,
   renderMachineAwareContent,
   refreshStationProfile,
@@ -19872,6 +20009,7 @@ export {
   ensureGlobalAgentRulesStandardConfig,
   ensureDangerousOperationGuardStandardConfig,
   ensureCodewithSharedTodosStorageStandardConfig,
+  discoverHarnesses,
   diffConfig,
   detectMachineContext,
   detectFormat,
@@ -19957,8 +20095,10 @@ export {
   INSTRUCTIONS_LOCAL_OPT_IN_ENV,
   INSTRUCTIONS_DOMAIN_ARCHIVE_SCHEMA,
   INBOX_CONVERSATIONS_MINIMUM_VERSION,
+  HARNESS_DISCOVERY_SCHEMA,
   GLOBAL_AGENT_RULES_STANDARD_SLUG,
   GLOBAL_AGENT_RULES_STANDARD_CONTENT,
+  DISCOVERABLE_HARNESSES,
   DANGEROUS_OPERATION_GUARD_STANDARD_SLUG,
   DANGEROUS_OPERATION_GUARD_STANDARD_CONTENT,
   ConfigVersionConflictError,