@alecsibilia/luca 13.0.0-alpha.1

package/dist/shared/luca.CRmaAfXR.mjs

@@ -0,0 +1,713 @@
+import { z } from 'zod';
+import 'node:fs';
+import 'node:fs/promises';
+import 'node:path';
+import 'node:os';
+
+const PipelineStepValues = [
+  "idle",
+  "triage",
+  "research",
+  "discuss",
+  "architect",
+  "plan",
+  "plan-review",
+  "execute",
+  "checks",
+  "verify",
+  "review",
+  "learn",
+  "milestone",
+  "complete"
+];
+const LEGACY_PIPELINE_STEP_MAP = {
+  // Old setup-related steps fold into triage (start of per-phase work).
+  classify: "triage",
+  configure: "triage",
+  "git-setup": "triage",
+  roadmap: "triage",
+  "phase-order": "triage",
+  // Old audit sub-steps fold into review.
+  "review-audit": "review",
+  "gap-audit": "review",
+  // Old cleanup folds into milestone.
+  cleanup: "milestone"
+};
+
+const ComplexityLevel = z.enum([
+  "TRIVIAL",
+  "SIMPLE",
+  "MODERATE",
+  "COMPLEX",
+  "CRITICAL"
+]);
+const OversightMode = z.enum([
+  "full-auto",
+  "checkpoint",
+  "human-in-loop"
+]);
+const PipelineStepEnum = z.enum(PipelineStepValues);
+const PipelineStep = z.preprocess((val) => {
+  if (typeof val === "string" && val in LEGACY_PIPELINE_STEP_MAP) {
+    return LEGACY_PIPELINE_STEP_MAP[val];
+  }
+  return val;
+}, PipelineStepEnum);
+const PhaseStatus = z.enum([
+  "pending",
+  "in-progress",
+  "complete",
+  "skipped",
+  "blocked"
+]);
+z.enum([
+  "IDLE",
+  "PLANNING",
+  "EXECUTING",
+  "REVIEWING",
+  "FINALIZING"
+]);
+const RoadmapPhaseSchema = z.object({
+  name: z.string(),
+  deps: z.array(z.string()).default([]),
+  status: PhaseStatus.default("pending"),
+  complexity: ComplexityLevel.optional()
+});
+const lucaStateSchema = z.object({
+  // --- Complexity & oversight ---
+  complexity: ComplexityLevel.optional(),
+  oversight: OversightMode.default("full-auto"),
+  // --- Pipeline progress ---
+  pipelineStep: PipelineStep.default("idle"),
+  currentPhase: z.number().default(0),
+  totalPhases: z.number().default(0),
+  phaseSubStep: z.string().optional(),
+  // --- Session ---
+  sessionId: z.string().optional(),
+  // --- Roadmap ---
+  roadmap: z.array(RoadmapPhaseSchema).default([]),
+  // --- Git ---
+  branchName: z.string().optional(),
+  issueNumber: z.number().optional(),
+  // --- Iteration tracking ---
+  checksFixIteration: z.number().default(0),
+  verifyIteration: z.number().default(0),
+  planReviewIteration: z.number().default(0),
+  researchReviewIteration: z.number().default(0),
+  reviewIteration: z.number().default(0),
+  // --- Budget matrix (resolved from complexity) ---
+  maxChecksFixIterations: z.number().default(3),
+  maxVerifyIterations: z.number().default(2),
+  maxPlanReviewIterations: z.number().default(2),
+  maxResearchReviewIterations: z.number().default(2),
+  maxReviewIterations: z.number().default(2),
+  maxPhases: z.number().default(5),
+  // --- Review-mode entry timestamp ---
+  reviewStartedAt: z.string().optional(),
+  // --- Crash recovery ---
+  lockPid: z.number().optional(),
+  lockAcquiredAt: z.string().optional(),
+  // --- Sandbox paths (workflow-allowed file roots) ---
+  sandboxAllowedPaths: z.array(z.string()).default([])
+});
+const lucaStateSchemaTolerant = lucaStateSchema.passthrough();
+
+const PIPELINE_STEP_TO_COARSE_PHASE = {
+  idle: "IDLE",
+  triage: "PLANNING",
+  research: "PLANNING",
+  discuss: "PLANNING",
+  architect: "PLANNING",
+  plan: "PLANNING",
+  "plan-review": "PLANNING",
+  execute: "EXECUTING",
+  checks: "EXECUTING",
+  verify: "REVIEWING",
+  review: "REVIEWING",
+  learn: "REVIEWING",
+  milestone: "FINALIZING",
+  complete: "FINALIZING"
+};
+
+function coarsePhaseOf(step) {
+  return PIPELINE_STEP_TO_COARSE_PHASE[step];
+}
+
+const PHASE_SLUG_RE = /^[0-9]{2}-[a-z](?:[a-z0-9-]*[a-z0-9])?$/;
+const WAVE_FILE_RE = /^[0-9]{2}\.md$/;
+const SEMVER_TAG_RE = /^v\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
+const REVIEWER_NAME_RE = /^[a-z][a-z0-9-]*[a-z0-9]$/;
+const RUN_ID_RE = /^[A-Za-z0-9_-]+$/;
+const LUCA_DIR_ROOT = ".luca";
+const lucaRootPaths = {
+  state: `${LUCA_DIR_ROOT}/state.json`,
+  config: `${LUCA_DIR_ROOT}/config.json`,
+  lock: `${LUCA_DIR_ROOT}/lock.json`,
+  ledger: `${LUCA_DIR_ROOT}/ledger.jsonl`
+};
+const PHASE_FILE_PATHS = {
+  research: "research.md",
+  context: "context.md",
+  plan: "plan.md",
+  "plan-review": "plan-review.md",
+  verify: "verify.json",
+  learn: "learn.md",
+  confidence: "confidence.jsonl",
+  "execute/summary": "execute/summary.md",
+  "execute/progress": "execute/progress.jsonl"
+};
+
+z.enum([
+  // Root-level
+  "root.state",
+  "root.config",
+  "root.lock",
+  "root.roadmap",
+  "root.ledger",
+  // Phase artifacts
+  "phase.research",
+  "phase.context",
+  "phase.plan",
+  "phase.plan-review",
+  "phase.execute.summary",
+  "phase.execute.progress",
+  "phase.execute.wave",
+  "phase.audit",
+  "phase.verify",
+  "phase.learn",
+  "phase.confidence",
+  "phase.raw",
+  // Milestones
+  "milestone.roadmap",
+  "milestone.backlog-snapshot-json",
+  "milestone.backlog-snapshot-md",
+  "milestone.audit",
+  // Telemetry
+  "telemetry.run",
+  // Archive
+  "archive.phase"
+]);
+const PhaseSlugSchema = z.string().regex(PHASE_SLUG_RE, {
+  message: 'Phase slug must be <NN-kebab-case>, e.g. "01-auth-rewrite" (NN zero-padded).'
+});
+z.string().regex(REVIEWER_NAME_RE, {
+  message: 'Reviewer name must be kebab-case, e.g. "code-review".'
+});
+z.string().regex(SEMVER_TAG_RE, {
+  message: 'Version tag must be SemVer-prefixed with "v", e.g. "v12.0.0".'
+});
+z.number().int().min(0).max(99, { message: "Wave number must fit in two digits (0\u201399)." });
+const RunIdSchema = z.string().regex(RUN_ID_RE, {
+  message: "runId must be alphanumeric/kebab."
+});
+
+const PIPELINE_TRANSITIONS = {
+  idle: ["triage"],
+  triage: ["research"],
+  research: ["discuss", "research"],
+  // re-research allowed
+  discuss: ["architect"],
+  architect: ["plan"],
+  plan: ["plan-review"],
+  "plan-review": ["execute", "plan"],
+  // re-plan allowed
+  execute: ["checks"],
+  checks: ["verify", "execute"],
+  // fix loop back to execute
+  verify: ["review", "checks"],
+  // fix loop back to checks
+  review: ["learn"],
+  learn: ["milestone", "plan"],
+  // next phase OR close milestone
+  milestone: ["complete"],
+  complete: ["idle"]
+  // start a fresh session
+};
+function isLegalTransition(from, to) {
+  return PIPELINE_TRANSITIONS[from].includes(to);
+}
+
+const SYSTEM_DIR_PATTERN = /^\/(etc|usr|var|System|bin|sbin)(\/|$)/;
+const GIT_DIR_PATTERN = /(^|\/)\.git(\/|$)/;
+const HOME_DENIED_SUBDIRS = [".claude", ".luca"];
+const reAnchorless = (re) => re.source.replace(/^\^/, "").replace(/\$$/, "");
+const AUDIT_PATH_PATTERN = new RegExp(
+  `^\\.luca/phases/${reAnchorless(PHASE_SLUG_RE)}/audits/${reAnchorless(
+    REVIEWER_NAME_RE
+  )}\\.md$`
+);
+function classifyWritePath(path, opts = {}) {
+  if (GIT_DIR_PATTERN.test(path)) {
+    return {
+      class: "denied",
+      reason: "writes under .git/ are never allowed"
+    };
+  }
+  if (SYSTEM_DIR_PATTERN.test(path)) {
+    return {
+      class: "denied",
+      reason: "writes under system directories (/etc, /usr, /var, /System, /bin, /sbin) are never allowed"
+    };
+  }
+  for (const subdir of HOME_DENIED_SUBDIRS) {
+    if (path.startsWith(`~/${subdir}/`) || path === `~/${subdir}`) {
+      return {
+        class: "denied",
+        reason: `writes under ~/${subdir}/ are never allowed`
+      };
+    }
+    if (opts.homedir) {
+      const abs = `${opts.homedir.replace(/\/$/, "")}/${subdir}`;
+      if (path.startsWith(`${abs}/`) || path === abs) {
+        return {
+          class: "denied",
+          reason: `writes under ${abs}/ (user tooling dir) are never allowed`
+        };
+      }
+    }
+  }
+  if (path.startsWith(".luca/") || path === ".luca") {
+    if (AUDIT_PATH_PATTERN.test(path)) {
+      return { class: "planning-audit" };
+    }
+    return { class: "planning-general" };
+  }
+  return { class: "code" };
+}
+
+z.object({
+  pid: z.number().int().positive(),
+  acquired_at: z.string().min(1),
+  run_id: z.string().min(1),
+  /** Best-effort hostname (omitted when `os.hostname()` is unavailable). */
+  host: z.string().optional()
+});
+
+const SAFE_FREEFORM_SCHEMA = z.string().max(64).regex(/^[\w #\t{}/,.():-]*$/);
+const REGEX_SOURCE_SCHEMA = z.string().min(1).max(128).refine(
+  (v) => {
+    try {
+      new RegExp(v);
+      return true;
+    } catch {
+      return false;
+    }
+  },
+  { message: "must be a valid regex source" }
+).refine((v) => !/[+*}]\)[+*{]/.test(v), {
+  message: "nested quantifiers prohibited (ReDoS guard)"
+});
+const BaseRuleSchema = z.object({
+  kind: z.enum(["static", "current-branch-if-matches", "ask"]),
+  value: SAFE_FREEFORM_SCHEMA.optional(),
+  pattern: REGEX_SOURCE_SCHEMA.optional(),
+  fallback: z.union([SAFE_FREEFORM_SCHEMA, z.literal("ask")]).optional()
+});
+const BranchTypeRuleSchema = z.object({
+  match: REGEX_SOURCE_SCHEMA,
+  template: SAFE_FREEFORM_SCHEMA,
+  base: BaseRuleSchema,
+  prBase: BaseRuleSchema,
+  role: z.enum(["feature", "release", "rc"]).optional()
+});
+const BranchingSectionSchema = z.object({
+  types: z.array(SAFE_FREEFORM_SCHEMA).default([
+    "feat",
+    "fix",
+    "refactor",
+    "chore",
+    "docs",
+    "test",
+    "style"
+  ]),
+  template: SAFE_FREEFORM_SCHEMA.default("{type}/{issue}-{slug}"),
+  defaultBranch: SAFE_FREEFORM_SCHEMA.default("main"),
+  guardedBranches: z.array(SAFE_FREEFORM_SCHEMA).min(1).default(["main"]),
+  branchTypes: z.array(BranchTypeRuleSchema).optional(),
+  fallback: BranchTypeRuleSchema.optional(),
+  confirmBaseBeforeCreate: z.boolean().default(false)
+}).prefault({});
+const CommitsSectionSchema = z.object({
+  convention: z.enum(["conventional", "none"]).default("conventional"),
+  scopes: z.array(SAFE_FREEFORM_SCHEMA).default([]),
+  /**
+   * Allowed commit-message types. Distinct from `branching.types` —
+   * branching.types governs branch-name prefix; commits.types
+   * governs commit-message prefix. They MAY differ for squash-merge
+   * repos where every PR squashes to a single `feat:` commit
+   * regardless of branch type. Falls back to branching.types when
+   * unset.
+   */
+  types: z.array(SAFE_FREEFORM_SCHEMA).max(20).optional(),
+  trailers: z.object({
+    coAuthor: z.boolean(),
+    issueRef: SAFE_FREEFORM_SCHEMA
+  }).optional(),
+  subjectMaxLength: z.number().int().min(20).max(200).default(72)
+}).prefault({});
+const PrSectionSchema = z.object({
+  titleFormat: SAFE_FREEFORM_SCHEMA.default(
+    "{type}({scope}): {description}"
+  ),
+  baseBranch: SAFE_FREEFORM_SCHEMA.default("main"),
+  /**
+   * Preferred PR title template — supersedes `titleFormat` when
+   * present. `titleFormat` is retained for backward compatibility.
+   * When both are set, `titleTemplate` wins.
+   */
+  titleTemplate: SAFE_FREEFORM_SCHEMA.optional(),
+  titleExamples: z.array(SAFE_FREEFORM_SCHEMA).max(5).optional(),
+  forbidden: z.array(
+    z.object({
+      pattern: REGEX_SOURCE_SCHEMA,
+      reason: SAFE_FREEFORM_SCHEMA
+    })
+  ).max(10).optional(),
+  bodyTemplate: SAFE_FREEFORM_SCHEMA.optional(),
+  draftByDefault: z.boolean().optional()
+}).prefault({});
+const ReleaseSectionSchema = z.object({
+  tool: z.enum(["changesets", "none", "semantic-release"]).default("none"),
+  versionBump: z.record(z.string(), z.enum(["major", "minor", "patch"])).default({
+    feat: "minor",
+    fix: "patch",
+    chore: "patch",
+    refactor: "patch"
+  })
+}).prefault({});
+const TrackerSectionSchema = z.object({
+  kind: z.enum(["github", "linear", "jira", "none"]).default("github"),
+  issuePrefix: SAFE_FREEFORM_SCHEMA.default(""),
+  /**
+   * Issue-link template used in PR bodies. Distinct from
+   * `commits.trailers.issueRef` (the commit-message trailer
+   * prefix) — consumers may use the same string for both, but
+   * they are conceptually independent.
+   */
+  linkFormat: SAFE_FREEFORM_SCHEMA.optional()
+}).prefault({});
+const ProjectPreferencesSchema = z.object({
+  schemaVersion: z.literal(1).default(1),
+  branching: BranchingSectionSchema,
+  commits: CommitsSectionSchema,
+  pr: PrSectionSchema,
+  release: ReleaseSectionSchema,
+  tracker: TrackerSectionSchema
+}).prefault({});
+z.enum([
+  "branching",
+  "commits",
+  "pr",
+  "release",
+  "tracker"
+]);
+ProjectPreferencesSchema.parse({});
+
+const TodoStatus = z.enum(["pending", "backlog", "done"]);
+const TodoIdSchema = z.string().min(1).max(60).regex(/^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/, {
+  message: "must be kebab-case (lowercase a-z, digits, single dashes)"
+});
+const VerificationRefSchema = z.object({
+  criterionId: z.string().min(1).describe(
+    "Stable criterion id (e.g. 'ac-03') matching an entry in the active phase's verify.json."
+  )
+});
+const TodoSchema = z.object({
+  schemaVersion: z.literal(1),
+  id: TodoIdSchema,
+  title: z.string().min(1).max(200),
+  body: z.string().max(8192).optional(),
+  status: TodoStatus,
+  source: z.string().max(120).optional(),
+  metadata: z.record(z.string(), z.unknown()).optional(),
+  updatedAt: z.string().datetime({ message: "updatedAt must be ISO 8601 datetime" }),
+  verificationRef: VerificationRefSchema.optional()
+});
+function slugFromTitle(title) {
+  const slug = title.normalize("NFKD").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60).replace(/-+$/g, "");
+  if (slug.length === 0) {
+    throw new Error(
+      `cannot derive a slug from title "${title}" (no alphanumeric content)`
+    );
+  }
+  return slug;
+}
+const TODO_CONCEPT_PREFIX = "todo:";
+function todoConceptFor(id) {
+  return `${TODO_CONCEPT_PREFIX}${id}`;
+}
+
+const ShadowScanSeverity = z.enum(["critical", "high", "medium", "low"]);
+const ShadowScanAction = z.enum(["delete", "move", "gitignore"]);
+const ShadowScanMode = z.enum(["quick", "standard", "full"]);
+const ShadowScanFindingSchema = z.object({
+  /** Detection category label, e.g. "orphaned-temp-script". */
+  category: z.string().min(1),
+  severity: ShadowScanSeverity,
+  /** Repo-relative path of the flagged file. */
+  file_path: z.string().min(1),
+  /** What was detected. */
+  description: z.string().min(1),
+  /** Human-readable remediation recommendation. */
+  recommendation: z.string().min(1),
+  /** The remediation the apply tool would perform. */
+  recommended_action: ShadowScanAction,
+  /** Destination path — required for a `move` action. */
+  target_path: z.string().min(1).optional(),
+  /** Whether the remediation is safe to apply without user confirmation. */
+  auto_fixable: z.boolean()
+});
+const ShadowScanSummarySchema = z.object({
+  total: z.number().int().min(0),
+  critical: z.number().int().min(0),
+  high: z.number().int().min(0),
+  medium: z.number().int().min(0),
+  low: z.number().int().min(0)
+});
+z.object({
+  scan_mode: ShadowScanMode,
+  /** Detection category numbers that were run for this scan. */
+  categories_scanned: z.array(z.number().int()),
+  findings: z.array(ShadowScanFindingSchema),
+  summary: ShadowScanSummarySchema,
+  scanned_at: z.string().datetime({ message: "scanned_at must be ISO 8601 datetime" })
+});
+
+const ClassifyComplexityInputSchema = z.object({
+  taskDescription: z.string().describe("Description of the development task"),
+  estimatedFileCount: z.number().default(0).describe("Estimated number of files affected"),
+  crossCuttingConcerns: z.array(z.string()).default([]).describe("Cross-cutting concerns (e.g. auth, state, API changes)"),
+  hasBreakingChanges: z.boolean().default(false).describe("Whether the change introduces breaking changes"),
+  affectedDomains: z.array(z.string()).default([]).describe("Affected architectural domains")
+});
+z.object({
+  complexity: ComplexityLevel,
+  reasoning: z.string(),
+  factors: z.object({
+    fileScope: z.enum(["small", "medium", "large"]),
+    dependencyDepth: z.enum(["shallow", "moderate", "deep"]),
+    riskLevel: z.enum(["low", "medium", "high"])
+  })
+});
+
+z.object({
+  file: z.string(),
+  line: z.number().optional(),
+  column: z.number().optional(),
+  message: z.string(),
+  code: z.string().optional(),
+  severity: z.enum(["error", "warning"])
+});
+
+const TelemetryRecordSchema = z.object({
+  v: z.literal(1),
+  // ISO 8601 datetime — aggregator consumers parse durations from these.
+  ts: z.iso.datetime(),
+  runId: z.string(),
+  kind: z.string(),
+  phase: z.string().nullable(),
+  slug: z.string().nullable(),
+  wave: z.number().nullable(),
+  complexity: z.string().nullable(),
+  oversight: z.string().nullable(),
+  durationMs: z.number().nullable(),
+  meta: z.record(z.string(), z.unknown())
+});
+
+const LedgerEntrySchema = z.object({
+  /** Event timestamp (ISO 8601). */
+  timestamp: z.iso.datetime(),
+  /** Run identifier — correlates ledger entries with telemetry records. */
+  runId: z.string(),
+  /** Event name (e.g. `mode-transition`, `phase-complete`). */
+  event: z.string(),
+  /** Free-form per-event payload. */
+  data: z.record(z.string(), z.unknown())
+});
+
+const VerificationCriterionSchema = z.object({
+  /** Stable identifier (e.g. "ac-01", "test-pass"). */
+  criterionId: z.string(),
+  /** Human-readable description. */
+  description: z.string(),
+  /** Whether the criterion is satisfied. */
+  met: z.boolean(),
+  /** File / line / test evidence supporting the verdict. */
+  evidence: z.string(),
+  /** If not met, what is missing. */
+  gap: z.string().optional(),
+  /** Whether this criterion blocks proceeding. */
+  blocking: z.boolean()
+});
+const CheckResultSchema = z.object({
+  name: z.string(),
+  status: z.enum(["pass", "fail", "skip", "timeout"]),
+  errorCount: z.number(),
+  warningCount: z.number(),
+  /** Duration in milliseconds. */
+  durationMs: z.number().optional()
+});
+const VerificationResultSchema = z.object({
+  /** ISO 8601 timestamp (stored verbatim; not parsed for arithmetic). */
+  timestamp: z.string(),
+  /**
+   * Run that produced this result. Stamped on write, validated on read: a
+   * stale result from a prior run (mismatched runId) is treated as absent so
+   * it cannot satisfy the new run's wave/phase guards. Optional for
+   * back-compat with results written before runId stamping.
+   */
+  runId: z.string().optional(),
+  /** Pipeline phase (e.g. "Phase 1: Setup"). */
+  phase: z.string().optional(),
+  /** Wave / iteration number. */
+  wave: z.number(),
+  /** Verification depth. */
+  mode: z.enum(["quick", "full"]),
+  /** Overall verdict. */
+  status: z.enum(["PASS", "FAIL", "STALLED"]),
+  /** Per-criterion results. */
+  criteria: z.array(VerificationCriterionSchema),
+  /** Automated check results. */
+  checks: z.array(CheckResultSchema),
+  /** Convergence assessment. */
+  convergence: z.enum(["converging", "stalled", "resolved"]),
+  /** Error fingerprints for tracking across iterations. */
+  errorFingerprints: z.array(z.string()),
+  /** Recommendation to the orchestrator. */
+  recommendation: z.enum(["proceed", "fix", "escalate"]),
+  /** Free-form notes from the verifier. */
+  notes: z.string().optional()
+});
+
+const ConfidenceLevelSchema = z.enum(["high", "medium", "low"]);
+const ConfidenceCategorySchema = z.enum([
+  "plan-gap",
+  "design-choice",
+  "convention-unclear",
+  "requirement-ambiguous",
+  "dependency-unknown",
+  "scope-creep"
+]);
+const ConfidenceEntrySchema = z.object({
+  /** Event timestamp (ISO 8601). */
+  timestamp: z.iso.datetime(),
+  /** Phase name from the plan / roadmap. */
+  phase: z.string(),
+  /** Wave number within the phase. */
+  wave: z.number(),
+  /** Task ID or description from the plan. */
+  task: z.string(),
+  /** How confident the executor was in its decision. */
+  confidence: ConfidenceLevelSchema,
+  /** What kind of ambiguity was encountered. */
+  category: ConfidenceCategorySchema,
+  /** What the executor actually decided to do. */
+  decision: z.string(),
+  /** Other options that were considered. */
+  alternatives: z.array(z.string()),
+  /** Why this choice was made over the alternatives. */
+  reasoning: z.string(),
+  /** What could go wrong if this was the wrong call. */
+  risk: z.string(),
+  /** Which files were affected by this decision. */
+  files: z.array(z.string()),
+  /** Suggested focus area for a human reviewer. */
+  reviewHint: z.string().optional()
+});
+
+new Set(Object.keys(PIPELINE_TRANSITIONS));
+
+const STEP_TEMPLATES = {
+  triage: "Begin triage. Parse the request, classify complexity, and advance to research. Do NOT implement anything. Do NOT modify files. Your only job is to classify and transition.",
+  research: "Begin research. Read the existing state and prior artifacts, investigate the affected areas, and save findings to `.luca/phases/<slug>/research.md`. When research is complete, advance to discuss.",
+  discuss: "Begin discussion. Gather user decisions for the active phase and persist them as `.luca/phases/<slug>/context.md`. Keep the scope tight \u2014 clarifying questions only.",
+  architect: "Begin architecture. Read research + context, then produce a structured implementation plan using goal-backward analysis. When the plan is approved, advance to plan.",
+  plan: "Write the phase plan to `.luca/phases/<slug>/plan.md`. Keep tasks atomic and each task verifiable. When the plan is final, advance to plan-review.",
+  "plan-review": "Review the plan against the research + context. Validate every task is atomic, verifiable, and traceable. Surface gaps as plan-review notes; do not edit the plan in place.",
+  execute: "Begin execution. Read `.luca/phases/<slug>/plan.md` and implement changes in waves. Run `luca checks run` after each wave. Do NOT re-create the plan. When all waves are complete, advance to checks.",
+  checks: "Run the verification harness via `luca checks run`. On failure, loop back to execute with a focused fix list. On success, advance to verify.",
+  verify: "Verify the changes against the plan and acceptance criteria. Produce `verify.json` with the result; on failure loop back to checks.",
+  review: "Review the code changes against the plan. Spawn reviewer subagents for a multi-perspective audit. Produce REVIEW reports under `audits/`. If must-fix issues are found, loop back to execute; otherwise advance to learn.",
+  learn: "Capture learnings as patterns/decisions/pitfalls in MuninnDB and as `learn.md`. Then advance to milestone (to close the milestone) or back to plan (to start the next phase).",
+  milestone: "Close the milestone. Produce the versioned roadmap + audit snapshot under `.luca/milestones/`. Then advance to complete.",
+  complete: "Wrap the session: finalize metrics, surface the PR if appropriate, and advance to idle."
+};
+const ALL_PIPELINE_STEPS_TABLE$1 = {
+  idle: true,
+  triage: true,
+  research: true,
+  discuss: true,
+  architect: true,
+  plan: true,
+  "plan-review": true,
+  execute: true,
+  checks: true,
+  verify: true,
+  review: true,
+  learn: true,
+  milestone: true,
+  complete: true
+};
+new Set(
+  Object.keys(ALL_PIPELINE_STEPS_TABLE$1)
+);
+for (const step of Object.keys(ALL_PIPELINE_STEPS_TABLE$1)) {
+  if (step === "idle") continue;
+  if (STEP_TEMPLATES[step] === void 0) {
+    throw new Error(
+      `continuation-messages: STEP_TEMPLATES is missing an entry for pipelineStep '${step}'. Add a template or extend the coarse-phase map if this step shouldn't emit a continuation.`
+    );
+  }
+}
+
+const STEP_REMINDERS = {
+  triage: "<luca-reminder>You are in triage. \u226475 words output. Classify \u2192 rationale \u2192 next step. Do NOT implement.</luca-reminder>",
+  research: "<luca-reminder>You are in research. Budget: MODERATE \u226410, COMPLEX \u226420, CRITICAL \u226430 tool calls. Synthesis \u2264200 lines.</luca-reminder>",
+  discuss: "<luca-reminder>Discuss (read-only). Under 300 words per turn. \u22642 clarifying questions. Persist decisions to context.md.</luca-reminder>",
+  architect: "<luca-reminder>You are in architect mode. \u22643 sentences per task. \u2264150 lines PLAN.md total. Validate with plan-reviewer before finishing.</luca-reminder>",
+  plan: "<luca-reminder>You are in plan mode. Atomic tasks, each verifiable. Keep PLAN.md \u2264150 lines. No code yet.</luca-reminder>",
+  "plan-review": "<luca-reminder>Plan-review (read-only). Validate atomicity/verifiability/traceability. Surface gaps; do not edit the plan in place.</luca-reminder>",
+  execute: "<luca-reminder>You are in execute mode. Run `luca checks run` within 1 tool call of wave completion. Stalled \u22652 iterations = stop and escalate. No prose between tool calls.</luca-reminder>",
+  checks: "<luca-reminder>You are in checks. Run the verification harness. On failure, loop back to execute with a focused fix list. No prose.</luca-reminder>",
+  verify: "<luca-reminder>You are in verify. Compare changes against plan + acceptance criteria. Produce verify.json; on failure loop back to checks.</luca-reminder>",
+  review: "<luca-reminder>You are in review mode (read-only). Maximum 5 MUST-FIX items. MUST-FIX = correctness bugs, security, missing requirements ONLY.</luca-reminder>",
+  learn: "<luca-reminder>You are in learn mode. Capture patterns/decisions/pitfalls in MuninnDB + learn.md. Be concrete. \u2264200 lines.</luca-reminder>",
+  milestone: "<luca-reminder>You are in milestone mode. Close the milestone: versioned roadmap + audit snapshot under .luca/milestones/.</luca-reminder>",
+  complete: "<luca-reminder>You are in complete mode. Finalize metrics, surface the PR if appropriate, then advance to idle.</luca-reminder>"
+};
+const ALL_PIPELINE_STEPS_TABLE = {
+  idle: true,
+  triage: true,
+  research: true,
+  discuss: true,
+  architect: true,
+  plan: true,
+  "plan-review": true,
+  execute: true,
+  checks: true,
+  verify: true,
+  review: true,
+  learn: true,
+  milestone: true,
+  complete: true
+};
+new Set(
+  Object.keys(ALL_PIPELINE_STEPS_TABLE)
+);
+for (const step of Object.keys(ALL_PIPELINE_STEPS_TABLE)) {
+  if (step === "idle") continue;
+  if (STEP_REMINDERS[step] === void 0) {
+    throw new Error(
+      `context-refresher: STEP_REMINDERS is missing an entry for pipelineStep '${step}'. Add a reminder or extend the coarse-phase map if this step shouldn't emit a reminder.`
+    );
+  }
+}
+for (const step of Object.keys(STEP_REMINDERS)) {
+  if (coarsePhaseOf(step) === "IDLE") {
+    throw new Error(
+      `context-refresher: STEP_REMINDERS includes step '${step}' whose coarse phase is IDLE. IDLE steps never emit reminders \u2014 drop the entry from STEP_REMINDERS.`
+    );
+  }
+}
+
+export { AUDIT_PATH_PATTERN as A, ClassifyComplexityInputSchema as C, LUCA_DIR_ROOT as L, ProjectPreferencesSchema as P, RunIdSchema as R, ShadowScanFindingSchema as S, TelemetryRecordSchema as T, VerificationRefSchema as V, WAVE_FILE_RE as W, classifyWritePath as a, ConfidenceCategorySchema as b, coarsePhaseOf as c, ConfidenceLevelSchema as d, lucaRootPaths as e, RoadmapPhaseSchema as f, PipelineStep as g, PIPELINE_TRANSITIONS as h, isLegalTransition as i, PIPELINE_STEP_TO_COARSE_PHASE as j, PipelineStepValues as k, lucaStateSchema as l, TodoIdSchema as m, TodoSchema as n, TodoStatus as o, TODO_CONCEPT_PREFIX as p, LedgerEntrySchema as q, ConfidenceEntrySchema as r, slugFromTitle as s, todoConceptFor as t, VerificationResultSchema as u, PHASE_SLUG_RE as v, lucaStateSchemaTolerant as w, PhaseSlugSchema as x, PHASE_FILE_PATHS as y };