@lsctech/polaris 0.4.4 → 0.4.6

package/dist/smartdocs-engine/doctrine.js

@@ -7,6 +7,8 @@ exports.stampIngestFrontMatter = stampIngestFrontMatter;
 exports.doctrineDraft = doctrineDraft;
 exports.doctrinePromote = doctrinePromote;
 exports.doctrineDeprecate = doctrineDeprecate;
+exports.detectDoctrineSupersession = detectDoctrineSupersession;
+exports.checkSmartDocsLinks = checkSmartDocsLinks;
 exports.specPromote = specPromote;
 exports.migrateProvenance = migrateProvenance;
 const node_fs_1 = require("node:fs");
@@ -186,6 +188,59 @@ function appendLifecycle(lifecyclePath, event) {
     (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(lifecyclePath), { recursive: true });
     (0, node_fs_1.appendFileSync)(lifecyclePath, JSON.stringify(event) + "\n", "utf-8");
 }
+const DIRECTORY_LOG_HEADER = "# Directory Update Log";
+/**
+ * Append a dated prose entry to a per-directory log.md file, following the OKF convention:
+ * date-grouped YYYY-MM-DD headings, newest-first, with a bold verb prefix.
+ *
+ * Creates the file with the canonical header if it does not yet exist. If the
+ * newest heading already matches today's date, the entry is inserted under that
+ * heading; otherwise a new today's heading is prepended before the existing entries.
+ *
+ * This function is best-effort: failures during read/write are caught and logged
+ * as warnings but do not propagate to the caller, ensuring log.md update failures
+ * do not block directory transitions.
+ *
+ * @param directory - Directory that contains (or will contain) log.md
+ * @param verb - Lifecycle verb rendered as the bold prefix (Draft, Promote, Deprecate)
+ * @param reason - Human-readable prose entry for this change
+ */
+function logDirectoryChange(directory, verb, reason) {
+    try {
+        const logPath = (0, node_path_1.join)(directory, "log.md");
+        const today = new Date().toISOString().slice(0, 10);
+        const entry = `**${verb}**: ${reason}`;
+        let content = (0, node_fs_1.existsSync)(logPath) ? (0, node_fs_1.readFileSync)(logPath, "utf-8") : "";
+        content = content.replace(/\r\n/g, "\n");
+        const todayHeading = `## ${today}`;
+        // Use anchored regex to match heading at start of line, not substring in prose.
+        const firstHeadingMatch = content.match(/^## (\d{4}-\d{2}-\d{2})/m);
+        if (firstHeadingMatch && firstHeadingMatch[1] === today) {
+            // Find the actual heading line position using anchored search.
+            const headingMatch = content.match(new RegExp(`^${todayHeading}`, 'm'));
+            if (headingMatch && headingMatch.index !== undefined) {
+                const headingIndex = headingMatch.index;
+                const afterHeading = headingIndex + todayHeading.length;
+                const newContent = `${content.slice(0, afterHeading)}\n${entry}${content.slice(afterHeading)}`;
+                (0, node_fs_1.writeFileSync)(logPath, newContent, "utf-8");
+            }
+        }
+        else if (content.trim().startsWith(DIRECTORY_LOG_HEADER)) {
+            const afterHeader = content.indexOf(DIRECTORY_LOG_HEADER) + DIRECTORY_LOG_HEADER.length;
+            const tail = content.slice(afterHeader).replace(/^\n*/, "\n\n");
+            const newContent = `${DIRECTORY_LOG_HEADER}\n\n${todayHeading}\n${entry}${tail}`;
+            (0, node_fs_1.writeFileSync)(logPath, newContent, "utf-8");
+        }
+        else {
+            const existing = content.trim() ? `${content}\n\n` : "";
+            (0, node_fs_1.writeFileSync)(logPath, `${DIRECTORY_LOG_HEADER}\n\n${todayHeading}\n${entry}\n${existing}`, "utf-8");
+        }
+    }
+    catch (err) {
+        // Best-effort: log warning but do not propagate failure.
+        console.warn(`[warn] Failed to update log.md in ${directory}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
 /**
  * Resolve a filesystem path against a repository root and return an absolute path.
  *
@@ -236,6 +291,8 @@ function doctrineDraft(path, options) {
         destination,
         timestamp: new Date().toISOString(),
     });
+    const reason = options.reason ?? `${(0, node_path_1.basename)(destination)} drafted to doctrine/candidate/`;
+    logDirectoryChange((0, node_path_1.dirname)(destination), "Draft", reason);
     return { source, destination, runId, lifecyclePath };
 }
 /**
@@ -322,6 +379,8 @@ function doctrinePromote(path, options) {
         destination,
         timestamp: new Date().toISOString(),
     });
+    const reason = options.reason ?? `${(0, node_path_1.basename)(destination)} promoted to doctrine/active/`;
+    logDirectoryChange((0, node_path_1.dirname)(destination), "Promote", reason);
     return { source, destination, runId, lifecyclePath };
 }
 /**
@@ -371,6 +430,8 @@ function doctrineDeprecate(path, options) {
         deprecated_at: deprecatedAt,
         timestamp: deprecatedAt,
     });
+    const reason = options.reason ?? `${(0, node_path_1.basename)(destination)} deprecated to doctrine/deprecated/`;
+    logDirectoryChange((0, node_path_1.dirname)(destination), "Deprecate", reason);
     return { source, destination, runId, lifecyclePath };
 }
 // ── Spec verb-keyword conflict detection ──────────────────────────────────────
@@ -390,6 +451,174 @@ function extractSpecKeywords(content, pattern) {
     }
     return result;
 }
+/**
+ * Compute the Jaccard similarity between two keyword sets.
+ * Returns a value in [0, 1]; 0 means no overlap, 1 means identical.
+ */
+function jaccardSimilarity(a, b) {
+    if (a.size === 0 && b.size === 0)
+        return 0;
+    let intersection = 0;
+    for (const kw of a) {
+        if (b.has(kw))
+            intersection++;
+    }
+    return intersection / (a.size + b.size - intersection);
+}
+/**
+ * Extract a combined keyword set from a document using both REQUIRES and PROHIBITS patterns.
+ * Reuses the existing extractSpecKeywords function — no second algorithm.
+ */
+function extractAllKeywords(content) {
+    const requires = extractSpecKeywords(content, MODAL_REQUIRES);
+    const prohibits = extractSpecKeywords(content, MODAL_PROHIBITS);
+    return new Set([...requires, ...prohibits]);
+}
+// Jaccard threshold above which an active doc is considered a supersession candidate.
+// 0.3 is deliberately permissive: better to surface an advisory than to miss it.
+const SUPERSESSION_THRESHOLD = 0.3;
+/**
+ * Detect whether an incoming doctrine-candidate document has high content overlap with
+ * any existing active doctrine document. When overlap exceeds the threshold, the active
+ * doc is returned as a suggested-supersession advisory conflict.
+ *
+ * This is report-only: it never writes to `supersedes`/`superseded_by` frontmatter.
+ * The caller (or the user via CLI) decides whether to act on the suggestion.
+ *
+ * @param candidatePath - Absolute or repo-relative path to the candidate document
+ * @param options       - Doctrine options (must include `repoRoot`)
+ * @returns Array of SpecConflict entries with type "suggested-supersession"; empty when
+ *          no active docs exist or no overlap exceeds the threshold
+ */
+function detectDoctrineSupersession(candidatePath, options) {
+    const repoRoot = (0, node_path_1.resolve)(options.repoRoot);
+    const source = resolvePath(candidatePath, repoRoot);
+    if (!(0, node_fs_1.existsSync)(source))
+        return [];
+    let candidateContent;
+    try {
+        candidateContent = (0, node_fs_1.readFileSync)(source, "utf-8");
+    }
+    catch {
+        return [];
+    }
+    const candidateKeywords = extractAllKeywords(candidateContent);
+    // No keywords in candidate → no meaningful overlap can be computed
+    if (candidateKeywords.size === 0)
+        return [];
+    const activeDir = (0, node_path_1.resolve)(repoRoot, "smartdocs", "doctrine", "active");
+    if (!(0, node_fs_1.existsSync)(activeDir))
+        return [];
+    const conflicts = [];
+    let activeFiles;
+    try {
+        activeFiles = (0, node_fs_1.readdirSync)(activeDir).filter((f) => f.endsWith(".md"));
+    }
+    catch {
+        return [];
+    }
+    for (const file of activeFiles) {
+        let activeContent;
+        try {
+            activeContent = (0, node_fs_1.readFileSync)((0, node_path_1.join)(activeDir, file), "utf-8");
+        }
+        catch {
+            continue;
+        }
+        const activeKeywords = extractAllKeywords(activeContent);
+        if (activeKeywords.size === 0)
+            continue;
+        const score = jaccardSimilarity(candidateKeywords, activeKeywords);
+        if (score >= SUPERSESSION_THRESHOLD) {
+            conflicts.push({
+                type: "suggested-supersession",
+                conflictingFile: file,
+                detail: `candidate has ${Math.round(score * 100)}% keyword overlap with active doc "${file}" — consider adding supersedes: ${file.replace(/\.md$/, "")} to frontmatter`,
+            });
+        }
+    }
+    return conflicts;
+}
+// Regex to extract markdown links: [text](href)
+const MD_LINK_RE = /\[([^\]]*)\]\(([^)]+)\)/g;
+// Tiers that are subject to strict link checking (raw/ is permissive per OKF §5.3)
+const STRICT_LINK_TIERS = ["candidate", "active"];
+/**
+ * Determine whether a file path is in a strict-check tier (candidate/ or active/)
+ * under smartdocs/. Returns false for raw/ or anything outside smartdocs/.
+ */
+function isStrictTier(filePath, repoRoot) {
+    const rel = (0, node_path_1.relative)((0, node_path_1.resolve)(repoRoot), (0, node_path_1.resolve)(filePath)).replace(/\\/g, "/");
+    if (!rel.startsWith("smartdocs/"))
+        return false;
+    return STRICT_LINK_TIERS.some((tier) => rel.includes(`/${tier}/`) || rel.includes(`/${tier}\\`));
+}
+/**
+ * Resolve a markdown link href found in `sourceFile` to an absolute filesystem path.
+ *
+ * Supports two forms:
+ *   - Bundle-relative: `/smartdocs/...` — resolved from repoRoot
+ *   - Relative: `./foo.md`, `../foo.md`, `foo.md` — resolved from the source file's directory
+ *
+ * Returns null if the href does not point into smartdocs/ (e.g. external URLs, src/ links).
+ */
+function resolveSmartDocsLink(href, sourceFile, repoRoot) {
+    // Strip anchors
+    const bare = href.split("#")[0];
+    if (!bare.endsWith(".md"))
+        return null;
+    let abs;
+    if (bare.startsWith("/")) {
+        // Bundle-relative: treat / as repoRoot
+        abs = (0, node_path_1.join)((0, node_path_1.resolve)(repoRoot), bare.slice(1));
+    }
+    else if (bare.startsWith("http://") || bare.startsWith("https://")) {
+        return null;
+    }
+    else {
+        // Relative to source file's directory
+        abs = (0, node_path_1.join)((0, node_path_1.dirname)((0, node_path_1.resolve)(sourceFile)), bare);
+    }
+    // Only check links that land inside smartdocs/
+    const rel = (0, node_path_1.relative)((0, node_path_1.resolve)(repoRoot), abs).replace(/\\/g, "/");
+    if (!rel.startsWith("smartdocs/"))
+        return null;
+    return abs;
+}
+/**
+ * Check all markdown cross-links in a strict-tier (candidate/ or active/) SmartDoc.
+ *
+ * For each link whose href resolves into smartdocs/**, verifies the target exists.
+ * Missing targets are returned as SpecConflict entries with type "stale-assumption".
+ * Files from raw/ are never checked — pass isRaw=true or detect via filePath.
+ *
+ * @param filePath - Absolute path to the source document
+ * @param content  - File content (already read by caller)
+ * @param repoRoot - Repository root directory
+ * @returns Array of stale-assumption conflicts for every broken smartdocs/ link
+ */
+function checkSmartDocsLinks(filePath, content, repoRoot) {
+    if (!isStrictTier(filePath, repoRoot))
+        return [];
+    const conflicts = [];
+    const re = new RegExp(MD_LINK_RE.source, MD_LINK_RE.flags);
+    for (const match of content.matchAll(re)) {
+        const href = match[2];
+        if (!href)
+            continue;
+        const target = resolveSmartDocsLink(href, filePath, repoRoot);
+        if (target === null)
+            continue; // not a smartdocs/ link — skip
+        if (!(0, node_fs_1.existsSync)(target)) {
+            conflicts.push({
+                type: "stale-assumption",
+                conflictingFile: (0, node_path_1.relative)((0, node_path_1.resolve)(repoRoot), (0, node_path_1.resolve)(filePath)).replace(/\\/g, "/"),
+                detail: `broken link: "${href}" → target not found: ${(0, node_path_1.relative)((0, node_path_1.resolve)(repoRoot), target).replace(/\\/g, "/")}`,
+            });
+        }
+    }
+    return conflicts;
+}
 /**
  * Promotes a spec file from smartdocs/raw/ into smartdocs/specs/active/.
  *
@@ -529,6 +758,8 @@ function specPromote(path, options) {
         approved: options.approve ?? false,
         timestamp: new Date().toISOString(),
     });
+    const reason = options.reason ?? `${(0, node_path_1.basename)(destination)} promoted to specs/active/`;
+    logDirectoryChange((0, node_path_1.dirname)(destination), "Promote", reason);
     return { source, destination, runId, lifecyclePath, conflicts, halted: false, report };
 }
 /**

package/dist/smartdocs-engine/index.js

@@ -15,6 +15,29 @@ const audit_js_1 = require("./audit.js");
 const triage_js_1 = require("./triage.js");
 const adapter_js_1 = require("../graph/store/adapter.js");
 const index_js_1 = require("../graph/query/index.js");
+/**
+ * Prints the shared written/skipped-exists/skipped-draft report and summary line used by
+ * every `seed-*-all` command (seed-index, seed-instructions, seed-summary, reformat-okf).
+ *
+ * @param filename - The generated filename (e.g. "index.md") to report against each directory.
+ * @param dryRun - Whether this was a dry-run pass (controls the "would write" vs "written" label).
+ * @param result - The written/skippedExists/skippedDraft arrays from a seed-*-all call.
+ * @param options.leadingBlankLine - Whether to prefix the summary line with a blank line (default true).
+ * @param options.extraSummary - Extra summary text appended after "skipped (draft)" (e.g. root/ineligible counts).
+ */
+function printSeedAllResult(filename, dryRun, { written, skippedExists, skippedDraft }, options = {}) {
+    const { leadingBlankLine = true, extraSummary = "" } = options;
+    for (const dir of written) {
+        console.log(`${dryRun ? "[dry-run] would write" : "written"}: ${dir}/${filename}`);
+    }
+    for (const dir of skippedExists) {
+        console.log(`skipped (human-edited): ${dir}/${filename}`);
+    }
+    for (const dir of skippedDraft) {
+        console.log(`skipped (draft exists): ${dir}/${filename}`);
+    }
+    console.log(`${leadingBlankLine ? "\n" : ""}Done. ${written.length} written, ${skippedExists.length} skipped (exists), ${skippedDraft.length} skipped (draft)${extraSummary}.`);
+}
 /**
  * Build and return the top-level "docs" Commander command group for Polaris docs lifecycle workflows.
  *
@@ -283,15 +306,6 @@ function createDocsCommand(options = {}) {
                 includeHidden: options.includeHidden,
                 includeRoot: options.includeRoot,
             });
-            for (const dir of written) {
-                console.log(`${options.dryRun ? "[dry-run] would write" : "written"}: ${dir}/POLARIS.md`);
-            }
-            for (const dir of skippedExists) {
-                console.log(`skipped (human-edited): ${dir}/POLARIS.md`);
-            }
-            for (const dir of skippedDraft) {
-                console.log(`skipped (draft exists): ${dir}/POLARIS.md`);
-            }
             if (options.dryRun) {
                 if (skippedRoot) {
                     console.log(`\nSkipped (root):`);
@@ -315,7 +329,7 @@ function createDocsCommand(options = {}) {
                 }
             }
             const rootCount = skippedRoot ? 1 : 0;
-            console.log(`\nDone. ${written.length} written, ${skippedExists.length} skipped (exists), ${skippedDraft.length} skipped (draft), ${rootCount} skipped (root), ${skippedIneligible.length} skipped (ineligible).`);
+            printSeedAllResult("POLARIS.md", options.dryRun, { written, skippedExists, skippedDraft }, { extraSummary: `, ${rootCount} skipped (root), ${skippedIneligible.length} skipped (ineligible)` });
             return;
         }
         if (!pathArg) {
@@ -351,15 +365,6 @@ function createDocsCommand(options = {}) {
                 includeHidden: options.includeHidden,
                 includeRoot: options.includeRoot,
             });
-            for (const dir of written) {
-                console.log(`${options.dryRun ? "[dry-run] would write" : "written"}: ${dir}/SUMMARY.md`);
-            }
-            for (const dir of skippedExists) {
-                console.log(`skipped (human-edited): ${dir}/SUMMARY.md`);
-            }
-            for (const dir of skippedDraft) {
-                console.log(`skipped (draft exists): ${dir}/SUMMARY.md`);
-            }
             if (options.dryRun) {
                 if (skippedRoot) {
                     console.log(`\nSkipped (root):`);
@@ -383,7 +388,7 @@ function createDocsCommand(options = {}) {
                 }
             }
             const rootCount = skippedRoot ? 1 : 0;
-            console.log(`\nDone. ${written.length} written, ${skippedExists.length} skipped (exists), ${skippedDraft.length} skipped (draft), ${rootCount} skipped (root), ${skippedIneligible.length} skipped (ineligible).`);
+            printSeedAllResult("SUMMARY.md", options.dryRun, { written, skippedExists, skippedDraft }, { extraSummary: `, ${rootCount} skipped (root), ${skippedIneligible.length} skipped (ineligible)` });
             return;
         }
         if (!pathArg) {
@@ -402,6 +407,77 @@ function createDocsCommand(options = {}) {
             console.log(`skipped (draft exists): ${pathArg}/SUMMARY.md`);
         }
     });
+    docs
+        .command("seed-index [path]")
+        .description("Generate OKF-conformant index.md files for smartdocs/")
+        .option("-r, --repo-root <path>", "Repository root", defaultRepoRoot)
+        .option("--all", "Generate index.md for all smartdocs directories lacking one")
+        .option("--dry-run", "Print what would be written without writing files")
+        .action((pathArg, options) => {
+        if (options.all) {
+            const { written, skippedExists, skippedDraft, } = (0, seed_instructions_js_1.seedIndexAll)(options.repoRoot, {
+                dryRun: options.dryRun,
+            });
+            printSeedAllResult("index.md", options.dryRun, { written, skippedExists, skippedDraft });
+            return;
+        }
+        const targetPath = pathArg || "smartdocs";
+        const result = (0, seed_instructions_js_1.seedIndex)(targetPath, options.repoRoot, { dryRun: options.dryRun });
+        if (result === "written") {
+            const label = options.dryRun ? "[dry-run] would write" : "written";
+            console.log(`${label}: ${targetPath}/index.md`);
+        }
+        else if (result === "skipped-exists") {
+            console.warn(`warning: ${targetPath}/index.md already exists (no draft marker) — skipped`);
+        }
+        else {
+            console.log(`skipped (draft exists): ${targetPath}/index.md`);
+        }
+    });
+    docs
+        .command("reformat-okf")
+        .description("Migrate existing smartdocs to OKF structure in one step: runs migrate → seed-index --all → seed-instructions --all. " +
+        "Agent instruction files (CLAUDE.md, AGENTS.md, etc.) are never touched. " +
+        "Use --dry-run to preview changes before writing.")
+        .option("--dry-run", "Preview what would change without writing any files")
+        .option("-r, --repo-root <path>", "Repository root", defaultRepoRoot)
+        .action((options) => {
+        const dryRun = options.dryRun;
+        const repoRoot = options.repoRoot;
+        const label = dryRun ? "[dry-run]" : "";
+        // Step 1: migrate (moves scattered markdown to smartdocs/raw/)
+        console.log(`${label ? label + " " : ""}Step 1/3: migrate`);
+        try {
+            const migrateResult = (0, migrate_js_1.migrateDocs)({ repoRoot, dryRun });
+            (0, migrate_js_1.printMigrateResults)(migrateResult);
+        }
+        catch (err) {
+            console.error(`reformat-okf: migrate failed — ${err instanceof Error ? err.message : String(err)}`);
+            process.exit(1);
+        }
+        // Step 2: seed-index --all (ensures index.md with okf_version frontmatter in every smartdocs dir)
+        console.log(`\n${label ? label + " " : ""}Step 2/3: seed-index --all`);
+        try {
+            const { written, skippedExists, skippedDraft } = (0, seed_instructions_js_1.seedIndexAll)(repoRoot, { dryRun });
+            printSeedAllResult("index.md", dryRun, { written, skippedExists, skippedDraft }, { leadingBlankLine: false });
+        }
+        catch (err) {
+            console.error(`reformat-okf: seed-index failed — ${err instanceof Error ? err.message : String(err)}`);
+            process.exit(1);
+        }
+        // Step 3: seed-instructions --all (ensures POLARIS.md drafts; never touches CLAUDE.md/AGENTS.md)
+        console.log(`\n${label ? label + " " : ""}Step 3/3: seed-instructions --all`);
+        try {
+            const { written, skippedExists, skippedDraft, skippedIneligible, skippedRoot } = (0, seed_instructions_js_1.seedInstructionsAll)(repoRoot, { dryRun });
+            const rootCount = skippedRoot ? 1 : 0;
+            printSeedAllResult("POLARIS.md", dryRun, { written, skippedExists, skippedDraft }, { leadingBlankLine: false, extraSummary: `, ${rootCount} skipped (root), ${skippedIneligible.length} skipped (ineligible)` });
+        }
+        catch (err) {
+            console.error(`reformat-okf: seed-instructions failed — ${err instanceof Error ? err.message : String(err)}`);
+            process.exit(1);
+        }
+        console.log(`\nreformat-okf complete.${dryRun ? " (dry-run — no files written)" : ""}`);
+    });
     docs
         .command("audit")
         .description("Scan repo for files at risk of recursive ingestion")
@@ -464,9 +540,10 @@ function createDoctrineCommand() {
         .description("Move a doc from smartdocs/raw/ or smartdocs/doctrine/raw/ to docs/doctrine/candidate/")
         .option("-r, --repo-root <path>", "Repository root", process.cwd())
         .option("--run-id <id>", "Override the generated doctrine run ID")
+        .option("--reason <text>", "Reason for this draft")
         .action((path, options) => {
         try {
-            const result = (0, doctrine_js_1.doctrineDraft)(path, { repoRoot: options.repoRoot, runId: options.runId });
+            const result = (0, doctrine_js_1.doctrineDraft)(path, { repoRoot: options.repoRoot, runId: options.runId, reason: options.reason });
             console.log(`drafted: ${result.destination}`);
             console.log(`provenance: ${result.lifecyclePath}`);
         }
@@ -480,11 +557,13 @@ function createDoctrineCommand() {
         .description("Move a doc from smartdocs/doctrine/candidate/ to smartdocs/doctrine/active/")
         .option("-r, --repo-root <path>", "Repository root", process.cwd())
         .option("--run-id <id>", "Override the generated doctrine run ID")
+        .option("--reason <text>", "Reason for this promotion")
         .action((path, options) => {
         try {
             const result = (0, doctrine_js_1.doctrinePromote)(path, {
                 repoRoot: options.repoRoot,
-                runId: options.runId
+                runId: options.runId,
+                reason: options.reason,
             });
             console.log(`promoted: ${result.destination}`);
             console.log(`provenance: ${result.lifecyclePath}`);
@@ -499,11 +578,13 @@ function createDoctrineCommand() {
         .description("Move a doc from smartdocs/doctrine/active/ to smartdocs/doctrine/deprecated/")
         .option("-r, --repo-root <path>", "Repository root", process.cwd())
         .option("--run-id <id>", "Override the generated doctrine run ID")
+        .option("--reason <text>", "Reason for this deprecation")
         .action((path, options) => {
         try {
             const result = (0, doctrine_js_1.doctrineDeprecate)(path, {
                 repoRoot: options.repoRoot,
                 runId: options.runId,
+                reason: options.reason,
             });
             console.log(`deprecated: ${result.destination}`);
             console.log(`provenance: ${result.lifecyclePath}`);
@@ -519,12 +600,14 @@ function createDoctrineCommand() {
         .option("-r, --repo-root <path>", "Repository root", process.cwd())
         .option("--run-id <id>", "Override the generated run ID")
         .option("--approve", "Proceed despite detected conflicts")
+        .option("--reason <text>", "Reason for this promotion")
         .action((path, options) => {
         try {
             const result = (0, doctrine_js_1.specPromote)(path, {
                 repoRoot: options.repoRoot,
                 runId: options.runId,
                 approve: options.approve,
+                reason: options.reason,
             });
             console.log(result.report);
             if (result.halted) {