@theglitchking/hit-em-with-the-docs 2.5.0 → 2.7.0

package/dist/action/utils/config.d.ts

@@ -10,6 +10,43 @@ import { z } from 'zod';
 export declare const DEFAULT_VAULT_ROOT = ".documentation/knowledge-base/";
 export declare const DEFAULT_PLAYBOOK_GLOBS: string[];
 export declare const DEFAULT_AUDIT_WINDOW_DAYS = 90;
+/**
+ * Valid `category` values for a domain. Kept in sync with `DomainDefinition`
+ * in `core/domains/constants.ts` — duplicated here intentionally so the config
+ * loader carries no dependency on the domain layer (the registry imports the
+ * config, not the other way around).
+ */
+export declare const DOMAIN_CATEGORY_VALUES: readonly ["core", "development", "features", "advanced"];
+/**
+ * Schema for a single custom domain entry. Mirrors `DomainDefinition`. Used
+ * by the registry merge layer and by `hewtd domain add` (which validates
+ * strictly before writing). Collision with a built-in id is NOT checked here —
+ * that requires knowing the built-in set, so it is enforced in the registry
+ * merge (drop-with-warning) and in the CLI writer (hard error).
+ */
+export declare const customDomainSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    keywords: z.ZodArray<z.ZodString, "many">;
+    loadPriority: z.ZodNumber;
+    category: z.ZodEnum<["core", "development", "features", "advanced"]>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    name: string;
+    description: string;
+    keywords: string[];
+    loadPriority: number;
+    category: "features" | "core" | "development" | "advanced";
+}, {
+    id: string;
+    name: string;
+    description: string;
+    keywords: string[];
+    loadPriority: number;
+    category: "features" | "core" | "development" | "advanced";
+}>;
+export type CustomDomainConfig = z.infer<typeof customDomainSchema>;
 /**
  * Schema for `.claude/hit-em-with-the-docs.json`. Every field is optional
  * with a sensible default. The runtime's `updatePolicy` is preserved via
@@ -28,6 +65,29 @@ declare const vaultConfigSchema: z.ZodDefault<z.ZodObject<{
     playbook_paths?: string[] | undefined;
     audit_window_days?: number | undefined;
 }>>;
+export declare const DEFAULT_ARCHIVE_CANDIDATE_DAYS = 365;
+/**
+ * Archival policy. Governs candidate DETECTION and archival aggressiveness.
+ * The safe default is propose-don't-impose: nothing is ever auto-archived
+ * (`auto: false`), age alone never qualifies a doc (`require_orphaned: true`),
+ * and the recency threshold is generous (docs churn slower than code).
+ */
+declare const archiveConfigSchema: z.ZodDefault<z.ZodObject<{
+    honor_status_deprecated: z.ZodDefault<z.ZodBoolean>;
+    candidate_after_days: z.ZodDefault<z.ZodNumber>;
+    require_orphaned: z.ZodDefault<z.ZodBoolean>;
+    auto: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    honor_status_deprecated: boolean;
+    candidate_after_days: number;
+    require_orphaned: boolean;
+    auto: boolean;
+}, {
+    honor_status_deprecated?: boolean | undefined;
+    candidate_after_days?: number | undefined;
+    require_orphaned?: boolean | undefined;
+    auto?: boolean | undefined;
+}>>;
 declare const pluginConfigSchema: z.ZodObject<{
     vault: z.ZodDefault<z.ZodObject<{
         root: z.ZodDefault<z.ZodString>;
@@ -42,6 +102,51 @@ declare const pluginConfigSchema: z.ZodObject<{
         playbook_paths?: string[] | undefined;
         audit_window_days?: number | undefined;
     }>>;
+    domains: z.ZodDefault<z.ZodEffects<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodString;
+        keywords: z.ZodArray<z.ZodString, "many">;
+        loadPriority: z.ZodNumber;
+        category: z.ZodEnum<["core", "development", "features", "advanced"]>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        name: string;
+        description: string;
+        keywords: string[];
+        loadPriority: number;
+        category: "features" | "core" | "development" | "advanced";
+    }, {
+        id: string;
+        name: string;
+        description: string;
+        keywords: string[];
+        loadPriority: number;
+        category: "features" | "core" | "development" | "advanced";
+    }>, "many">, {
+        id: string;
+        name: string;
+        description: string;
+        keywords: string[];
+        loadPriority: number;
+        category: "features" | "core" | "development" | "advanced";
+    }[], unknown>>;
+    archive: z.ZodDefault<z.ZodObject<{
+        honor_status_deprecated: z.ZodDefault<z.ZodBoolean>;
+        candidate_after_days: z.ZodDefault<z.ZodNumber>;
+        require_orphaned: z.ZodDefault<z.ZodBoolean>;
+        auto: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        honor_status_deprecated: boolean;
+        candidate_after_days: number;
+        require_orphaned: boolean;
+        auto: boolean;
+    }, {
+        honor_status_deprecated?: boolean | undefined;
+        candidate_after_days?: number | undefined;
+        require_orphaned?: boolean | undefined;
+        auto?: boolean | undefined;
+    }>>;
 }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
     vault: z.ZodDefault<z.ZodObject<{
         root: z.ZodDefault<z.ZodString>;
@@ -56,6 +161,51 @@ declare const pluginConfigSchema: z.ZodObject<{
         playbook_paths?: string[] | undefined;
         audit_window_days?: number | undefined;
     }>>;
+    domains: z.ZodDefault<z.ZodEffects<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodString;
+        keywords: z.ZodArray<z.ZodString, "many">;
+        loadPriority: z.ZodNumber;
+        category: z.ZodEnum<["core", "development", "features", "advanced"]>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        name: string;
+        description: string;
+        keywords: string[];
+        loadPriority: number;
+        category: "features" | "core" | "development" | "advanced";
+    }, {
+        id: string;
+        name: string;
+        description: string;
+        keywords: string[];
+        loadPriority: number;
+        category: "features" | "core" | "development" | "advanced";
+    }>, "many">, {
+        id: string;
+        name: string;
+        description: string;
+        keywords: string[];
+        loadPriority: number;
+        category: "features" | "core" | "development" | "advanced";
+    }[], unknown>>;
+    archive: z.ZodDefault<z.ZodObject<{
+        honor_status_deprecated: z.ZodDefault<z.ZodBoolean>;
+        candidate_after_days: z.ZodDefault<z.ZodNumber>;
+        require_orphaned: z.ZodDefault<z.ZodBoolean>;
+        auto: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        honor_status_deprecated: boolean;
+        candidate_after_days: number;
+        require_orphaned: boolean;
+        auto: boolean;
+    }, {
+        honor_status_deprecated?: boolean | undefined;
+        candidate_after_days?: number | undefined;
+        require_orphaned?: boolean | undefined;
+        auto?: boolean | undefined;
+    }>>;
 }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
     vault: z.ZodDefault<z.ZodObject<{
         root: z.ZodDefault<z.ZodString>;
@@ -70,8 +220,54 @@ declare const pluginConfigSchema: z.ZodObject<{
         playbook_paths?: string[] | undefined;
         audit_window_days?: number | undefined;
     }>>;
+    domains: z.ZodDefault<z.ZodEffects<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodString;
+        keywords: z.ZodArray<z.ZodString, "many">;
+        loadPriority: z.ZodNumber;
+        category: z.ZodEnum<["core", "development", "features", "advanced"]>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        name: string;
+        description: string;
+        keywords: string[];
+        loadPriority: number;
+        category: "features" | "core" | "development" | "advanced";
+    }, {
+        id: string;
+        name: string;
+        description: string;
+        keywords: string[];
+        loadPriority: number;
+        category: "features" | "core" | "development" | "advanced";
+    }>, "many">, {
+        id: string;
+        name: string;
+        description: string;
+        keywords: string[];
+        loadPriority: number;
+        category: "features" | "core" | "development" | "advanced";
+    }[], unknown>>;
+    archive: z.ZodDefault<z.ZodObject<{
+        honor_status_deprecated: z.ZodDefault<z.ZodBoolean>;
+        candidate_after_days: z.ZodDefault<z.ZodNumber>;
+        require_orphaned: z.ZodDefault<z.ZodBoolean>;
+        auto: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        honor_status_deprecated: boolean;
+        candidate_after_days: number;
+        require_orphaned: boolean;
+        auto: boolean;
+    }, {
+        honor_status_deprecated?: boolean | undefined;
+        candidate_after_days?: number | undefined;
+        require_orphaned?: boolean | undefined;
+        auto?: boolean | undefined;
+    }>>;
 }, z.ZodTypeAny, "passthrough">>;
 export type VaultConfig = z.infer<typeof vaultConfigSchema>;
+export type ArchiveConfig = z.infer<typeof archiveConfigSchema>;
 export type PluginConfig = z.infer<typeof pluginConfigSchema>;
 /**
  * Load the plugin config for a project, applying defaults. Never throws —
@@ -85,6 +281,21 @@ export declare function loadPluginConfig(projectRoot?: string): Promise<PluginCo
  * Same fail-open behavior.
  */
 export declare function loadPluginConfigSync(projectRoot?: string): PluginConfig;
+/**
+ * Read the RAW config object (unparsed, no defaults applied) for a project.
+ * Returns `{}` when the file is missing or unreadable/malformed. Use this when
+ * you need to MUTATE the config and write it back without clobbering keys this
+ * module doesn't model (e.g. the runtime's `updatePolicy`). Never throws.
+ */
+export declare function readRawConfig(projectRoot?: string): Promise<Record<string, unknown>>;
+/**
+ * Write the RAW config object back to `.claude/hit-em-with-the-docs.json`,
+ * creating the `.claude/` directory if needed. Pretty-printed with a trailing
+ * newline. Returns the absolute path written.
+ */
+export declare function writeRawConfig(projectRoot: string, data: Record<string, unknown>): Promise<string>;
+/** Absolute path to a project's config file (whether or not it exists). */
+export declare function configFilePath(projectRoot: string): string;
 /**
  * Resolve the vault root for a project, applying config + defaults.
  * The returned path is absolute.

package/dist/action/utils/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["file:///home/tmarlette/workspace/the-glitch-kingdom/hit-em-with-the-docs/src/utils/config.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,kBAAkB,mCAAmC,CAAC;AACnE,eAAO,MAAM,sBAAsB,UAA6B,CAAC;AACjE,eAAO,MAAM,yBAAyB,KAAK,CAAC;AAE5C;;;;GAIG;AACH,QAAA,MAAM,iBAAiB;;;;;;;;;;;;GAMT,CAAC;AAEf,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAIR,CAAC;AAEjB,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAC5D,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAI9D;;;;;GAKG;AACH,wBAAsB,gBAAgB,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CAkBlF;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,YAAY,CAoBvE;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,GAAG,MAAM,CAElF;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,YAAY,GACnB,MAAM,EAAE,CAEV"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["file:///home/tmarlette/workspace/the-glitch-kingdom/hit-em-with-the-docs/src/utils/config.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAKH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,kBAAkB,mCAAmC,CAAC;AACnE,eAAO,MAAM,sBAAsB,UAA6B,CAAC;AACjE,eAAO,MAAM,yBAAyB,KAAK,CAAC;AAK5C;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,0DAKzB,CAAC;AAEX;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;EAO7B,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAgBpE;;;;GAIG;AACH,QAAA,MAAM,iBAAiB;;;;;;;;;;;;GAMT,CAAC;AAEf,eAAO,MAAM,8BAA8B,MAAM,CAAC;AAElD;;;;;GAKG;AACH,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;;;GAWX,CAAC;AAEf,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAMR,CAAC;AAEjB,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAC5D,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAI9D;;;;;GAKG;AACH,wBAAsB,gBAAgB,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CAkBlF;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,YAAY,CAiBvE;AAED;;;;;GAKG;AACH,wBAAsB,aAAa,CACjC,WAAW,CAAC,EAAE,MAAM,GACnB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAYlC;AAED;;;;GAIG;AACH,wBAAsB,cAAc,CAClC,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC5B,OAAO,CAAC,MAAM,CAAC,CAKjB;AAED,2EAA2E;AAC3E,wBAAgB,cAAc,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAE1D;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,GAAG,MAAM,CAElF;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,YAAY,GACnB,MAAM,EAAE,CAEV"}

package/dist/action/utils/glob.d.ts

@@ -9,7 +9,19 @@ export interface GlobOptions {
  */
 export declare function glob(pattern: string, options?: GlobOptions): Promise<string[]>;
 /**
- * Find all markdown files in a directory
+ * Reserved documentation subdirectory for DEPRECATED docs. Anything under
+ * `<docs>/archive/` is intentionally excluded from every hewtd scan (audit,
+ * link-check, metadata-sync, integrate dup-detection, link graph, search) —
+ * it's a parking lot for retired docs, not part of the active corpus.
+ */
+export declare const ARCHIVE_DIR = "archive";
+/**
+ * Find all markdown files in a directory.
+ *
+ * Used exclusively as the documentation-corpus scanner, so it always skips
+ * the reserved `archive/` subtree (deprecated docs) in addition to the
+ * standard build/vcs ignores. Callers may pass extra `ignore` patterns; they
+ * are merged, never override the archive exclusion.
  */
 export declare function findMarkdownFiles(dir: string, options?: Omit<GlobOptions, 'absolute'>): Promise<string[]>;
 /**

package/dist/action/utils/glob.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"glob.d.ts","sourceRoot":"","sources":["file:///home/tmarlette/workspace/the-glitch-kingdom/hit-em-with-the-docs/src/utils/glob.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,WAAW;IAC1B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,GAAG,CAAC,EAAE,OAAO,CAAC;CACf;AAED;;GAEG;AACH,wBAAsB,IAAI,CACxB,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,WAAgB,GACxB,OAAO,CAAC,MAAM,EAAE,CAAC,CAiBnB;AAED;;GAEG;AACH,wBAAsB,iBAAiB,CACrC,GAAG,EAAE,MAAM,EACX,OAAO,GAAE,IAAI,CAAC,WAAW,EAAE,UAAU,CAAM,GAC1C,OAAO,CAAC,MAAM,EAAE,CAAC,CAMnB;AAED;;GAEG;AACH,wBAAsB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAO/D;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEpD;AAED;;GAEG;AACH,wBAAsB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAOhE;AAED;;GAEG;AACH,wBAAsB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAO3D;AAED;;GAEG;AACH,wBAAsB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAStE;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,CAEtE;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAEpE;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE/C;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEhD;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEjD;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAGpD;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAElD"}
+{"version":3,"file":"glob.d.ts","sourceRoot":"","sources":["file:///home/tmarlette/workspace/the-glitch-kingdom/hit-em-with-the-docs/src/utils/glob.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,WAAW;IAC1B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,GAAG,CAAC,EAAE,OAAO,CAAC;CACf;AAED;;GAEG;AACH,wBAAsB,IAAI,CACxB,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,WAAgB,GACxB,OAAO,CAAC,MAAM,EAAE,CAAC,CAiBnB;AAED;;;;;GAKG;AACH,eAAO,MAAM,WAAW,YAAY,CAAC;AAUrC;;;;;;;GAOG;AACH,wBAAsB,iBAAiB,CACrC,GAAG,EAAE,MAAM,EACX,OAAO,GAAE,IAAI,CAAC,WAAW,EAAE,UAAU,CAAM,GAC1C,OAAO,CAAC,MAAM,EAAE,CAAC,CAQnB;AAED;;GAEG;AACH,wBAAsB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAO/D;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEpD;AAED;;GAEG;AACH,wBAAsB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAOhE;AAED;;GAEG;AACH,wBAAsB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAO3D;AAED;;GAEG;AACH,wBAAsB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAStE;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,CAEtE;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAEpE;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE/C;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEhD;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEjD;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAGpD;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAElD"}

package/dist/cli/index.js

@@ -19,7 +19,7 @@ import { analyzeDependencies } from '../core/discover/dependencies.js';
 import { saveHealthReport } from '../reports/health-report.js';
 import { saveAuditReport } from '../reports/audit-report.js';
 import { saveLinkReport } from '../reports/link-report.js';
-import { DOMAINS, DOMAIN_DEFINITIONS, isValidDomain } from '../core/domains/constants.js';
+import { getAllDomains, getDomainDefinition, isValidDomain, } from '../core/domains/registry.js';
 import { regenerateIndexes } from '../generators/regenerate.js';
 const program = new Command();
 program
@@ -81,7 +81,7 @@ program
     if (options.domain) {
         if (!isValidDomain(options.domain)) {
             logger.error(`Unknown domain: ${options.domain}`);
-            logger.info(`Valid domains: ${DOMAINS.join(', ')}`);
+            logger.info(`Valid domains: ${getAllDomains().join(', ')}`);
             process.exit(1);
         }
         domains = [options.domain];
@@ -92,7 +92,7 @@ program
         ...(domains ? { domains } : {}),
         silent: true,
     });
-    for (const domain of DOMAINS) {
+    for (const domain of getAllDomains()) {
         const count = result.documentCounts[domain] ?? 0;
         logger.info(`  ${domain.padEnd(16)} ${count} document${count === 1 ? '' : 's'}`);
     }
@@ -291,12 +291,242 @@ program
     .action(() => {
     logger.header('Documentation Domains');
     const headers = ['Domain', 'Category', 'Priority', 'Description'];
-    const rows = DOMAINS.map((d) => {
-        const def = DOMAIN_DEFINITIONS[d];
+    const rows = getAllDomains().map((d) => {
+        const def = getDomainDefinition(d);
         return [d, def.category, `${def.loadPriority}/10`, def.description];
     });
     logger.table(headers, rows);
 });
+// --- Custom domains: add / remove / list ---
+const domain = program
+    .command('domain')
+    .description('Manage custom documentation domains (add | remove | list)');
+domain
+    .command('list')
+    .description('List built-in and custom domains')
+    .option('--json', 'Output as JSON', false)
+    .action(async (options) => {
+    const { listDomains } = await import('../core/domains/manage.js');
+    const result = listDomains(process.cwd());
+    if (options.json) {
+        logger.info(JSON.stringify(result, null, 2));
+        return;
+    }
+    logger.header('Documentation Domains');
+    const headers = ['Domain', 'Kind', 'Category', 'Priority', 'Description'];
+    const rows = [
+        ...result.builtin.map((d) => [
+            d.id,
+            'built-in',
+            d.category,
+            `${d.loadPriority}/10`,
+            d.description,
+        ]),
+        ...result.custom.map((d) => [
+            d.id,
+            'custom',
+            d.category,
+            `${d.loadPriority}/10`,
+            d.description,
+        ]),
+    ];
+    logger.table(headers, rows);
+    logger.newline();
+    logger.info(`${result.builtin.length} built-in · ${result.custom.length} custom`);
+});
+domain
+    .command('add <id>')
+    .description('Add a custom domain (writes config + scaffolds the folder)')
+    .option('-p, --path <path>', 'Documentation path', '.documentation')
+    .option('-n, --name <name>', 'Human-readable name (defaults to a title-cased id)')
+    .option('-d, --description <desc>', 'One-line description')
+    .option('-k, --keywords <csv>', 'Comma-separated keywords used for auto-classification (required)')
+    .option('-c, --category <category>', 'core | development | features | advanced', 'features')
+    .option('--load-priority <n>', 'Load priority 1-10', '5')
+    .option('--dry-run', 'Preview without writing', false)
+    .action(async (id, options) => {
+    const { addDomain } = await import('../core/domains/manage.js');
+    const docsPath = resolve(process.cwd(), options.path);
+    const titleCase = (s) => s.replace(/[-_]/g, ' ').replace(/\b\w/g, (ch) => ch.toUpperCase());
+    const spec = {
+        id,
+        name: options.name ?? titleCase(id),
+        description: options.description ?? `${titleCase(id)} documentation`,
+        keywords: options.keywords
+            ? String(options.keywords)
+                .split(',')
+                .map((k) => k.trim())
+                .filter(Boolean)
+            : [],
+        loadPriority: parseInt(options.loadPriority, 10),
+        category: options.category,
+    };
+    const result = await addDomain({
+        projectRoot: process.cwd(),
+        docsPath,
+        spec,
+        dryRun: options.dryRun,
+    });
+    logger.header(`hewtd domain add: ${id}`);
+    if (!result.ok) {
+        for (const e of result.errors)
+            logger.error(e);
+        process.exit(1);
+    }
+    logger.info(`Config:  ${result.configPath}`);
+    logger.info(`Folder:  ${result.domainFolder}`);
+    if (result.action === 'dry_run') {
+        logger.info('');
+        logger.info('--- proposed config entry ---');
+        logger.info(JSON.stringify(result.spec, null, 2));
+        logger.info('');
+        logger.info('Dry-run — nothing written. Re-run without --dry-run to apply.');
+        return;
+    }
+    logger.success(`Added custom domain "${id}".`);
+    logger.info(`Wrote ${result.filesWritten?.length ?? 0} file(s).`);
+    logger.info('Run `hewtd maintain` any time to refresh indexes.');
+});
+domain
+    .command('remove <id>')
+    .alias('rm')
+    .description('Remove a custom domain from config (never deletes docs)')
+    .option('-p, --path <path>', 'Documentation path', '.documentation')
+    .option('--dry-run', 'Preview without writing', false)
+    .action(async (id, options) => {
+    const { removeDomain } = await import('../core/domains/manage.js');
+    const docsPath = resolve(process.cwd(), options.path);
+    const result = await removeDomain({
+        projectRoot: process.cwd(),
+        docsPath,
+        id,
+        dryRun: options.dryRun,
+    });
+    logger.header(`hewtd domain remove: ${id}`);
+    if (!result.ok) {
+        for (const e of result.errors)
+            logger.error(e);
+        process.exit(1);
+    }
+    if (result.orphanedDocs > 0) {
+        logger.warn(`${result.orphanedDocs} document(s) in ${result.domainFolder} will be ORPHANED (left on disk, no longer a recognized domain).`);
+    }
+    if (result.action === 'dry_run') {
+        logger.info('');
+        logger.info('Dry-run — nothing written. Re-run without --dry-run to apply.');
+        return;
+    }
+    logger.success(`Removed custom domain "${id}" from config.`);
+    logger.info(`Folder left intact: ${result.domainFolder}`);
+});
+// --- Archival process: archive / unarchive / archive-candidates ---
+program
+    .command('archive <file>')
+    .description('Archive (deprecate) a doc: move it into archive/, stamp lifecycle metadata, reindex. Non-destructive + reversible.')
+    .option('-p, --path <path>', 'Documentation path', '.documentation')
+    .option('-r, --reason <reason>', 'Why this doc is being archived')
+    .option('--force', 'Archive even if active docs still link to it', false)
+    .option('--dry-run', 'Preview without moving anything', false)
+    .action(async (file, options) => {
+    const { archiveDoc } = await import('../core/archive/manage.js');
+    const docsPath = resolve(process.cwd(), options.path);
+    const result = await archiveDoc({
+        projectRoot: process.cwd(),
+        docsPath,
+        file,
+        reason: options.reason,
+        force: options.force,
+        dryRun: options.dryRun,
+    });
+    logger.header(`hewtd archive: ${file}`);
+    if (!result.ok) {
+        for (const e of result.errors)
+            logger.error(e);
+        if (result.action === 'blocked' && result.inboundLinks.length > 0) {
+            logger.info('');
+            logger.info('Active docs linking here (fix these or use --force):');
+            for (const l of result.inboundLinks) {
+                logger.info(`  ${l.source}:${l.lineNumber}  "${l.linkText}"`);
+            }
+        }
+        process.exit(1);
+    }
+    logger.info(`From: ${result.from}`);
+    logger.info(`To:   ${result.to}`);
+    if (result.inboundLinks.length > 0) {
+        logger.warn(`${result.inboundLinks.length} active doc(s) link here — these become dangling:`);
+        for (const l of result.inboundLinks)
+            logger.info(`  ${l.source}:${l.lineNumber}`);
+    }
+    if (result.action === 'dry_run') {
+        logger.info('');
+        logger.info('Dry-run — nothing moved. Re-run without --dry-run to apply.');
+        return;
+    }
+    logger.success(`Archived via ${result.moveMethod}. Run \`hewtd maintain\` any time to refresh.`);
+});
+program
+    .command('unarchive <file>')
+    .description('Restore an archived doc back to its domain folder (reverse of archive).')
+    .option('-p, --path <path>', 'Documentation path', '.documentation')
+    .option('--dry-run', 'Preview without moving anything', false)
+    .action(async (file, options) => {
+    const { unarchiveDoc } = await import('../core/archive/manage.js');
+    const docsPath = resolve(process.cwd(), options.path);
+    const result = await unarchiveDoc({
+        projectRoot: process.cwd(),
+        docsPath,
+        file,
+        dryRun: options.dryRun,
+    });
+    logger.header(`hewtd unarchive: ${file}`);
+    if (!result.ok) {
+        for (const e of result.errors)
+            logger.error(e);
+        process.exit(1);
+    }
+    logger.info(`From: ${result.from}`);
+    logger.info(`To:   ${result.to}`);
+    if (result.action === 'dry_run') {
+        logger.info('');
+        logger.info('Dry-run — nothing moved. Re-run without --dry-run to apply.');
+        return;
+    }
+    logger.success(`Restored via ${result.moveMethod}.`);
+});
+program
+    .command('archive-candidates')
+    .description('List docs that may warrant archiving (advisory — never moves anything).')
+    .option('-p, --path <path>', 'Documentation path', '.documentation')
+    .option('--json', 'Output as JSON', false)
+    .action(async (options) => {
+    const { loadPluginConfig } = await import('../utils/config.js');
+    const { findArchiveCandidates } = await import('../core/archive/candidates.js');
+    const docsPath = resolve(process.cwd(), options.path);
+    const config = await loadPluginConfig(process.cwd());
+    const candidates = await findArchiveCandidates({
+        docsPath,
+        projectRoot: process.cwd(),
+        config: config.archive,
+    });
+    if (options.json) {
+        logger.info(JSON.stringify(candidates, null, 2));
+        return;
+    }
+    logger.header('Archive candidates');
+    if (candidates.length === 0) {
+        logger.success('No archival candidates. Nothing flagged.');
+        return;
+    }
+    for (const c of candidates) {
+        logger.info(`  ${c.file}  (score ${c.score})`);
+        for (const r of c.reasons)
+            logger.info(`      - ${r}`);
+    }
+    logger.info('');
+    logger.info('These are suggestions only. Archive one with:');
+    logger.info('  hewtd archive <file> --dry-run    # preview, then drop --dry-run');
+});
 // --- 2.3.0: knowledge-base commands ---
 program
     .command('find-citers <fact-id>')