@lumenflow/cli 3.22.0 → 4.0.1

package/dist/chunk-EK2AKZKD.js

@@ -1,55 +0,0 @@
-// src/wu-lifecycle-sync/constants.ts
-var WU_LIFECYCLE_COMMANDS = {
-  CREATE: "wu:create",
-  CLAIM: "wu:claim",
-  DONE: "wu:done"
-};
-var WU_LIFECYCLE_EVENT_KINDS = {
-  CREATE: "task_created",
-  CLAIM: "task_claimed",
-  DONE: "task_completed"
-};
-var WU_LIFECYCLE_SYNC_SKIPPED_REASONS = {
-  WORKSPACE_CONFIG_MISSING: "workspace-config-missing",
-  WORKSPACE_CONFIG_INVALID: "workspace-config-invalid",
-  WORKSPACE_ID_MISSING: "workspace-id-missing",
-  CONTROL_PLANE_NOT_CONFIGURED: "control-plane-not-configured",
-  CONTROL_PLANE_INVALID: "control-plane-invalid",
-  CONTROL_PLANE_SDK_UNAVAILABLE: "control-plane-sdk-unavailable",
-  MISSING_TOKEN_ENV: "missing-token-env",
-  NO_EVENTS: "no-events",
-  NO_EVENTS_ACCEPTED: "no-events-accepted",
-  PUSH_FAILED: "push-failed"
-};
-var WU_LIFECYCLE_SYNC_RESULT_DEFAULTS = {
-  SENT: false,
-  ACCEPTED: 0
-};
-var WU_LIFECYCLE_SYNC_CONFIG = {
-  CONTROL_PLANE_FIELD: "control_plane",
-  WORKSPACE_ID_FIELD: "id",
-  TEXT_ENCODING_UTF8: "utf-8"
-};
-var WU_LIFECYCLE_SYNC_LOG_PREFIX = "[wu-lifecycle-sync]";
-var WU_LIFECYCLE_EVENT_SCHEMA_VERSION = 1;
-var WU_LIFECYCLE_CLAIM_DEFAULTS = {
-  ACTOR: "wu-claim-cli",
-  SESSION_ID: "wu-claim-session"
-};
-var WU_LIFECYCLE_SPEC_HASH = {
-  ALGORITHM: "sha256",
-  DIGEST_ENCODING: "hex",
-  HEX_256_REGEX: /^[a-f0-9]{64}$/
-};
-
-export {
-  WU_LIFECYCLE_COMMANDS,
-  WU_LIFECYCLE_EVENT_KINDS,
-  WU_LIFECYCLE_SYNC_SKIPPED_REASONS,
-  WU_LIFECYCLE_SYNC_RESULT_DEFAULTS,
-  WU_LIFECYCLE_SYNC_CONFIG,
-  WU_LIFECYCLE_SYNC_LOG_PREFIX,
-  WU_LIFECYCLE_EVENT_SCHEMA_VERSION,
-  WU_LIFECYCLE_CLAIM_DEFAULTS,
-  WU_LIFECYCLE_SPEC_HASH
-};

package/dist/chunk-ELD7JTTT.js

@@ -1,343 +0,0 @@
-import {
-  findInitiative,
-  getInitiativePhases,
-  getInitiativeProgress,
-  getInitiativeWUs
-} from "./chunk-MZ7RKIX4.js";
-import {
-  OUTPUT_FORMATS
-} from "./chunk-NAP6CFSO.js";
-import {
-  WU_OPTIONS,
-  createWUParser,
-  runCLI
-} from "./chunk-2GXVIN57.js";
-import {
-  WU_STATUS
-} from "./chunk-V6OJGLBA.js";
-import {
-  die
-} from "./chunk-RXRKBBSM.js";
-
-// src/initiative-status.ts
-function asString(value) {
-  return typeof value === "string" ? value : "";
-}
-function asStringArray(value) {
-  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
-}
-function normalizeLifecycleStatus(value) {
-  return typeof value === "string" ? value.trim().toLowerCase() : "";
-}
-function toInitiativePhases(doc) {
-  return Array.isArray(doc.phases) ? doc.phases : [];
-}
-function hasIncompletePhase(phases) {
-  if (!Array.isArray(phases) || phases.length === 0) {
-    return false;
-  }
-  return phases.some((phase) => {
-    if (phase == null || typeof phase !== "object") {
-      return true;
-    }
-    return normalizeLifecycleStatus(phase.status) !== WU_STATUS.DONE;
-  });
-}
-function hasAllLinkedWUsDone(progress) {
-  if (!progress) {
-    return false;
-  }
-  return progress.total > 0 && progress.done === progress.total;
-}
-function hasIncompleteLinkedWUs(progress) {
-  if (!progress) {
-    return false;
-  }
-  return progress.total > 0 && progress.done < progress.total;
-}
-function deriveInitiativeLifecycleStatus(status, phases, progress) {
-  const normalizedStatus = normalizeLifecycleStatus(status);
-  if (hasAllLinkedWUsDone(progress)) {
-    return WU_STATUS.DONE;
-  }
-  if (normalizedStatus === WU_STATUS.DONE && hasIncompletePhase(phases)) {
-    return WU_STATUS.IN_PROGRESS;
-  }
-  if (normalizedStatus === WU_STATUS.DONE && hasIncompleteLinkedWUs(progress)) {
-    return WU_STATUS.IN_PROGRESS;
-  }
-  return normalizedStatus || WU_STATUS.IN_PROGRESS;
-}
-function getWUBlockers(doc) {
-  const blockedBy = asStringArray(doc.blocked_by);
-  if (blockedBy.length > 0) {
-    return blockedBy;
-  }
-  return asStringArray(doc.dependencies);
-}
-function hasPhaseWUStatus(phaseWUs, status) {
-  return phaseWUs.some((wu) => normalizeLifecycleStatus(wu.doc.status) === status);
-}
-function areAllPhaseWUsDone(phaseWUs) {
-  return phaseWUs.length > 0 && phaseWUs.every((wu) => normalizeLifecycleStatus(wu.doc.status) === WU_STATUS.DONE);
-}
-function deriveInitiativePhaseStatus(status, phaseWUs) {
-  if (areAllPhaseWUsDone(phaseWUs)) {
-    return WU_STATUS.DONE;
-  }
-  if (hasPhaseWUStatus(phaseWUs, WU_STATUS.IN_PROGRESS)) {
-    return WU_STATUS.IN_PROGRESS;
-  }
-  if (hasPhaseWUStatus(phaseWUs, WU_STATUS.BLOCKED)) {
-    return WU_STATUS.BLOCKED;
-  }
-  if (hasPhaseWUStatus(phaseWUs, WU_STATUS.READY)) {
-    return WU_STATUS.READY;
-  }
-  return normalizeLifecycleStatus(status) || WU_STATUS.IN_PROGRESS;
-}
-function priorityRank(priority) {
-  const p = String(priority || "").toUpperCase();
-  const map = { P0: 0, P1: 1, P2: 2, P3: 3 };
-  return p in map ? map[p] : 9;
-}
-function isRunnableReady(wu, wuById) {
-  if (normalizeLifecycleStatus(wu.doc.status) !== WU_STATUS.READY) return false;
-  const blockers = getWUBlockers(wu.doc);
-  return blockers.every((blockerId) => {
-    const blocker = wuById.get(blockerId);
-    return !blocker || normalizeLifecycleStatus(blocker.doc.status) === WU_STATUS.DONE;
-  });
-}
-function renderDetailed(initiative, useColor) {
-  const { id, doc } = initiative;
-  const progress = getInitiativeProgress(id);
-  const wus = getInitiativeWUs(id);
-  const wuById = new Map(wus.map((wu) => [wu.id, wu]));
-  const phaseGroups = getInitiativePhases(id);
-  const phases = toInitiativePhases(doc);
-  const status = deriveInitiativeLifecycleStatus(doc.status, phases, progress);
-  const docTitle = asString(doc.title);
-  const rawStatus = asString(doc.status);
-  const normalizedRawStatus = normalizeLifecycleStatus(rawStatus);
-  console.log(`
-${id}: ${docTitle || "(untitled)"}`);
-  console.log(
-    `Status: ${status} | Progress: ${progress.percentage}% (${progress.done}/${progress.total} WUs)`
-  );
-  if (status !== normalizedRawStatus) {
-    console.log(
-      `Lifecycle mismatch: metadata status '${rawStatus}' is inconsistent with phase state; reporting '${status}'.`
-    );
-  }
-  console.log("\nStart here:");
-  console.log(
-    `  1) Plan waves (recommended): pnpm orchestrate:initiative --initiative ${id} --dry-run`
-  );
-  const runnableReady = wus.filter((wu) => isRunnableReady(wu, wuById)).sort((a, b) => {
-    const byPriority = priorityRank(a.doc.priority) - priorityRank(b.doc.priority);
-    if (byPriority !== 0) return byPriority;
-    return a.id.localeCompare(b.id);
-  });
-  if (runnableReady.length > 0) {
-    const next = runnableReady[0];
-    if (next) {
-      console.log(
-        `  2) Start next WU: pnpm wu:claim --id ${next.id} --lane "${asString(next.doc.lane)}"`
-      );
-      console.log(`     Then cd into the created worktree (shown by wu:claim output)`);
-    }
-  } else if (progress.inProgress > 0) {
-    console.log(
-      `  2) Continue: ${progress.inProgress} WU(s) already in progress (finish those first)`
-    );
-  } else if (progress.blocked > 0) {
-    console.log(`  2) Unblock: ${progress.blocked} WU(s) blocked (resolve blockers first)`);
-  } else {
-    console.log("  2) No runnable ready WUs found (check dependencies/blocked_by)");
-  }
-  const description = asString(doc.description);
-  if (description) {
-    console.log(`
-Description: ${description}`);
-  }
-  const owner = asString(doc.owner);
-  if (owner) {
-    console.log(`Owner: ${owner}`);
-  }
-  const targetDate = asString(doc.target_date);
-  if (targetDate) {
-    console.log(`Target: ${targetDate}`);
-  }
-  if (phases.length > 0) {
-    console.log("\nPhases:");
-    for (const phase of phases) {
-      const phaseWUs = phaseGroups.get(phase.id) || [];
-      const phaseStatus = formatStatus(
-        deriveInitiativePhaseStatus(phase.status, phaseWUs),
-        useColor
-      );
-      const phaseTitle = asString(phase.title) || `Phase ${phase.id}`;
-      console.log(
-        `  ${phase.id}. ${phaseTitle.padEnd(30)} [${phaseStatus}] ${phaseWUs.length} WUs`
-      );
-    }
-    const unassigned = phaseGroups.get(null) || [];
-    if (unassigned.length > 0) {
-      console.log(`  -. Unassigned                       ${unassigned.length} WUs`);
-    }
-  }
-  console.log("\nWork Units by Status:");
-  const byStatus = groupWUsByStatus(wus);
-  for (const [status2, statusWUs] of Object.entries(byStatus)) {
-    if (statusWUs.length > 0) {
-      console.log(`  ${capitalizeFirst(status2)} (${statusWUs.length}):`);
-      for (const wu of statusWUs.slice(0, 5)) {
-        console.log(`    - ${wu.id}: ${truncate(asString(wu.doc.title), 50)}`);
-      }
-      if (statusWUs.length > 5) {
-        console.log(`    ... and ${statusWUs.length - 5} more`);
-      }
-    }
-  }
-  const successMetrics = asStringArray(doc.success_metrics);
-  if (successMetrics.length > 0) {
-    console.log("\nSuccess Metrics:");
-    for (const metric of successMetrics) {
-      console.log(`  - ${metric}`);
-    }
-  }
-  console.log("");
-}
-function renderJSON(initiative) {
-  const { id, doc } = initiative;
-  const progress = getInitiativeProgress(id);
-  const wus = getInitiativeWUs(id);
-  const phaseGroups = getInitiativePhases(id);
-  const phases = toInitiativePhases(doc);
-  const status = deriveInitiativeLifecycleStatus(doc.status, phases, progress);
-  const output = {
-    id,
-    slug: asString(doc.slug),
-    title: asString(doc.title),
-    description: asString(doc.description),
-    status,
-    rawStatus: asString(doc.status),
-    priority: asString(doc.priority),
-    owner: asString(doc.owner),
-    created: asString(doc.created),
-    targetDate: asString(doc.target_date),
-    progress: {
-      percentage: progress.percentage,
-      done: progress.done,
-      inProgress: progress.inProgress,
-      ready: progress.ready,
-      blocked: progress.blocked,
-      total: progress.total
-    },
-    phases: phases.map((phase) => {
-      const phaseWUs = phaseGroups.get(phase.id) || [];
-      const phaseStatus = deriveInitiativePhaseStatus(phase.status, phaseWUs);
-      return {
-        id: phase.id,
-        title: asString(phase.title),
-        status: phaseStatus,
-        wuCount: phaseWUs.length,
-        wus: phaseWUs.map((w) => ({
-          id: w.id,
-          title: asString(w.doc.title),
-          status: normalizeLifecycleStatus(w.doc.status)
-        }))
-      };
-    }),
-    workUnits: wus.map((w) => ({
-      id: w.id,
-      title: asString(w.doc.title),
-      status: normalizeLifecycleStatus(w.doc.status),
-      phase: w.doc.phase ?? null
-    })),
-    successMetrics: asStringArray(doc.success_metrics),
-    labels: asStringArray(doc.labels)
-  };
-  console.log(JSON.stringify(output, null, 2));
-}
-function groupWUsByStatus(wus) {
-  const groups = {
-    [WU_STATUS.DONE]: [],
-    [WU_STATUS.IN_PROGRESS]: [],
-    [WU_STATUS.READY]: [],
-    [WU_STATUS.BLOCKED]: [],
-    other: []
-  };
-  for (const wu of wus) {
-    const status = normalizeLifecycleStatus(wu.doc.status);
-    switch (status) {
-      case WU_STATUS.DONE:
-        groups[WU_STATUS.DONE].push(wu);
-        break;
-      case WU_STATUS.IN_PROGRESS:
-        groups[WU_STATUS.IN_PROGRESS].push(wu);
-        break;
-      case WU_STATUS.READY:
-        groups[WU_STATUS.READY].push(wu);
-        break;
-      case WU_STATUS.BLOCKED:
-        groups[WU_STATUS.BLOCKED].push(wu);
-        break;
-      default:
-        groups.other.push(wu);
-        break;
-    }
-  }
-  return groups;
-}
-function formatStatus(status, useColor) {
-  if (!useColor) return status;
-  return status;
-}
-function truncate(str, maxLen) {
-  if (!str) return "";
-  return str.length > maxLen ? `${str.substring(0, maxLen - 3)}...` : str;
-}
-function capitalizeFirst(str) {
-  return str.charAt(0).toUpperCase() + str.slice(1).replace(/_/g, " ");
-}
-async function main() {
-  const args = createWUParser({
-    name: "initiative-status",
-    description: "Show detailed initiative view with phases and WUs",
-    options: [WU_OPTIONS.id, WU_OPTIONS.format, WU_OPTIONS.color],
-    required: [],
-    allowPositionalId: true
-  });
-  const initRef = args.id;
-  if (!initRef) {
-    die("Initiative ID or slug is required.\n\nUsage: pnpm initiative:status INIT-001");
-  }
-  const initiative = findInitiative(initRef);
-  if (!initiative) {
-    die(
-      `Initiative not found: ${initRef}
-
-Run 'pnpm initiative:list' to see available initiatives.`
-    );
-  }
-  const format = args.format || OUTPUT_FORMATS.TABLE;
-  switch (format) {
-    case OUTPUT_FORMATS.JSON:
-      renderJSON(initiative);
-      break;
-    default:
-      renderDetailed(initiative, Boolean(args.color));
-      break;
-  }
-}
-if (import.meta.main) {
-  void runCLI(main);
-}
-
-export {
-  deriveInitiativeLifecycleStatus,
-  deriveInitiativePhaseStatus,
-  main
-};

package/dist/chunk-EX6TT2XI.js

@@ -1,195 +0,0 @@
-import {
-  createWUParser,
-  runCLI,
-  withMicroWorktree
-} from "./chunk-2GXVIN57.js";
-import {
-  EXIT_CODES,
-  LUMENFLOW_PATHS
-} from "./chunk-DWMLTXKQ.js";
-
-// src/state-emit.ts
-import fs from "fs/promises";
-import path from "path";
-var VALID_EMIT_TYPES = ["claim", "release", "complete"];
-var WU_ID_PATTERN = /^WU-\d+$/;
-var LOG_PREFIX = "[state:emit]";
-var TOOL_NAME = "state:emit";
-function validateParams(opts) {
-  if (!VALID_EMIT_TYPES.includes(opts.type)) {
-    throw new Error(
-      `Invalid event type: '${opts.type}'. Valid types: ${VALID_EMIT_TYPES.join(", ")}`
-    );
-  }
-  if (!opts.reason || opts.reason.trim().length === 0) {
-    throw new Error("Reason is required for corrective events");
-  }
-  if (!WU_ID_PATTERN.test(opts.wuId)) {
-    throw new Error(`Invalid WU ID: '${opts.wuId}'. Must match pattern WU-XXX (e.g., WU-123)`);
-  }
-}
-function getTransactionalCommitMessage(type, wuId) {
-  return `chore(repair): emit corrective ${type} event for ${wuId.toLowerCase()}`;
-}
-async function emitCorrectiveEvent(opts) {
-  validateParams(opts);
-  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-  const event = {
-    wuId: opts.wuId,
-    type: opts.type,
-    reason: opts.reason,
-    timestamp,
-    source: TOOL_NAME,
-    corrective: true
-  };
-  if (opts.type === "claim") {
-    if (opts.lane) event.lane = opts.lane;
-    if (opts.title) event.title = opts.title;
-  }
-  const eventLine = JSON.stringify(event);
-  await fs.mkdir(path.dirname(opts.eventsFilePath), { recursive: true });
-  await fs.appendFile(opts.eventsFilePath, eventLine + "\n", "utf-8");
-  await writeAuditLog(opts.auditLogPath, {
-    tool: TOOL_NAME,
-    status: "success",
-    timestamp,
-    input: {
-      type: opts.type,
-      wuId: opts.wuId,
-      reason: opts.reason
-    }
-  });
-}
-async function emitCorrectiveEventTransactionally(opts, deps = {}) {
-  validateParams(opts);
-  const withMicroWorktreeImpl = deps.withMicroWorktreeImpl ?? withMicroWorktree;
-  const emitCorrectiveEventImpl = deps.emitCorrectiveEventImpl ?? emitCorrectiveEvent;
-  await withMicroWorktreeImpl({
-    operation: "state-emit",
-    id: `emit-${opts.wuId.toLowerCase()}-${opts.type}`,
-    logPrefix: LOG_PREFIX,
-    pushOnly: true,
-    execute: async ({ worktreePath }) => {
-      const eventsFilePath = path.join(worktreePath, LUMENFLOW_PATHS.WU_EVENTS);
-      const auditLogPath = path.join(worktreePath, LUMENFLOW_PATHS.AUDIT_LOG);
-      await emitCorrectiveEventImpl({
-        type: opts.type,
-        wuId: opts.wuId,
-        reason: opts.reason,
-        eventsFilePath,
-        auditLogPath,
-        lane: opts.lane,
-        title: opts.title
-      });
-      return {
-        commitMessage: getTransactionalCommitMessage(opts.type, opts.wuId),
-        files: [LUMENFLOW_PATHS.WU_EVENTS]
-      };
-    }
-  });
-}
-async function writeAuditLog(logPath, entry) {
-  try {
-    await fs.mkdir(path.dirname(logPath), { recursive: true });
-    await fs.appendFile(logPath, JSON.stringify(entry) + "\n", "utf-8");
-  } catch {
-  }
-}
-function parseArguments() {
-  return createWUParser({
-    name: "state-emit",
-    description: "Emit a corrective event to the state store",
-    options: [
-      {
-        name: "type",
-        flags: "-t, --type <type>",
-        description: `Event type (${VALID_EMIT_TYPES.join(", ")})`
-      },
-      {
-        name: "wu",
-        flags: "--wu <wuId>",
-        description: "Work Unit ID (e.g., WU-123)"
-      },
-      {
-        name: "reason",
-        flags: "-r, --reason <reason>",
-        description: "Reason for the corrective event (required)"
-      },
-      {
-        name: "baseDir",
-        flags: "-b, --base-dir <path>",
-        description: "Base directory (defaults to current directory)"
-      },
-      {
-        name: "transactional",
-        flags: "--transactional",
-        description: "Commit corrective event via micro-worktree (push-only mode)"
-      }
-    ],
-    required: [],
-    allowPositionalId: false
-  });
-}
-async function main() {
-  const args = parseArguments();
-  if (!args.type) {
-    console.error(`${LOG_PREFIX} Error: --type is required (${VALID_EMIT_TYPES.join(", ")})`);
-    process.exit(EXIT_CODES.ERROR);
-  }
-  if (!args.wu) {
-    console.error(`${LOG_PREFIX} Error: --wu is required (e.g., WU-123)`);
-    process.exit(EXIT_CODES.ERROR);
-  }
-  if (!args.reason) {
-    console.error(`${LOG_PREFIX} Error: --reason is required`);
-    process.exit(EXIT_CODES.ERROR);
-  }
-  const baseDir = args.baseDir || process.cwd();
-  const eventsFilePath = path.join(baseDir, LUMENFLOW_PATHS.WU_EVENTS);
-  const auditLogPath = path.join(baseDir, LUMENFLOW_PATHS.AUDIT_LOG);
-  try {
-    if (args.transactional) {
-      const resolvedBaseDir = path.resolve(baseDir);
-      const resolvedCwd = path.resolve(process.cwd());
-      if (resolvedBaseDir !== resolvedCwd) {
-        throw new Error(
-          "Transactional mode requires running from target repo root; --base-dir is not supported"
-        );
-      }
-      await emitCorrectiveEventTransactionally({
-        type: args.type,
-        wuId: args.wu,
-        reason: args.reason
-      });
-      console.log(`${LOG_PREFIX} Emitted corrective '${args.type}' event for ${args.wu}`);
-      console.log(`${LOG_PREFIX} Mode: transactional (micro-worktree push-only)`);
-      console.log(`${LOG_PREFIX} Reason: ${args.reason}`);
-    } else {
-      await emitCorrectiveEvent({
-        type: args.type,
-        wuId: args.wu,
-        reason: args.reason,
-        eventsFilePath,
-        auditLogPath
-      });
-      console.log(`${LOG_PREFIX} Emitted corrective '${args.type}' event for ${args.wu}`);
-      console.log(`${LOG_PREFIX} Mode: append-only`);
-      console.log(`${LOG_PREFIX} Reason: ${args.reason}`);
-      console.log(`${LOG_PREFIX} Events file: ${eventsFilePath}`);
-    }
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    console.error(`${LOG_PREFIX} Error: ${message}`);
-    process.exit(EXIT_CODES.ERROR);
-  }
-}
-if (import.meta.main) {
-  void runCLI(main);
-}
-
-export {
-  VALID_EMIT_TYPES,
-  emitCorrectiveEvent,
-  emitCorrectiveEventTransactionally,
-  main
-};

package/dist/chunk-EXINSFZE.js

@@ -1,82 +0,0 @@
-import {
-  SHA256_INTEGRITY_PREFIX,
-  computeDeterministicPackHash
-} from "./chunk-HANJXVKW.js";
-import {
-  WU_OPTIONS,
-  createWUParser,
-  runCLI
-} from "./chunk-2GXVIN57.js";
-
-// src/pack-hash.ts
-import { resolve } from "path";
-var LOG_PREFIX = "[pack:hash]";
-var DEFAULT_PACKS_ROOT = "packages/@lumenflow/packs";
-function resolvePackRoot(options) {
-  const { directPackRoot, packId, packsRoot } = options;
-  if (directPackRoot) {
-    return resolve(directPackRoot);
-  }
-  if (packId && packsRoot) {
-    return resolve(packsRoot, packId);
-  }
-  return null;
-}
-async function computePackHash(options) {
-  const { packRoot, hashExclusions } = options;
-  const absolutePackRoot = resolve(packRoot);
-  const hex = await computeDeterministicPackHash({
-    packRoot: absolutePackRoot,
-    exclusions: hashExclusions
-  });
-  return `${SHA256_INTEGRITY_PREFIX}${hex}`;
-}
-var PACK_HASH_OPTIONS = {
-  packId: {
-    name: "id",
-    flags: "--id <packId>",
-    description: "Pack ID to hash (resolves under --packs-root)"
-  },
-  packsRoot: {
-    name: "packsRoot",
-    flags: "--packs-root <dir>",
-    description: `Root directory containing packs (default: "${DEFAULT_PACKS_ROOT}")`
-  },
-  packRoot: {
-    name: "packRoot",
-    flags: "--pack-root <dir>",
-    description: "Direct path to pack directory (overrides --id and --packs-root)"
-  }
-};
-async function main() {
-  const opts = createWUParser({
-    name: "pack-hash",
-    description: "Compute integrity hash for a LumenFlow domain pack",
-    options: [
-      PACK_HASH_OPTIONS.packId,
-      PACK_HASH_OPTIONS.packsRoot,
-      PACK_HASH_OPTIONS.packRoot,
-      WU_OPTIONS.force
-    ]
-  });
-  const packId = opts.id;
-  const packsRoot = opts.packsRoot ?? DEFAULT_PACKS_ROOT;
-  const directPackRoot = opts.packRoot;
-  const resolvedPackRoot = resolvePackRoot({ directPackRoot, packId, packsRoot });
-  if (!resolvedPackRoot) {
-    console.error(`${LOG_PREFIX} Error: Provide --id <packId> or --pack-root <dir>`);
-    process.exit(1);
-  }
-  const hash = await computePackHash({ packRoot: resolvedPackRoot });
-  console.log(hash);
-}
-if (import.meta.main) {
-  void runCLI(main);
-}
-
-export {
-  LOG_PREFIX,
-  resolvePackRoot,
-  computePackHash,
-  main
-};