@hasna/instructions 0.4.39 → 0.4.43

package/dist/mcp/index.js

@@ -99,17 +99,17 @@ var init_retired_storage_mode = __esm(() => {
 
 // src/lib/raw-store-root.ts
 import { homedir } from "os";
-import { join, resolve } from "path";
+import { join as join2, resolve } from "path";
 function getRawStoreRoot() {
-  return resolve(process.env[RAW_STORE_ROOT_ENV] || join(process.env["HOME"] || homedir(), ".hasna", "instructions"));
+  return resolve(process.env[RAW_STORE_ROOT_ENV] || join2(process.env["HOME"] || homedir(), ".hasna", "instructions"));
 }
 var RAW_STORE_ROOT_ENV = "HASNA_CONFIGS_HOME";
 var init_raw_store_root = () => {};
 
 // src/db/database.ts
 import { Database } from "bun:sqlite";
-import { existsSync, mkdirSync, rmSync } from "fs";
-import { join as join2 } from "path";
+import { existsSync as existsSync2, mkdirSync, rmSync } from "fs";
+import { join as join3 } from "path";
 import { randomUUID } from "crypto";
 function getDbPath() {
   if (process.env["HASNA_INSTRUCTIONS_DB_PATH"]) {
@@ -117,7 +117,7 @@ function getDbPath() {
   }
   const dir = getRawStoreRoot();
   mkdirSync(dir, { recursive: true });
-  return join2(dir, "instructions.db");
+  return join3(dir, "instructions.db");
 }
 function uuid() {
   return randomUUID();
@@ -158,7 +158,7 @@ function resetLocalDatabase() {
   if (dbPath === ":memory:")
     return;
   for (const p of [dbPath, `${dbPath}-wal`, `${dbPath}-shm`]) {
-    if (existsSync(p))
+    if (existsSync2(p))
       rmSync(p);
   }
 }
@@ -527,11 +527,11 @@ var init_configs = __esm(() => {
 // src/lib/template.ts
 var exports_template = {};
 __export(exports_template, {
-  extractTemplateVars: () => extractTemplateVars,
-  isTemplate: () => isTemplate,
-  parseTemplateVars: () => parseTemplateVars,
+  renderTemplatePreview: () => renderTemplatePreview,
   renderTemplate: () => renderTemplate,
-  renderTemplatePreview: () => renderTemplatePreview
+  parseTemplateVars: () => parseTemplateVars,
+  isTemplate: () => isTemplate,
+  extractTemplateVars: () => extractTemplateVars
 });
 function parseTemplateVars(content) {
   const names = new Set;
@@ -596,8 +596,8 @@ var init_template = __esm(() => {
 
 // src/lib/machine.ts
 import { arch as currentArch, homedir as homedir2, hostname as currentHostname, type as currentOsType } from "os";
-import { existsSync as existsSync2 } from "fs";
-import { join as join3 } from "path";
+import { existsSync as existsSync3 } from "fs";
+import { join as join4 } from "path";
 function normalizeOsFamily(os) {
   const value = (os ?? "").trim().toLowerCase();
   if (value === "darwin" || value === "macos" || value === "mac" || value === "osx")
@@ -612,8 +612,8 @@ function detectMachineContext(overrides = {}) {
   const homeDir = overrides.home_dir ?? process.env["CONFIGS_HOME"] ?? process.env["HOME"] ?? homedir2();
   const os = overrides.os ?? currentOsType();
   const osFamily = normalizeOsFamily(os);
-  const bunBinDir = overrides.bun_bin_dir ?? join3(homeDir, ".bun", "bin");
-  const defaultBunPath = osFamily === "macos" && existsSync2(BREW_BUN_PATH) ? BREW_BUN_PATH : join3(bunBinDir, "bun");
+  const bunBinDir = overrides.bun_bin_dir ?? join4(homeDir, ".bun", "bin");
+  const defaultBunPath = osFamily === "macos" && existsSync3(BREW_BUN_PATH) ? BREW_BUN_PATH : join4(bunBinDir, "bun");
   return {
     id: "current-machine",
     hostname: overrides.hostname ?? currentHostname(),
@@ -623,10 +623,10 @@ function detectMachineContext(overrides = {}) {
     created_at: "",
     os_family: osFamily,
     home_dir: homeDir,
-    workspace_root: overrides.workspace_root ?? join3(homeDir, osFamily === "macos" ? "Workspace" : "workspace"),
+    workspace_root: overrides.workspace_root ?? join4(homeDir, osFamily === "macos" ? "Workspace" : "workspace"),
     bun_bin_dir: bunBinDir,
     bun_path: overrides.bun_path ?? defaultBunPath,
-    path_prefix: overrides.path_prefix ?? (osFamily === "macos" ? `${join3("/opt", "homebrew", "bin")}:${bunBinDir}` : bunBinDir)
+    path_prefix: overrides.path_prefix ?? (osFamily === "macos" ? `${join4("/opt", "homebrew", "bin")}:${bunBinDir}` : bunBinDir)
   };
 }
 function machineContextToVariables(machine) {
@@ -4777,113 +4777,113 @@ var init_types2 = __esm(() => {
 // ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v3/external.js
 var exports_external = {};
 __export(exports_external, {
-  BRAND: () => BRAND,
-  DIRTY: () => DIRTY,
-  EMPTY_PATH: () => EMPTY_PATH,
-  INVALID: () => INVALID,
-  NEVER: () => NEVER,
-  OK: () => OK,
-  ParseStatus: () => ParseStatus,
-  Schema: () => ZodType,
-  ZodAny: () => ZodAny,
-  ZodArray: () => ZodArray,
-  ZodBigInt: () => ZodBigInt,
-  ZodBoolean: () => ZodBoolean,
-  ZodBranded: () => ZodBranded,
-  ZodCatch: () => ZodCatch,
-  ZodDate: () => ZodDate,
-  ZodDefault: () => ZodDefault,
-  ZodDiscriminatedUnion: () => ZodDiscriminatedUnion,
-  ZodEffects: () => ZodEffects,
-  ZodEnum: () => ZodEnum,
-  ZodError: () => ZodError,
-  ZodFirstPartyTypeKind: () => ZodFirstPartyTypeKind,
-  ZodFunction: () => ZodFunction,
-  ZodIntersection: () => ZodIntersection,
-  ZodIssueCode: () => ZodIssueCode,
-  ZodLazy: () => ZodLazy,
-  ZodLiteral: () => ZodLiteral,
-  ZodMap: () => ZodMap,
-  ZodNaN: () => ZodNaN,
-  ZodNativeEnum: () => ZodNativeEnum,
-  ZodNever: () => ZodNever,
-  ZodNull: () => ZodNull,
-  ZodNullable: () => ZodNullable,
-  ZodNumber: () => ZodNumber,
-  ZodObject: () => ZodObject,
-  ZodOptional: () => ZodOptional,
-  ZodParsedType: () => ZodParsedType,
-  ZodPipeline: () => ZodPipeline,
-  ZodPromise: () => ZodPromise,
-  ZodReadonly: () => ZodReadonly,
-  ZodRecord: () => ZodRecord,
-  ZodSchema: () => ZodType,
-  ZodSet: () => ZodSet,
-  ZodString: () => ZodString,
-  ZodSymbol: () => ZodSymbol,
-  ZodTransformer: () => ZodEffects,
-  ZodTuple: () => ZodTuple,
-  ZodType: () => ZodType,
-  ZodUndefined: () => ZodUndefined,
-  ZodUnion: () => ZodUnion,
-  ZodUnknown: () => ZodUnknown,
-  ZodVoid: () => ZodVoid,
-  addIssueToContext: () => addIssueToContext,
-  any: () => anyType,
-  array: () => arrayType,
-  bigint: () => bigIntType,
-  boolean: () => booleanType,
-  coerce: () => coerce,
-  custom: () => custom,
-  date: () => dateType,
-  datetimeRegex: () => datetimeRegex,
-  defaultErrorMap: () => en_default,
-  discriminatedUnion: () => discriminatedUnionType,
-  effect: () => effectsType,
-  enum: () => enumType,
-  function: () => functionType,
-  getErrorMap: () => getErrorMap,
-  getParsedType: () => getParsedType,
-  instanceof: () => instanceOfType,
-  intersection: () => intersectionType,
-  isAborted: () => isAborted,
-  isAsync: () => isAsync,
-  isDirty: () => isDirty,
-  isValid: () => isValid,
-  late: () => late,
-  lazy: () => lazyType,
-  literal: () => literalType,
-  makeIssue: () => makeIssue,
-  map: () => mapType,
-  nan: () => nanType,
-  nativeEnum: () => nativeEnumType,
-  never: () => neverType,
-  null: () => nullType,
-  nullable: () => nullableType,
-  number: () => numberType,
-  object: () => objectType,
-  objectUtil: () => objectUtil,
-  oboolean: () => oboolean,
-  onumber: () => onumber,
-  optional: () => optionalType,
-  ostring: () => ostring,
-  pipeline: () => pipelineType,
-  preprocess: () => preprocessType,
-  promise: () => promiseType,
-  quotelessJson: () => quotelessJson,
-  record: () => recordType,
-  set: () => setType,
-  setErrorMap: () => setErrorMap,
-  strictObject: () => strictObjectType,
-  string: () => stringType,
-  symbol: () => symbolType,
-  transformer: () => effectsType,
-  tuple: () => tupleType,
-  undefined: () => undefinedType,
-  union: () => unionType,
-  unknown: () => unknownType,
+  void: () => voidType,
   util: () => util,
-  void: () => voidType
+  unknown: () => unknownType,
+  union: () => unionType,
+  undefined: () => undefinedType,
+  tuple: () => tupleType,
+  transformer: () => effectsType,
+  symbol: () => symbolType,
+  string: () => stringType,
+  strictObject: () => strictObjectType,
+  setErrorMap: () => setErrorMap,
+  set: () => setType,
+  record: () => recordType,
+  quotelessJson: () => quotelessJson,
+  promise: () => promiseType,
+  preprocess: () => preprocessType,
+  pipeline: () => pipelineType,
+  ostring: () => ostring,
+  optional: () => optionalType,
+  onumber: () => onumber,
+  oboolean: () => oboolean,
+  objectUtil: () => objectUtil,
+  object: () => objectType,
+  number: () => numberType,
+  nullable: () => nullableType,
+  null: () => nullType,
+  never: () => neverType,
+  nativeEnum: () => nativeEnumType,
+  nan: () => nanType,
+  map: () => mapType,
+  makeIssue: () => makeIssue,
+  literal: () => literalType,
+  lazy: () => lazyType,
+  late: () => late,
+  isValid: () => isValid,
+  isDirty: () => isDirty,
+  isAsync: () => isAsync,
+  isAborted: () => isAborted,
+  intersection: () => intersectionType,
+  instanceof: () => instanceOfType,
+  getParsedType: () => getParsedType,
+  getErrorMap: () => getErrorMap,
+  function: () => functionType,
+  enum: () => enumType,
+  effect: () => effectsType,
+  discriminatedUnion: () => discriminatedUnionType,
+  defaultErrorMap: () => en_default,
+  datetimeRegex: () => datetimeRegex,
+  date: () => dateType,
+  custom: () => custom,
+  coerce: () => coerce,
+  boolean: () => booleanType,
+  bigint: () => bigIntType,
+  array: () => arrayType,
+  any: () => anyType,
+  addIssueToContext: () => addIssueToContext,
+  ZodVoid: () => ZodVoid,
+  ZodUnknown: () => ZodUnknown,
+  ZodUnion: () => ZodUnion,
+  ZodUndefined: () => ZodUndefined,
+  ZodType: () => ZodType,
+  ZodTuple: () => ZodTuple,
+  ZodTransformer: () => ZodEffects,
+  ZodSymbol: () => ZodSymbol,
+  ZodString: () => ZodString,
+  ZodSet: () => ZodSet,
+  ZodSchema: () => ZodType,
+  ZodRecord: () => ZodRecord,
+  ZodReadonly: () => ZodReadonly,
+  ZodPromise: () => ZodPromise,
+  ZodPipeline: () => ZodPipeline,
+  ZodParsedType: () => ZodParsedType,
+  ZodOptional: () => ZodOptional,
+  ZodObject: () => ZodObject,
+  ZodNumber: () => ZodNumber,
+  ZodNullable: () => ZodNullable,
+  ZodNull: () => ZodNull,
+  ZodNever: () => ZodNever,
+  ZodNativeEnum: () => ZodNativeEnum,
+  ZodNaN: () => ZodNaN,
+  ZodMap: () => ZodMap,
+  ZodLiteral: () => ZodLiteral,
+  ZodLazy: () => ZodLazy,
+  ZodIssueCode: () => ZodIssueCode,
+  ZodIntersection: () => ZodIntersection,
+  ZodFunction: () => ZodFunction,
+  ZodFirstPartyTypeKind: () => ZodFirstPartyTypeKind,
+  ZodError: () => ZodError,
+  ZodEnum: () => ZodEnum,
+  ZodEffects: () => ZodEffects,
+  ZodDiscriminatedUnion: () => ZodDiscriminatedUnion,
+  ZodDefault: () => ZodDefault,
+  ZodDate: () => ZodDate,
+  ZodCatch: () => ZodCatch,
+  ZodBranded: () => ZodBranded,
+  ZodBoolean: () => ZodBoolean,
+  ZodBigInt: () => ZodBigInt,
+  ZodArray: () => ZodArray,
+  ZodAny: () => ZodAny,
+  Schema: () => ZodType,
+  ParseStatus: () => ParseStatus,
+  OK: () => OK,
+  NEVER: () => NEVER,
+  INVALID: () => INVALID,
+  EMPTY_PATH: () => EMPTY_PATH,
+  DIRTY: () => DIRTY,
+  BRAND: () => BRAND
 });
 var init_external = __esm(() => {
   init_errors();
@@ -4903,11 +4903,11 @@ var init_zod = __esm(() => {
 // src/lib/redact.ts
 var exports_redact = {};
 __export(exports_redact, {
-  hasSecrets: () => hasSecrets,
-  isSecretVarName: () => isSecretVarName,
-  redactContent: () => redactContent,
+  scanSecrets: () => scanSecrets,
   redactFormatForTarget: () => redactFormatForTarget,
-  scanSecrets: () => scanSecrets
+  redactContent: () => redactContent,
+  isSecretVarName: () => isSecretVarName,
+  hasSecrets: () => hasSecrets
 });
 function redactShell(content) {
   const redacted = [];
@@ -5115,7 +5115,7 @@ var init_session_render_contract = __esm(() => {
 });
 
 // src/lib/project-context.ts
-import { basename, dirname, isAbsolute, join as join4, parse, relative, resolve as resolve2 } from "path";
+import { basename, dirname as dirname2, isAbsolute, join as join5, parse, relative, resolve as resolve2 } from "path";
 function revisionKey(value) {
   const sequence = value.match(/^(?:rev-)?([0-9]+)$/);
   if (sequence)
@@ -5678,7 +5678,7 @@ var init_asset_plan = __esm(() => {
 // src/lib/cursor-authority.ts
 import { createHash } from "crypto";
 import { homedir as homedir3 } from "os";
-import { join as join5, resolve as resolve3 } from "path";
+import { join as join6, resolve as resolve3 } from "path";
 function sha256(content) {
   return createHash("sha256").update(content).digest("hex");
 }
@@ -5686,7 +5686,7 @@ function homeDir() {
   return process.env["HOME"] || homedir3();
 }
 function isCursorGlobalAuthorityPath(path) {
-  return resolve3(path) === resolve3(join5(homeDir(), CURSOR_GLOBAL_AUTHORITY_RELATIVE_PATH));
+  return resolve3(path) === resolve3(join6(homeDir(), CURSOR_GLOBAL_AUTHORITY_RELATIVE_PATH));
 }
 function stampCursorGlobalAuthorityMarker(content) {
   if (CURSOR_GLOBAL_AUTHORITY_MARKER_PATTERN.test(content))
@@ -6030,7 +6030,12 @@ var init_instruction_graph = __esm(() => {
   init_asset_plan();
   COMMON_FALLBACKS = ["fail", "flatten", "promote-always", "omit"];
   DEFAULT_PROVIDER_CAPABILITIES = Object.freeze({
-    claude: capability("claude", ">=1.0.0", "native-import", "CLAUDE.md @ imports", { native_imports: true, asset_surface: "code" }),
+    claude: capability("claude", ">=1.0.0", "native-import", "CLAUDE.md @ imports plus path-gated rules", {
+      activation_modes: ["always", "glob"],
+      native_imports: true,
+      conditional_artifacts: true,
+      asset_surface: "code"
+    }),
     codex: capability("codex", ">=0.1.0", "flattened", "AGENTS.md", { asset_surface: "cli" }),
     cursor: capability("cursor", ">=1.0.0", "cursor-rule", ".cursor/rules/*.mdc", { activation_modes: ["always", "glob"], conditional_artifacts: true, asset_surface: "ide" }),
     opencode: capability("opencode", ">=1.0.0", "managed-fragment", "opencode.json instructions", { provider_variant: "v1-instructions", session_surface: "opencode-config-instructions" }),
@@ -6879,8 +6884,8 @@ var init_config_store = __esm(() => {
 });
 
 // src/lib/session-render-ownership.ts
-import { existsSync as existsSync3, readFileSync, statSync } from "fs";
-import { dirname as dirname2, join as join6, parse as parse2, relative as relative2, sep } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync2, statSync } from "fs";
+import { dirname as dirname3, join as join7, parse as parse2, relative as relative2, sep } from "path";
 function toSegments(absolutePath2) {
   return absolutePath2.replaceAll("\\", "/").split("/").filter(Boolean);
 }
@@ -6899,19 +6904,19 @@ function pathIsSessionRenderManagedDir(absolutePath2) {
 function readManifestRelativePaths(manifestPath) {
   let stats;
   try {
-    if (!existsSync3(manifestPath))
+    if (!existsSync4(manifestPath))
       return null;
     stats = statSync(manifestPath);
   } catch {
     return null;
   }
-  const cached = manifestCache.get(manifestPath);
-  if (cached && cached.mtimeMs === stats.mtimeMs && cached.size === stats.size) {
-    return cached.relativePaths;
+  const cached2 = manifestCache.get(manifestPath);
+  if (cached2 && cached2.mtimeMs === stats.mtimeMs && cached2.size === stats.size) {
+    return cached2.relativePaths;
   }
   let manifest;
   try {
-    manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
+    manifest = JSON.parse(readFileSync2(manifestPath, "utf-8"));
   } catch {
     return null;
   }
@@ -6926,16 +6931,16 @@ function readManifestRelativePaths(manifestPath) {
 }
 function sessionRenderManifestClaimsPath(absolutePath2) {
   const root = parse2(absolutePath2).root;
-  let home = dirname2(absolutePath2);
+  let home = dirname3(absolutePath2);
   for (let depth = 0;depth < MANIFEST_ANCESTOR_LIMIT; depth += 1) {
-    const manifestPath = join6(home, ...SESSION_RENDER_MANIFEST_RELATIVE_PATH.split("/"));
+    const manifestPath = join7(home, ...SESSION_RENDER_MANIFEST_RELATIVE_PATH.split("/"));
     const relativePaths = readManifestRelativePaths(manifestPath);
     if (relativePaths) {
       const claimed = relative2(home, absolutePath2).split(sep).join("/");
       if (relativePaths.has(claimed))
         return true;
     }
-    const parent = dirname2(home);
+    const parent = dirname3(home);
     if (parent === home || home === root)
       break;
     home = parent;
@@ -6955,16 +6960,16 @@ var init_session_render_ownership = __esm(() => {
 // src/lib/apply.ts
 var exports_apply = {};
 __export(exports_apply, {
-  applyConfig: () => applyConfig,
-  applyConfigs: () => applyConfigs,
-  applyConfigsWithReport: () => applyConfigsWithReport,
-  expandPath: () => expandPath,
-  getConfigHome: () => getConfigHome,
+  previewConfigs: () => previewConfigs,
   normalizeTargetPath: () => normalizeTargetPath,
-  previewConfigs: () => previewConfigs
+  getConfigHome: () => getConfigHome,
+  expandPath: () => expandPath,
+  applyConfigsWithReport: () => applyConfigsWithReport,
+  applyConfigs: () => applyConfigs,
+  applyConfig: () => applyConfig
 });
-import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync2, realpathSync, writeFileSync } from "fs";
-import { basename as basename3, dirname as dirname3, join as join7, resolve as resolve4 } from "path";
+import { existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync3, realpathSync, writeFileSync } from "fs";
+import { basename as basename3, dirname as dirname4, join as join8, resolve as resolve4 } from "path";
 import { homedir as homedir4 } from "os";
 function getConfigHome() {
   return process.env["CONFIGS_HOME"] || process.env["HOME"] || homedir4();
@@ -6983,14 +6988,14 @@ function normalizeTargetPath(p) {
     let current = expanded;
     const missingSegments = [];
     while (true) {
-      if (existsSync4(current)) {
+      if (existsSync5(current)) {
         try {
           return resolve4(realpathSync(current), ...missingSegments);
         } catch {
           return expanded;
         }
       }
-      const parent = dirname3(current);
+      const parent = dirname4(current);
       const name = basename3(current);
       if (parent === current)
         return expanded;
@@ -7014,11 +7019,11 @@ async function writeConfigResult(config, targetPath, content, opts, meta = {}) {
   }
   const path = expandPath(renderedTargetPath);
   const renderedForTarget = isCursorGlobalAuthorityPath(path) ? stampCursorGlobalAuthorityMarker(renderedContent) : renderedContent;
-  const previousContent = existsSync4(path) ? readFileSync2(path, "utf-8") : null;
+  const previousContent = existsSync5(path) ? readFileSync3(path, "utf-8") : null;
   const changed = previousContent !== renderedForTarget;
   if (!opts.dryRun) {
-    const dir = dirname3(path);
-    if (!existsSync4(dir)) {
+    const dir = dirname4(path);
+    if (!existsSync5(dir)) {
       mkdirSync2(dir, { recursive: true });
     }
     if (previousContent !== null && changed) {
@@ -7052,9 +7057,9 @@ function wouldDestroyACredential(targetPath, renderedContent, format) {
   let current;
   try {
     const path = expandPath(targetPath);
-    if (!existsSync4(path))
+    if (!existsSync5(path))
       return [];
-    current = readFileSync2(path, "utf-8");
+    current = readFileSync3(path, "utf-8");
   } catch {
     return secretTokens;
   }
@@ -7142,7 +7147,7 @@ async function applyPreparedConfig(config, opts) {
       changed: outputResults.some((output) => output.changed)
     };
   }
-  if (!opts.dryRun) {
+  if (!opts.dryRun && result.changed) {
     await store.updateConfig(config.id, { synced_at: new Date().toISOString() });
   }
   return result;
@@ -7378,7 +7383,7 @@ function sessionRendererOwnsCanonicalTarget(normalized, opts) {
     getConfigHome(),
     opts.vars?.["HOME_DIR"]
   ].filter((home) => typeof home === "string" && home.length > 0));
-  if ([...homes].some((home) => SESSION_RENDER_OWNED_CONFIG_TARGETS.some((relativePath) => normalized === normalizeTargetPath(join7(home, ...relativePath.split("/"))))))
+  if ([...homes].some((home) => SESSION_RENDER_OWNED_CONFIG_TARGETS.some((relativePath) => normalized === normalizeTargetPath(join8(home, ...relativePath.split("/"))))))
     return true;
   return sessionRenderOwnsPath(normalized);
 }
@@ -7398,21 +7403,21 @@ var init_apply = __esm(() => {
 // src/lib/sync.ts
 var exports_sync = {};
 __export(exports_sync, {
-  CLAUDE_PROMPT_OUTPUTS: () => CLAUDE_PROMPT_OUTPUTS,
-  KNOWN_CONFIGS: () => KNOWN_CONFIGS,
-  PROJECT_CONFIG_FILES: () => PROJECT_CONFIG_FILES,
-  detectAgent: () => detectAgent,
-  detectCategory: () => detectCategory,
-  detectFormat: () => detectFormat,
-  diffConfig: () => diffConfig,
-  syncFromDir: () => syncFromDir,
-  syncKnown: () => syncKnown,
-  syncProject: () => syncProject,
+  syncToDisk: () => syncToDisk,
   syncToDir: () => syncToDir,
-  syncToDisk: () => syncToDisk
+  syncProject: () => syncProject,
+  syncKnown: () => syncKnown,
+  syncFromDir: () => syncFromDir,
+  diffConfig: () => diffConfig,
+  detectFormat: () => detectFormat,
+  detectCategory: () => detectCategory,
+  detectAgent: () => detectAgent,
+  PROJECT_CONFIG_FILES: () => PROJECT_CONFIG_FILES,
+  KNOWN_CONFIGS: () => KNOWN_CONFIGS,
+  CLAUDE_PROMPT_OUTPUTS: () => CLAUDE_PROMPT_OUTPUTS
 });
-import { existsSync as existsSync5, readdirSync, readFileSync as readFileSync3 } from "fs";
-import { basename as basename4, extname as extname2, join as join8 } from "path";
+import { existsSync as existsSync6, readdirSync, readFileSync as readFileSync4 } from "fs";
+import { basename as basename4, extname as extname2, join as join9 } from "path";
 function claudeRuleOutputs(fileName) {
   const stem = basename4(fileName, extname2(fileName));
   return [
@@ -7451,7 +7456,7 @@ function isGeneratedOutputTarget2(config, owners) {
   return !!ownerIds && !ownerIds.has(config.id);
 }
 function hasClaudePromptSource() {
-  return existsSync5(expandPath("~/.claude/CLAUDE.md"));
+  return existsSync6(expandPath("~/.claude/CLAUDE.md"));
 }
 function hasClaudeRuleSourceForCursorTarget(targetPath) {
   const absoluteTargetPath = expandPath(targetPath);
@@ -7459,7 +7464,7 @@ function hasClaudeRuleSourceForCursorTarget(targetPath) {
   if (!absoluteTargetPath.startsWith(`${absolutePrefix}/`) || !absoluteTargetPath.endsWith(".mdc"))
     return false;
   const stem = basename4(absoluteTargetPath, ".mdc");
-  return existsSync5(expandPath(`~/.claude/rules/${stem}.md`)) || existsSync5(expandPath(`~/.claude/rules/${stem}.mdc`));
+  return existsSync6(expandPath(`~/.claude/rules/${stem}.md`)) || existsSync6(expandPath(`~/.claude/rules/${stem}.mdc`));
 }
 function isKnownGeneratedTargetPath(targetPath) {
   const normalizedTargetPath = normalizeTargetPath(targetPath);
@@ -7476,11 +7481,11 @@ async function syncProject(opts) {
   const allConfigs = await store.listConfigs();
   const machine = detectMachineContext();
   for (const pf of PROJECT_CONFIG_FILES) {
-    const abs = join8(absDir, pf.file);
-    if (!existsSync5(abs))
+    const abs = join9(absDir, pf.file);
+    if (!existsSync6(abs))
       continue;
     try {
-      const rawContent = readFileSync3(abs, "utf-8");
+      const rawContent = readFileSync4(abs, "utf-8");
       if (rawContent.length > 500000) {
         result.skipped.push(pf.file);
         continue;
@@ -7509,20 +7514,20 @@ async function syncProject(opts) {
     }
   }
   for (const ruleDir of [
-    { dir: join8(absDir, ".claude", "rules"), agent: "claude", namePrefix: "rules" },
-    { dir: join8(absDir, ".agents", "rules"), agent: "antigravity", namePrefix: "antigravity-rules" },
-    { dir: join8(absDir, ".cursor", "rules"), agent: "cursor", namePrefix: "cursor-rules" },
-    { dir: join8(absDir, ".github", "instructions"), agent: "copilot", namePrefix: "copilot-instructions" },
-    { dir: join8(absDir, ".devin", "rules"), agent: "devin", namePrefix: "devin-rules" },
-    { dir: join8(absDir, ".windsurf", "rules"), agent: "windsurf-legacy", namePrefix: "windsurf-rules" },
-    { dir: join8(absDir, ".clinerules"), agent: "cline", namePrefix: "cline-rules" }
+    { dir: join9(absDir, ".claude", "rules"), agent: "claude", namePrefix: "rules" },
+    { dir: join9(absDir, ".agents", "rules"), agent: "antigravity", namePrefix: "antigravity-rules" },
+    { dir: join9(absDir, ".cursor", "rules"), agent: "cursor", namePrefix: "cursor-rules" },
+    { dir: join9(absDir, ".github", "instructions"), agent: "copilot", namePrefix: "copilot-instructions" },
+    { dir: join9(absDir, ".devin", "rules"), agent: "devin", namePrefix: "devin-rules" },
+    { dir: join9(absDir, ".windsurf", "rules"), agent: "windsurf-legacy", namePrefix: "windsurf-rules" },
+    { dir: join9(absDir, ".clinerules"), agent: "cline", namePrefix: "cline-rules" }
   ]) {
-    if (!existsSync5(ruleDir.dir))
+    if (!existsSync6(ruleDir.dir))
       continue;
     const mdFiles = readdirSync(ruleDir.dir).filter((f) => f.endsWith(".md") || f.endsWith(".mdc"));
     for (const f of mdFiles) {
-      const abs = join8(ruleDir.dir, f);
-      const raw = readFileSync3(abs, "utf-8");
+      const abs = join9(ruleDir.dir, f);
+      const raw = readFileSync4(abs, "utf-8");
       const redacted = redactContent(raw, "markdown");
       const machineAware = templateizeMachineContent(redacted.content, machine);
       const content = machineAware.content;
@@ -7561,20 +7566,20 @@ async function syncKnown(opts = {}) {
   for (const known of targets) {
     if (known.rulesDir) {
       const absDir = expandPath(known.rulesDir);
-      if (!existsSync5(absDir)) {
+      if (!existsSync6(absDir)) {
         result.skipped.push(known.rulesDir);
         continue;
       }
       const extensions = known.rulesExtensions ?? [".md", ".mdc"];
       const ruleFiles = readdirSync(absDir).filter((f) => extensions.some((ext) => f.endsWith(ext)));
       for (const f of ruleFiles) {
-        const abs2 = join8(absDir, f);
+        const abs2 = join9(absDir, f);
         const targetPath = abs2.replace(home, "~");
         if (existingOutputOwners.has(normalizeTargetPath(targetPath)) || isKnownGeneratedTargetPath(targetPath)) {
           result.skipped.push(`${targetPath} (generated output)`);
           continue;
         }
-        const raw = readFileSync3(abs2, "utf-8");
+        const raw = readFileSync4(abs2, "utf-8");
         const redacted = redactContent(raw, "markdown");
         const machineAware = templateizeMachineContent(redacted.content, machine);
         const content = machineAware.content;
@@ -7602,18 +7607,18 @@ async function syncKnown(opts = {}) {
       continue;
     }
     const abs = expandPath(known.path);
-    if (!existsSync5(abs)) {
+    if (!existsSync6(abs)) {
       result.skipped.push(known.path);
       continue;
     }
     try {
-      const rawContent = normalizeKnownConfigSource(known, readFileSync3(abs, "utf-8"));
+      const rawContent = normalizeKnownConfigSource(known, readFileSync4(abs, "utf-8"));
       if (rawContent.length > 500000) {
         result.skipped.push(known.path + " (too large)");
         continue;
       }
       const fmt = known.format ?? detectFormat(abs);
-      const redacted = redactContent(rawContent, fmt);
+      const redacted = redactContent(rawContent, redactFormatForTarget(abs, fmt));
       const machineAware = templateizeMachineContent(redacted.content, machine);
       const content = machineAware.content;
       const isTemplate2 = redacted.isTemplate || machineAware.changed;
@@ -7708,9 +7713,9 @@ function storedPlaceholderIsLiteralOnDisk(storedLine, diskLine) {
 }
 function buildDiff(expectedContent, targetPath, storedFormat, showSecrets) {
   const path = expandPath(targetPath);
-  if (!existsSync5(path))
+  if (!existsSync6(path))
     return `(file not found on disk: ${path})`;
-  const diskContent = readFileSync3(path, "utf-8");
+  const diskContent = readFileSync4(path, "utf-8");
   if (diskContent === expectedContent)
     return "(no diff \u2014 identical)";
   const format = redactFormatForTarget(targetPath, storedFormat);
@@ -7938,8 +7943,8 @@ var init_sync = __esm(() => {
 });
 
 // src/lib/sync-dir.ts
-import { existsSync as existsSync6, readdirSync as readdirSync2, readFileSync as readFileSync4, statSync as statSync2 } from "fs";
-import { join as join9, relative as relative3 } from "path";
+import { existsSync as existsSync7, readdirSync as readdirSync2, readFileSync as readFileSync5, statSync as statSync2 } from "fs";
+import { join as join10, relative as relative3 } from "path";
 import { homedir as homedir5 } from "os";
 function shouldSkip(p) {
   return SKIP.some((s) => p.includes(s));
@@ -7947,9 +7952,9 @@ function shouldSkip(p) {
 async function syncFromDir(dir, opts = {}) {
   const store = opts.store ?? resolveConfigStore();
   const absDir = expandPath(dir);
-  if (!existsSync6(absDir))
+  if (!existsSync7(absDir))
     return { added: 0, updated: 0, unchanged: 0, skipped: [`Not found: ${absDir}`] };
-  const files = opts.recursive !== false ? walkDir(absDir) : readdirSync2(absDir).map((f) => join9(absDir, f)).filter((f) => statSync2(f).isFile());
+  const files = opts.recursive !== false ? walkDir(absDir) : readdirSync2(absDir).map((f) => join10(absDir, f)).filter((f) => statSync2(f).isFile());
   const result = { added: 0, updated: 0, unchanged: 0, skipped: [] };
   const home = homedir5();
   const allConfigs = await store.listConfigs();
@@ -7959,20 +7964,21 @@ async function syncFromDir(dir, opts = {}) {
       continue;
     }
     try {
-      const content = readFileSync4(file, "utf-8");
+      const content = readFileSync5(file, "utf-8");
       if (content.length > 500000) {
         result.skipped.push(file + " (too large)");
         continue;
       }
       const targetPath = file.replace(home, "~");
+      const redacted = redactContent(content, redactFormatForTarget(targetPath, detectFormat(file)));
       const existing = allConfigs.find((c) => c.target_path === targetPath);
       if (!existing) {
         if (!opts.dryRun)
-          await store.createConfig({ name: relative3(absDir, file), category: detectCategory(file), agent: detectAgent(file), target_path: targetPath, format: detectFormat(file), content });
+          await store.createConfig({ name: relative3(absDir, file), category: detectCategory(file), agent: detectAgent(file), target_path: targetPath, format: detectFormat(file), content: redacted.content });
         result.added++;
-      } else if (existing.content !== content) {
+      } else if (existing.content !== redacted.content) {
         if (!opts.dryRun)
-          await store.updateConfig(existing.id, { content });
+          await store.updateConfig(existing.id, { content: redacted.content });
         result.updated++;
       } else {
         result.unchanged++;
@@ -8009,7 +8015,7 @@ async function syncToDir(dir, opts = {}) {
 }
 function walkDir(dir, files = []) {
   for (const entry of readdirSync2(dir, { withFileTypes: true })) {
-    const full = join9(dir, entry.name);
+    const full = join10(dir, entry.name);
     if (shouldSkip(full))
       continue;
     if (entry.isDirectory())
@@ -8024,14 +8030,15 @@ var init_sync_dir = __esm(() => {
   init_config_store();
   init_apply();
   init_sync();
+  init_redact();
   SKIP = [".db", ".db-shm", ".db-wal", ".log", ".lock", ".DS_Store", "node_modules", ".git"];
 });
 
 // package.json
-var require_package = __commonJS(function(exports, module) {
+var require_package = __commonJS((exports, module) => {
   module.exports = {
     name: "@hasna/instructions",
-    version: "0.4.39",
+    version: "0.4.43",
     description: "AI coding agent instruction & configuration manager \u2014 store, version, apply, and share all your AI coding configs. CLI + MCP + HTTP API (instructions-serve) + generated SDK + Dashboard.",
     type: "module",
     main: "dist/index.js",
@@ -8131,6 +8138,35 @@ var require_package = __commonJS(function(exports, module) {
 // src/mcp/index.ts
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
+// src/lib/package-version.ts
+import { existsSync, readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+var cached = null;
+function getPackageVersion() {
+  if (cached)
+    return cached;
+  try {
+    let dir = dirname(fileURLToPath(import.meta.url));
+    for (let i = 0;i < 8; i++) {
+      const pkgPath = join(dir, "package.json");
+      if (existsSync(pkgPath)) {
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+        if (pkg.name === "@hasna/instructions" && pkg.version) {
+          cached = pkg.version;
+          return cached;
+        }
+      }
+      const parent = dirname(dir);
+      if (parent === dir)
+        break;
+      dir = parent;
+    }
+  } catch {}
+  cached = "0.0.0";
+  return cached;
+}
+
 // src/mcp/server.ts
 init_config_store();
 init_apply();
@@ -8369,7 +8405,7 @@ function buildServer() {
           const allConfigs = await store.listConfigs({ kind: "file" });
           const { existsSync: ex, readFileSync: rf } = await import("fs");
           const { expandPath: expandPath2 } = await Promise.resolve().then(() => (init_apply(), exports_apply));
-          const { redactContent: redactContent2 } = await Promise.resolve().then(() => (init_redact(), exports_redact));
+          const { redactContent: redactContent2, redactFormatForTarget: redactFormatForTarget2 } = await Promise.resolve().then(() => (init_redact(), exports_redact));
           let drifted = 0, missing = 0, templates = 0;
           const driftedSlugs = [];
           for (const c of allConfigs) {
@@ -8383,7 +8419,7 @@ function buildServer() {
               continue;
             }
             const disk = rf(abs, "utf-8");
-            const { content: redactedDisk } = redactContent2(disk, c.format);
+            const { content: redactedDisk } = redactContent2(disk, redactFormatForTarget2(c.target_path, c.format));
             if (redactedDisk !== c.content) {
               drifted++;
               driftedSlugs.push(c.slug);
@@ -8430,11 +8466,11 @@ function buildServer() {
           return ok({ rendered, config_id: config.id, slug: config.slug });
         }
         case "scan_secrets": {
-          const { scanSecrets: scanSecrets2, redactContent: redactContent2 } = await Promise.resolve().then(() => (init_redact(), exports_redact));
+          const { scanSecrets: scanSecrets2, redactContent: redactContent2, redactFormatForTarget: redactFormatForTarget2 } = await Promise.resolve().then(() => (init_redact(), exports_redact));
           const configs = args["id_or_slug"] ? [await store.getConfig(args["id_or_slug"])] : await store.listConfigs({ kind: "file" });
           const findings = [];
           for (const c of configs) {
-            const fmt = c.format;
+            const fmt = redactFormatForTarget2(c.target_path ?? "", c.format);
             const secrets = scanSecrets2(c.content, fmt);
             if (secrets.length > 0) {
               findings.push({ slug: c.slug, secrets: secrets.length, vars: secrets.map((s) => s.varName) });
@@ -8582,6 +8618,24 @@ async function startMcpHttpServer(port) {
 // src/mcp/index.ts
 async function main() {
   const argv = process.argv.slice(2);
+  if (argv.includes("--version") || argv.includes("-V")) {
+    console.log(getPackageVersion());
+    return;
+  }
+  if (argv.includes("--help") || argv.includes("-h")) {
+    console.log(`Usage: configs-mcp [options]
+
+MCP server for @hasna/instructions (Streamable HTTP by default; --stdio to select stdio).
+
+Options:
+  -V, --version  output the version number
+  -h, --help     display help for command
+  --claude       register with Claude Code (stdio, user scope)
+  --http         explicitly select Streamable HTTP transport
+  --stdio        explicitly select stdio transport
+  --port <n>     HTTP port (default: 8853)`);
+    return;
+  }
   if (argv.includes("--claude")) {
     const proc = Bun.spawn(["claude", "mcp", "add", "--transport", "stdio", "--scope", "user", "configs", "--", "configs-mcp"], { stdout: "inherit", stderr: "inherit" });
     await proc.exited;