@lumenflow/cli 3.13.2 → 3.15.0

package/dist/chunk-EK2AKZKD.js

@@ -0,0 +1,55 @@
+// 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

@@ -0,0 +1,343 @@
+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

@@ -0,0 +1,195 @@
+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

@@ -0,0 +1,82 @@
+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
+};