@lumenflow/core 1.0.0 → 1.3.2

package/dist/spec-branch-helpers.d.ts

@@ -0,0 +1,118 @@
+/**
+ * Spec Branch Helpers
+ *
+ * WU-1062: External plan storage and no-main-write mode
+ *
+ * Provides helpers for working with spec branches (spec/wu-XXXX).
+ * wu:create writes to spec branches by default; wu:claim merges them to main.
+ *
+ * @module
+ */
+import type { SimpleGit } from 'simple-git';
+/**
+ * Spec branch prefix
+ */
+export declare const SPEC_BRANCH_PREFIX = "spec/";
+/**
+ * WU source location constants
+ */
+export declare const WU_SOURCE: {
+    /** WU exists on main branch only */
+    readonly MAIN: "main";
+    /** WU exists on spec branch only */
+    readonly SPEC_BRANCH: "spec_branch";
+    /** WU exists on both main and spec branch */
+    readonly BOTH: "both";
+    /** WU not found anywhere */
+    readonly NOT_FOUND: "not_found";
+};
+export type WUSourceType = (typeof WU_SOURCE)[keyof typeof WU_SOURCE];
+/**
+ * Get the spec branch name for a WU
+ *
+ * @param {string} wuId - Work Unit ID (e.g., 'WU-1062')
+ * @returns {string} Spec branch name (e.g., 'spec/wu-1062')
+ *
+ * @example
+ * getSpecBranchName('WU-1062') // 'spec/wu-1062'
+ */
+export declare function getSpecBranchName(wuId: string): string;
+/**
+ * Get the origin-qualified spec branch name
+ *
+ * @param {string} wuId - Work Unit ID
+ * @returns {string} Origin-qualified branch name (e.g., 'origin/spec/wu-1062')
+ */
+export declare function getOriginSpecBranch(wuId: string): string;
+/**
+ * Check if a spec branch exists on origin
+ *
+ * @param {string} wuId - Work Unit ID
+ * @param {SimpleGit} git - Git adapter instance
+ * @returns {Promise<boolean>} True if spec branch exists
+ *
+ * @example
+ * const exists = await specBranchExists('WU-1062', git);
+ */
+export declare function specBranchExists(wuId: string, git: SimpleGit): Promise<boolean>;
+/**
+ * Check if a WU exists on main branch
+ *
+ * @param {string} wuId - Work Unit ID
+ * @param {SimpleGit} git - Git adapter instance
+ * @returns {Promise<boolean>} True if WU YAML exists on main
+ */
+export declare function isWUOnMain(wuId: string, git: SimpleGit): Promise<boolean>;
+/**
+ * Merge spec branch to main branch (fast-forward only)
+ *
+ * This is used by wu:claim when a WU exists only on a spec branch.
+ * The spec branch is merged to main before creating the worktree.
+ *
+ * @param {string} wuId - Work Unit ID
+ * @param {SimpleGit} git - Git adapter instance
+ * @throws {Error} If merge fails (e.g., due to conflicts)
+ *
+ * @example
+ * await mergeSpecBranchToMain('WU-1062', git);
+ */
+export declare function mergeSpecBranchToMain(wuId: string, git: SimpleGit): Promise<void>;
+/**
+ * Delete spec branch after merge
+ *
+ * @param {string} wuId - Work Unit ID
+ * @param {SimpleGit} git - Git adapter instance
+ */
+export declare function deleteSpecBranch(wuId: string, git: SimpleGit): Promise<void>;
+/**
+ * Determine the source of a WU (main, spec branch, both, or not found)
+ *
+ * Used by wu:claim to decide whether to merge spec branch before creating worktree.
+ *
+ * @param {string} wuId - Work Unit ID
+ * @param {SimpleGit} git - Git adapter instance
+ * @returns {Promise<WUSourceType>} Source location constant
+ *
+ * @example
+ * const source = await getWUSource('WU-1062', git);
+ * if (source === WU_SOURCE.SPEC_BRANCH) {
+ *   await mergeSpecBranchToMain('WU-1062', git);
+ * }
+ */
+export declare function getWUSource(wuId: string, git: SimpleGit): Promise<WUSourceType>;
+/**
+ * Create a spec branch from current HEAD
+ *
+ * Used by wu:create in default mode (no --direct flag).
+ *
+ * @param {string} wuId - Work Unit ID
+ * @param {SimpleGit} git - Git adapter instance
+ */
+export declare function createSpecBranch(wuId: string, git: SimpleGit): Promise<void>;
+/**
+ * Push spec branch to origin
+ *
+ * @param {string} wuId - Work Unit ID
+ * @param {SimpleGit} git - Git adapter instance
+ */
+export declare function pushSpecBranch(wuId: string, git: SimpleGit): Promise<void>;

package/dist/spec-branch-helpers.js

@@ -0,0 +1,192 @@
+/**
+ * Spec Branch Helpers
+ *
+ * WU-1062: External plan storage and no-main-write mode
+ *
+ * Provides helpers for working with spec branches (spec/wu-XXXX).
+ * wu:create writes to spec branches by default; wu:claim merges them to main.
+ *
+ * @module
+ */
+import { WU_PATHS } from './wu-paths.js';
+/**
+ * Spec branch prefix
+ */
+export const SPEC_BRANCH_PREFIX = 'spec/';
+/**
+ * WU source location constants
+ */
+export const WU_SOURCE = {
+    /** WU exists on main branch only */
+    MAIN: 'main',
+    /** WU exists on spec branch only */
+    SPEC_BRANCH: 'spec_branch',
+    /** WU exists on both main and spec branch */
+    BOTH: 'both',
+    /** WU not found anywhere */
+    NOT_FOUND: 'not_found',
+};
+/**
+ * Get the spec branch name for a WU
+ *
+ * @param {string} wuId - Work Unit ID (e.g., 'WU-1062')
+ * @returns {string} Spec branch name (e.g., 'spec/wu-1062')
+ *
+ * @example
+ * getSpecBranchName('WU-1062') // 'spec/wu-1062'
+ */
+export function getSpecBranchName(wuId) {
+    return `${SPEC_BRANCH_PREFIX}${wuId.toLowerCase()}`;
+}
+/**
+ * Get the origin-qualified spec branch name
+ *
+ * @param {string} wuId - Work Unit ID
+ * @returns {string} Origin-qualified branch name (e.g., 'origin/spec/wu-1062')
+ */
+export function getOriginSpecBranch(wuId) {
+    return `origin/${getSpecBranchName(wuId)}`;
+}
+/**
+ * Check if a spec branch exists on origin
+ *
+ * @param {string} wuId - Work Unit ID
+ * @param {SimpleGit} git - Git adapter instance
+ * @returns {Promise<boolean>} True if spec branch exists
+ *
+ * @example
+ * const exists = await specBranchExists('WU-1062', git);
+ */
+export async function specBranchExists(wuId, git) {
+    try {
+        const originBranch = getOriginSpecBranch(wuId);
+        // Use branchExists if available, otherwise check with ls-remote
+        if ('branchExists' in git && typeof git.branchExists === 'function') {
+            return await git.branchExists(originBranch);
+        }
+        // Fallback: use ls-remote to check if branch exists
+        const result = await git.raw(['ls-remote', '--heads', 'origin', getSpecBranchName(wuId)]);
+        return result.trim().length > 0;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if a WU exists on main branch
+ *
+ * @param {string} wuId - Work Unit ID
+ * @param {SimpleGit} git - Git adapter instance
+ * @returns {Promise<boolean>} True if WU YAML exists on main
+ */
+export async function isWUOnMain(wuId, git) {
+    try {
+        const wuPath = WU_PATHS.WU(wuId);
+        // Check if file exists on origin/main
+        await git.raw(['ls-tree', 'origin/main', '--', wuPath]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Merge spec branch to main branch (fast-forward only)
+ *
+ * This is used by wu:claim when a WU exists only on a spec branch.
+ * The spec branch is merged to main before creating the worktree.
+ *
+ * @param {string} wuId - Work Unit ID
+ * @param {SimpleGit} git - Git adapter instance
+ * @throws {Error} If merge fails (e.g., due to conflicts)
+ *
+ * @example
+ * await mergeSpecBranchToMain('WU-1062', git);
+ */
+export async function mergeSpecBranchToMain(wuId, git) {
+    const specBranch = getSpecBranchName(wuId);
+    const originSpecBranch = getOriginSpecBranch(wuId);
+    // Fetch the spec branch
+    await git.fetch('origin', specBranch);
+    // Merge with fast-forward only (safe merge)
+    await git.merge([originSpecBranch, '--ff-only']);
+}
+/**
+ * Delete spec branch after merge
+ *
+ * @param {string} wuId - Work Unit ID
+ * @param {SimpleGit} git - Git adapter instance
+ */
+export async function deleteSpecBranch(wuId, git) {
+    const specBranch = getSpecBranchName(wuId);
+    try {
+        // Delete local branch if exists
+        await git.branch(['-d', specBranch]);
+    }
+    catch {
+        // Ignore if local branch doesn't exist
+    }
+    try {
+        // Delete remote branch
+        await git.push(['origin', '--delete', specBranch]);
+    }
+    catch {
+        // Ignore if remote branch doesn't exist
+    }
+}
+/**
+ * Determine the source of a WU (main, spec branch, both, or not found)
+ *
+ * Used by wu:claim to decide whether to merge spec branch before creating worktree.
+ *
+ * @param {string} wuId - Work Unit ID
+ * @param {SimpleGit} git - Git adapter instance
+ * @returns {Promise<WUSourceType>} Source location constant
+ *
+ * @example
+ * const source = await getWUSource('WU-1062', git);
+ * if (source === WU_SOURCE.SPEC_BRANCH) {
+ *   await mergeSpecBranchToMain('WU-1062', git);
+ * }
+ */
+export async function getWUSource(wuId, git) {
+    // Check both locations in parallel for efficiency
+    const [onMain, hasSpecBranch] = await Promise.all([
+        isWUOnMain(wuId, git),
+        specBranchExists(wuId, git),
+    ]);
+    if (onMain && hasSpecBranch) {
+        return WU_SOURCE.BOTH;
+    }
+    if (onMain) {
+        return WU_SOURCE.MAIN;
+    }
+    if (hasSpecBranch) {
+        return WU_SOURCE.SPEC_BRANCH;
+    }
+    return WU_SOURCE.NOT_FOUND;
+}
+/**
+ * Create a spec branch from current HEAD
+ *
+ * Used by wu:create in default mode (no --direct flag).
+ *
+ * @param {string} wuId - Work Unit ID
+ * @param {SimpleGit} git - Git adapter instance
+ */
+export async function createSpecBranch(wuId, git) {
+    const specBranch = getSpecBranchName(wuId);
+    // Create local branch
+    await git.checkoutLocalBranch(specBranch);
+}
+/**
+ * Push spec branch to origin
+ *
+ * @param {string} wuId - Work Unit ID
+ * @param {SimpleGit} git - Git adapter instance
+ */
+export async function pushSpecBranch(wuId, git) {
+    const specBranch = getSpecBranchName(wuId);
+    // Push to origin
+    await git.push(['origin', specBranch]);
+}

package/dist/stamp-utils.d.ts

@@ -26,6 +26,16 @@ export declare const STAMP_FORMAT_ERRORS: Readonly<{
     /** WU ID in stamp does not match expected ID */
     WU_ID_MISMATCH: "WU_ID_MISMATCH";
 }>;
+/**
+ * Validate that a date string is a valid ISO date (YYYY-MM-DD)
+ *
+ * WU-1006: Uses date-fns parse() and isValid() instead of manual parseInt parsing
+ * Library-First principle: leverage well-known libraries over brittle custom code
+ *
+ * @param {string} dateStr - Date string in YYYY-MM-DD format
+ * @returns {boolean} True if date is valid
+ */
+export declare function isValidDateString(dateStr: string): boolean;
 /**
  * Create stamp file (idempotent - safe to call multiple times)
  *

package/dist/stamp-utils.js

@@ -14,6 +14,7 @@ import { existsSync, writeFileSync, mkdirSync } from 'node:fs';
 import { readFile, access } from 'node:fs/promises';
 import { constants } from 'node:fs';
 import path from 'node:path';
+import { parse, isValid } from 'date-fns';
 import { WU_PATHS } from './wu-paths.js';
 import { todayISO } from './date-utils.js';
 /**
@@ -34,34 +35,31 @@ export const STAMP_FORMAT_ERRORS = Object.freeze({
     WU_ID_MISMATCH: 'WU_ID_MISMATCH',
 });
 /**
- * Valid date regex: YYYY-MM-DD format
+ * Valid date regex: YYYY-MM-DD format (for format checking before parsing)
  * @type {RegExp}
  */
-const DATE_PATTERN = /^(\d{4})-(\d{2})-(\d{2})$/;
+const DATE_FORMAT_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
 /**
- * Validate that a date string is a valid ISO date
+ * Validate that a date string is a valid ISO date (YYYY-MM-DD)
+ *
+ * WU-1006: Uses date-fns parse() and isValid() instead of manual parseInt parsing
+ * Library-First principle: leverage well-known libraries over brittle custom code
+ *
  * @param {string} dateStr - Date string in YYYY-MM-DD format
  * @returns {boolean} True if date is valid
  */
-function isValidDate(dateStr) {
-    const match = dateStr.match(DATE_PATTERN);
-    if (!match) {
-        return false;
-    }
-    const year = parseInt(match[1], 10);
-    const month = parseInt(match[2], 10);
-    const day = parseInt(match[3], 10);
-    // Basic validation
-    if (month < 1 || month > 12) {
-        return false;
-    }
-    // Check day validity for the month
-    const daysInMonth = new Date(year, month, 0).getDate();
-    if (day < 1 || day > daysInMonth) {
+export function isValidDateString(dateStr) {
+    // Quick format check - must be YYYY-MM-DD pattern
+    if (!dateStr || !DATE_FORMAT_PATTERN.test(dateStr)) {
         return false;
     }
-    return true;
+    // Parse with date-fns and validate the result
+    // parse() with strict format ensures proper date validation
+    const parsed = parse(dateStr, 'yyyy-MM-dd', new Date());
+    return isValid(parsed);
 }
+// Internal alias for backward compatibility
+const isValidDate = isValidDateString;
 /**
  * Stamp file body template (eliminates magic string)
  * Single source of truth for stamp format

package/dist/token-counter.js

@@ -9,7 +9,7 @@
 import { get_encoding } from 'tiktoken';
 import { readFileSync } from 'fs';
 import { createHash } from 'crypto';
-import { load as loadYAML } from 'js-yaml';
+import { parseYAML } from './wu-yaml.js';
 import { createError, ErrorCodes } from './error-handler.js';
 import { EXIT_CODES, STRING_LITERALS } from './wu-constants.js';
 // Cache tokenizer instance (expensive to create)
@@ -65,7 +65,7 @@ export function loadPrompt(promptPath) {
     try {
         const raw = readFileSync(promptPath, { encoding: 'utf-8' });
         // Parse YAML to access prompt structure
-        const parsed = loadYAML(raw);
+        const parsed = parseYAML(raw);
         // Extract prompt text (handle different YAML structures)
         let promptText = '';
         if (typeof parsed === 'string') {

package/dist/wu-consistency-checker.d.ts

@@ -30,6 +30,7 @@ export declare function checkWUConsistency(id: any, projectRoot?: string): Promi
         backlogInProgress?: undefined;
         statusInProgress?: undefined;
         hasWorktree?: undefined;
+        worktreePathExists?: undefined;
     };
 } | {
     valid: boolean;
@@ -41,6 +42,7 @@ export declare function checkWUConsistency(id: any, projectRoot?: string): Promi
         backlogInProgress: boolean;
         statusInProgress: boolean;
         hasWorktree: boolean;
+        worktreePathExists: boolean;
         wuExists?: undefined;
     };
 }>;

package/dist/wu-consistency-checker.js

@@ -15,9 +15,9 @@
 import { readFile, writeFile, readdir, mkdir, access } from 'node:fs/promises';
 import { constants } from 'node:fs';
 import path from 'node:path';
-import yaml from 'js-yaml';
+import { parseYAML, stringifyYAML } from './wu-yaml.js';
 import { WU_PATHS } from './wu-paths.js';
-import { CONSISTENCY_TYPES, LOG_PREFIX, REMOTES, STRING_LITERALS, toKebab, WU_STATUS, YAML_OPTIONS, } from './wu-constants.js';
+import { CONSISTENCY_TYPES, CONSISTENCY_MESSAGES, LOG_PREFIX, REMOTES, STRING_LITERALS, toKebab, WU_STATUS, YAML_OPTIONS, } from './wu-constants.js';
 import { todayISO } from './date-utils.js';
 import { createGitForPath } from './git-adapter.js';
 /**
@@ -41,10 +41,11 @@ export async function checkWUConsistency(id, projectRoot = process.cwd()) {
         return { valid: true, errors: [], stats: { wuExists: false } };
     }
     const wuContent = await readFile(wuPath, { encoding: 'utf-8' });
-    const wuDoc = yaml.load(wuContent);
+    const wuDoc = parseYAML(wuContent);
     const yamlStatus = wuDoc?.status || 'unknown';
     const lane = wuDoc?.lane || '';
     const title = wuDoc?.title || '';
+    const worktreePathFromYaml = wuDoc?.worktree_path || '';
     // Check stamp existence
     let hasStamp = false;
     try {
@@ -74,6 +75,7 @@ export async function checkWUConsistency(id, projectRoot = process.cwd()) {
     const { inProgress: statusInProgress } = parseStatusSections(statusContent, id);
     // Check for worktree
     const hasWorktree = await checkWorktreeExists(id, projectRoot);
+    const worktreePathExists = await checkWorktreePathExists(worktreePathFromYaml);
     // Detection logic
     // 1. YAML done but in status.md In Progress
     if (yamlStatus === WU_STATUS.DONE && statusInProgress) {
@@ -129,6 +131,19 @@ export async function checkWUConsistency(id, projectRoot = process.cwd()) {
             canAutoRepair: true,
         });
     }
+    // 6. Claimed WU missing worktree directory
+    if (worktreePathFromYaml &&
+        !worktreePathExists &&
+        (yamlStatus === WU_STATUS.IN_PROGRESS || yamlStatus === WU_STATUS.BLOCKED)) {
+        errors.push({
+            type: CONSISTENCY_TYPES.MISSING_WORKTREE_CLAIMED,
+            wuId: id,
+            title,
+            description: CONSISTENCY_MESSAGES.MISSING_WORKTREE_CLAIMED(id, yamlStatus, worktreePathFromYaml),
+            repairAction: CONSISTENCY_MESSAGES.MISSING_WORKTREE_CLAIMED_REPAIR,
+            canAutoRepair: false,
+        });
+    }
     return {
         valid: errors.length === 0,
         errors,
@@ -139,6 +154,7 @@ export async function checkWUConsistency(id, projectRoot = process.cwd()) {
             backlogInProgress,
             statusInProgress,
             hasWorktree,
+            worktreePathExists,
         },
     };
 }
@@ -202,7 +218,7 @@ export async function checkLaneForOrphanDoneWU(lane, excludeId, projectRoot = pr
         }
         let wuDoc;
         try {
-            wuDoc = yaml.load(wuContent);
+            wuDoc = parseYAML(wuContent);
         }
         catch {
             // Skip malformed YAML files - they're a separate issue
@@ -341,7 +357,7 @@ async function updateYamlToDone(id, projectRoot) {
     const wuPath = path.join(projectRoot, WU_PATHS.WU(id));
     // Read current YAML
     const content = await readFile(wuPath, { encoding: 'utf-8' });
-    const wuDoc = yaml.load(content);
+    const wuDoc = parseYAML(content);
     if (!wuDoc) {
         throw new Error(`Failed to parse WU YAML: ${wuPath}`);
     }
@@ -353,7 +369,7 @@ async function updateYamlToDone(id, projectRoot) {
         wuDoc.completed = todayISO();
     }
     // Write updated YAML
-    const updatedContent = yaml.dump(wuDoc, { lineWidth: YAML_OPTIONS.LINE_WIDTH });
+    const updatedContent = stringifyYAML(wuDoc, { lineWidth: YAML_OPTIONS.LINE_WIDTH });
     await writeFile(wuPath, updatedContent, { encoding: 'utf-8' });
 }
 /**
@@ -565,3 +581,21 @@ async function checkWorktreeExists(id, projectRoot) {
         return false;
     }
 }
+/**
+ * Check whether a worktree path exists on disk
+ *
+ * @param {string} worktreePath - Worktree path from WU YAML
+ * @returns {Promise<boolean>} True if path exists
+ */
+async function checkWorktreePathExists(worktreePath) {
+    if (!worktreePath) {
+        return false;
+    }
+    try {
+        await access(worktreePath, constants.R_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/wu-constants.d.ts

@@ -40,6 +40,10 @@ export declare const GIT_REFS: {
     ORIGIN_MAIN: string;
     /** Current HEAD ref */
     HEAD: string;
+    /** Upstream ref */
+    UPSTREAM: string;
+    /** Range of upstream..HEAD */
+    UPSTREAM_RANGE: string;
     /** Fetch head ref */
     FETCH_HEAD: string;
 };
@@ -258,6 +262,22 @@ export declare const CONSISTENCY_TYPES: {
     ORPHAN_WORKTREE_DONE: string;
     /** Stamp file exists but WU YAML status is not 'done' (partial wu:done failure) */
     STAMP_EXISTS_YAML_NOT_DONE: string;
+    /** WU is claimed but its worktree directory is missing */
+    MISSING_WORKTREE_CLAIMED: string;
+};
+/**
+ * Consistency check messages
+ */
+export declare const CONSISTENCY_MESSAGES: {
+    MISSING_WORKTREE_CLAIMED: (id: any, status: any, worktreePath: any) => string;
+    MISSING_WORKTREE_CLAIMED_REPAIR: string;
+};
+/**
+ * Worktree warning messages
+ */
+export declare const WORKTREE_WARNINGS: {
+    MISSING_TRACKED_HEADER: string;
+    MISSING_TRACKED_LINE: (worktreePath: any) => string;
 };
 /**
  * File system constants
@@ -270,6 +290,23 @@ export declare const FILE_SYSTEM: {
     /** UTF-8 encoding (alias for compatibility) */
     UTF8: string;
 };
+/**
+ * Build artifact cleanup globs
+ *
+ * Centralized glob patterns for worktree artifact cleanup.
+ */
+export declare const BUILD_ARTIFACT_GLOBS: {
+    /** Common dist directories inside worktrees */
+    DIST_DIRS: string[];
+    /** TypeScript build info files */
+    TSBUILDINFO_FILES: string[];
+};
+/**
+ * Build artifact cleanup ignore patterns
+ *
+ * Centralized ignore globs for artifact cleanup.
+ */
+export declare const BUILD_ARTIFACT_IGNORES: string[];
 /**
  * Process stdio constants
  *
@@ -352,12 +389,12 @@ export declare const DEFAULTS: {
  * YAML serialization options
  *
  * Centralized from duplicated { lineWidth: 100 } across wu-* scripts (WU-1256).
- * Use with js-yaml dump() function.
+ * Use with yaml stringify() options.
  */
 export declare const YAML_OPTIONS: {
     /** Standard line width for YAML dump (100 chars) */
     LINE_WIDTH: number;
-    /** No line wrapping (-1 disables wrapping in js-yaml) */
+    /** No line wrapping (-1 disables wrapping) */
     NO_WRAP: number;
 };
 /**
@@ -387,6 +424,59 @@ export declare const BOX: {
     /** Side border for content lines */
     SIDE: string;
 };
+/**
+ * Cleanup guard constants
+ */
+export declare const CLEANUP_GUARD: {
+    REASONS: {
+        UNCOMMITTED_CHANGES: string;
+        UNPUSHED_COMMITS: string;
+        STATUS_NOT_DONE: string;
+        MISSING_STAMP: string;
+        PR_NOT_MERGED: string;
+    };
+    TITLES: {
+        BLOCKED: string;
+        NEXT_STEPS: string;
+    };
+    MESSAGES: {
+        UNCOMMITTED_CHANGES: string;
+        UNPUSHED_COMMITS: string;
+        STATUS_NOT_DONE: string;
+        MISSING_STAMP: string;
+        PR_NOT_MERGED: string;
+    };
+    NEXT_STEPS: {
+        DEFAULT: {
+            text: string;
+            appendId: boolean;
+        }[];
+        UNCOMMITTED_CHANGES: {
+            text: string;
+            appendId: boolean;
+        }[];
+        UNPUSHED_COMMITS: {
+            text: string;
+            appendId: boolean;
+        }[];
+        STATUS_NOT_DONE: {
+            text: string;
+            appendId: boolean;
+        }[];
+        MISSING_STAMP: {
+            text: string;
+            appendId: boolean;
+        }[];
+        PR_NOT_MERGED: {
+            text: string;
+            appendId: boolean;
+        }[];
+    };
+    PR_CHECK: {
+        START: string;
+        RESULT: string;
+    };
+};
 /**
  * Git display constants
  *
@@ -454,6 +544,8 @@ export declare const GIT_FLAGS: {
     NO_VERIFY: string;
     /** No GPG sign flag (skip commit signing) */
     NO_GPG_SIGN: string;
+    /** One-line log format */
+    ONELINE: string;
 };
 /**
  * Git commands
@@ -470,6 +562,8 @@ export declare const GIT_COMMANDS: {
     LS_TREE: string;
     /** Git diff command */
     DIFF: string;
+    /** Git log command */
+    LOG: string;
     /** Git merge-base command */
     MERGE_BASE: string;
     /** Git rev-parse command */
@@ -918,7 +1012,6 @@ export declare const ESLINT_DEFAULTS: {
      *
      * WU-1866: Temporarily increased from 0 to 100 to unblock gates.
      * There are ~82 pre-existing warnings that need proper fixes.
-     * TODO: Create follow-up WU to fix warnings and restore zero-warnings policy.
      */
     MAX_WARNINGS: string;
 };
@@ -997,6 +1090,8 @@ export declare const GITLEAKS_ARGS: {
 export declare const PRETTIER_ARGS: {
     /** Check formatting without writing */
     CHECK: string;
+    /** List files with formatting differences */
+    LIST_DIFFERENT: string;
 };
 /**
  * Audit command arguments