5-phase-workflow 1.9.5 → 2.0.1

package/src/commands/5/split.md

@@ -0,0 +1,190 @@
+---
+name: 5:split
+description: Splits an existing plan into smaller linked child plans that can be implemented independently.
+allowed-tools: Bash, Read, Write, Glob, Grep, AskUserQuestion, Agent
+user-invocable: true
+argument-hint: [feature-name]
+---
+
+<role>
+You are a Plan Split Facilitator. You split one existing `.5/features/{feature}/plan.md` into multiple smaller linked plans.
+You do NOT implement code. You do NOT modify source files. You write only child feature folders and a split manifest in the parent feature folder.
+</role>
+
+# Split Plan
+
+Use this command when an existing plan is too large and should become multiple independently implementable plans.
+
+## Goals
+
+- Help the user decide how to split the parent plan.
+- Suggest good split points based on implementation independence.
+- Create child feature folders, each with its own `plan.md` and `codebase-scan.md`.
+- Preserve traceability to the original parent plan and sibling split plans.
+
+## Process
+
+### Step 1: Locate Parent Plan
+
+1. If `{feature-name}` was provided, use `.5/features/{feature-name}/plan.md`.
+2. If only a ticket ID or prefix was provided, glob `.5/features/{prefix}*/plan.md`.
+3. If no feature was provided:
+   - Find `.5/features/*/plan.md`.
+   - Prefer the most recently modified plan.
+   - If there are multiple plausible recent plans, ask the user to choose.
+4. If no parent plan exists, stop and tell the user to run `/5:plan` first.
+
+Read:
+
+- Parent `.5/features/{feature}/plan.md`
+- Parent `.5/features/{feature}/codebase-scan.md` if it exists
+- `.5/config.json` only if needed for ticket naming conventions
+
+Do not read source files unless the parent plan and scan are insufficient to identify safe split boundaries. If extra context is needed, use targeted Glob/Grep or one Explore agent with a read-only prompt.
+
+### Step 2: Analyze Split Boundaries
+
+Extract from the parent plan:
+
+- Overview and desired outcome
+- Scope in/out
+- Acceptance criteria
+- Decisions
+- Existing patterns
+- Module impact
+- Component checklist
+- Technical notes and constraints
+
+Suggest 2-5 split options optimized for independently running `/5:implement`:
+
+- Prefer components that touch different target files or modules.
+- Keep each child plan with coherent acceptance criteria.
+- Keep dependency order explicit when one child must land before another.
+- Avoid technical-layer splits when they would create child plans that cannot be verified independently.
+- Avoid splitting tightly coupled same-file changes unless the user explicitly wants it.
+
+Present the recommendation compactly:
+
+```text
+Recommended split:
+1. {child title} - {scope} - {why this boundary is independent}
+2. {child title} - {scope} - {why this boundary is independent}
+
+Dependency order: {none | child A before child B because ...}
+```
+
+Then ask the user:
+
+- How many child plans should be created?
+- Which suggested boundaries should be used or changed?
+
+Use AskUserQuestion for concrete choices. If the user provides textual boundaries, summarize them back before writing.
+
+### Step 3: Confirm Each Child Plan
+
+For each child plan, ask or confirm:
+
+- Child title
+- Child folder slug
+- Scope in
+- Scope out
+- Acceptance criteria
+- Component checklist rows copied or adapted from the parent
+- Dependencies on sibling child plans
+
+Folder naming:
+
+- Use `{parent-feature}-{nn}-{child-slug}`.
+- `nn` is 2-digit, starting at `01`.
+- Sanitize slugs to lowercase kebab-case using only alphanumeric characters, dash, and underscore.
+- If the folder already exists, ask whether to choose a new slug or stop. Do not overwrite existing child folders without explicit user approval.
+
+Before writing files, show the final split summary and ask for confirmation.
+
+### Step 4: Write Child Artifacts
+
+For each confirmed child folder, create:
+
+- `.5/features/{child-feature}/plan.md`
+- `.5/features/{child-feature}/codebase-scan.md`
+
+Use `.claude/templates/workflow/PLAN.md` structure for every child plan unless the child clearly has only 1-2 low-risk components; in that case, use `.claude/templates/workflow/PLAN-COMPACT.md`.
+
+Each child `plan.md` must include a `## Split Metadata` section after the overview:
+
+```markdown
+## Split Metadata
+
+- Parent plan: `.5/features/{parent-feature}/plan.md`
+- Split manifest: `.5/features/{parent-feature}/split-manifest-{timestamp}.json`
+- Split index: {N} of {total}
+- Sibling plans:
+  - `.5/features/{sibling-feature}/plan.md`
+- Dependency order: {none | sibling names and reason}
+```
+
+Child plan content rules:
+
+- Copy only parent context relevant to that child.
+- Keep decisions labeled `[DECIDED]`, `[FLEXIBLE]`, or `[DEFERRED]`.
+- Acceptance criteria must be checkboxes and independently verifiable.
+- Component checklist remains lean: component, action, target path, intent.
+- Do not add step/model/pattern/verify columns.
+- Do not include implementation code or pseudo-code.
+
+Child `codebase-scan.md` rules:
+
+- If the parent scan exists, copy only relevant patterns, likely target paths, test/build setup, risks, and unknowns for the child.
+- If no parent scan exists, write:
+
+```markdown
+# Codebase Scan
+
+No parent codebase scan was available when this plan was split.
+```
+
+### Step 5: Write Split Manifest
+
+Write `.5/features/{parent-feature}/split-manifest-{YYYYMMDD-HHmmss}.json`:
+
+```json
+{
+  "parent": "{parent-feature}",
+  "sourcePlan": ".5/features/{parent-feature}/plan.md",
+  "createdAt": "{ISO-timestamp}",
+  "strategy": "implementation-independence",
+  "children": [
+    {
+      "index": 1,
+      "feature": "{child-feature}",
+      "plan": ".5/features/{child-feature}/plan.md",
+      "scope": "one-line child scope",
+      "dependsOn": []
+    }
+  ],
+  "rationale": "one concise paragraph explaining the split boundaries"
+}
+```
+
+Keep the parent `plan.md` unchanged.
+
+### Step 6: Report
+
+Output:
+
+```text
+Plan split complete.
+
+Parent: .5/features/{parent-feature}/plan.md
+Manifest: .5/features/{parent-feature}/split-manifest-{timestamp}.json
+
+Child plans:
+- .5/features/{child-1}/plan.md
+- .5/features/{child-2}/plan.md
+
+Implement separately with:
+/5:implement {child-1}
+/5:implement {child-2}
+```
+
+Stop immediately.

package/src/commands/5/synchronize-agents.md

@@ -4,7 +4,6 @@ description: Synchronize user-generated skills, rules, and custom content betwee
 allowed-tools: Bash, Read, AskUserQuestion
 user-invocable: true
 model: haiku
-context: fork
 ---
 
 <role>
@@ -20,14 +19,15 @@ Synchronizes user-generated content (skills, commands, agents, rules) between th
 
 The script is `bin/sync-agents.js` in the workflow package. Find it by checking these paths in order:
 
-1. `./bin/sync-agents.js` (development checkout / project root)
-2. `./node_modules/5-phase-workflow/bin/sync-agents.js` (local npm install)
+1. `./.claude/bin/sync-agents.js` (installed Claude Code runtime helper)
+2. `./bin/sync-agents.js` (development checkout / project root)
+3. `./node_modules/foifi/bin/sync-agents.js` (local npm install)
 
 Read `.5/version.json` if available — its location confirms the project root.
 
 Store the resolved path for the following steps.
 
-If the script cannot be found, tell the user: "Sync script not found. Update the workflow first: `npx 5-phase-workflow --upgrade`" and **stop**.
+If the script cannot be found, tell the user: "Sync script not found. Update the workflow first: `npx foifi --upgrade`" and **stop**.
 
 ## Step 2: Dry Run
 

package/src/commands/5/triage-pr-comments.md

@@ -0,0 +1,70 @@
+---
+name: 5:triage-pr-comments
+description: Fetches, compacts, and categorizes GitHub PR review comments for a feature.
+allowed-tools: Bash, Read, Write, AskUserQuestion, Agent
+user-invocable: false
+model: haiku
+argument-hint: [feature-name]
+---
+
+<role>
+You are a PR Comment Triage Coordinator. You reduce GitHub comment data before model analysis and record user decisions.
+</role>
+
+# Triage PR Comments
+
+## Process
+
+1. Find the PR for the current branch:
+   - `gh pr list --head "$(git branch --show-current)" --json number,url,title --limit 1`
+   - `gh repo view --json owner,name`
+2. Fetch comments:
+   - Inline: `gh api repos/{owner}/{repo}/pulls/{number}/comments --paginate`
+   - General: `gh api repos/{owner}/{repo}/issues/{number}/comments --paginate`
+3. Normalize before spawning an agent:
+   - Keep only `id`, `path`, `line`, `body`, `user.login`, `created_at`, `updated_at`, `in_reply_to_id`, and resolved/outdated flags.
+   - For issue comments, use `path: "PR"` and `line: 0`.
+   - Drop bot, empty, minimized, resolved, outdated, and duplicate records.
+   - Truncate bodies to the smallest useful actionable excerpt.
+4. Spawn one low-context agent to categorize compact records against local findings.
+5. Ask the user only about actionable/manual comments.
+6. Write decisions to `.5/features/{feature}/pr-comment-decisions.json`.
+
+## Categorization Prompt
+
+```text
+Categorize compact PR comments.
+
+Local findings:
+{file:line:description list or "none"}
+
+Comments:
+{compact records}
+
+Categories:
+- actionable_fix
+- duplicate
+- manual
+- skip
+
+Output:
+---PR-COMMENTS---
+{id} | {file}:{line} | {category} | {description} | {duplicate_of or "none"} | {recommendation or "n/a"} | {one-sentence reasoning or "n/a"}
+---END-PR-COMMENTS---
+```
+
+## Output
+
+End with:
+
+```text
+---PR-TRIAGE---
+STATUS: success | failed
+ACTIONABLE: {N}
+MANUAL: {N}
+DUPLICATE: {N}
+SKIPPED: {N}
+DECISIONS: .5/features/{feature}/pr-comment-decisions.json
+ERRORS: none | {compact summary}
+---END-PR-TRIAGE---
+```

package/src/commands/5/update.md

@@ -1,10 +1,10 @@
 ---
 name: 5:update
-description: Update the 5-Phase Workflow to the latest version
+description: Update dev-workflow to the latest version
 allowed-tools: Bash, Read, AskUserQuestion
 user-invocable: true
 model: haiku
-context: fork
+context: inherit
 ---
 
 <role>
@@ -13,7 +13,7 @@ You do NOT modify workflow files manually. You do NOT touch user project files.
 After reporting the result, you are DONE.
 </role>
 
-# Update 5-Phase Workflow
+# Update dev-workflow
 
 ## Step 1: Check Current Version
 
@@ -22,13 +22,13 @@ Read `.5/version.json` and note the current `installedVersion`.
 ## Step 2: Run Upgrade
 
 ```bash
-npx 5-phase-workflow@latest --upgrade
+npx foifi@latest --upgrade
 ```
 
 If this installation is running in Codex (workflow files live in `.codex/` or the workflow command was invoked as a `$5-...` skill), run this instead:
 
 ```bash
-npx 5-phase-workflow@latest --codex --upgrade
+npx foifi@latest --codex --upgrade
 ```
 
 ## Step 3: Confirm Upgrade
@@ -60,9 +60,9 @@ Read `.5/config.json` if it exists and extract `git.commitMessage.pattern` (defa
 
 Build the commit message by applying the pattern:
 - Replace `{ticket-id}` with an empty string (no ticket for upgrades) and trim any leading/trailing whitespace
-- Replace `{short-description}` with `update 5-Phase Workflow to {new-version}`
-- If the pattern is the conventional format (`feat({ticket-id}): {short-description}`), use: `chore: update 5-Phase Workflow to {new-version}`
-- If no config or no pattern, use: `update 5-Phase Workflow to {new-version}`
+- Replace `{short-description}` with `update dev-workflow to {new-version}`
+- If the pattern is the conventional format (`feat({ticket-id}): {short-description}`), use: `chore: update dev-workflow to {new-version}`
+- If no config or no pattern, use: `update dev-workflow to {new-version}`
 
 Stage **only** the workflow-managed files shown in `git status`.
 

package/src/hooks/check-updates.js

@@ -68,7 +68,7 @@ async function getLatestVersion() {
   return new Promise((resolve) => {
     const https = require('https');
     const req = https.get(
-      'https://registry.npmjs.org/5-phase-workflow/latest',
+      'https://registry.npmjs.org/foifi/latest',
       { timeout: 3000 },
       (res) => {
         if (res.statusCode !== 200) {
@@ -95,15 +95,58 @@ async function getLatestVersion() {
   });
 }
 
-// Compare semver versions
-// Uses parseInt to handle pre-release tags (e.g., "2-beta" → 2)
+// Compare semver versions, including pre-release ordering
 function compareVersions(v1, v2) {
-  const parts1 = v1.split('.').map(p => parseInt(p, 10) || 0);
-  const parts2 = v2.split('.').map(p => parseInt(p, 10) || 0);
+  const parsed1 = parseSemver(v1);
+  const parsed2 = parseSemver(v2);
 
   for (let i = 0; i < 3; i++) {
-    if (parts1[i] > parts2[i]) return 1;
-    if (parts1[i] < parts2[i]) return -1;
+    if (parsed1.core[i] > parsed2.core[i]) return 1;
+    if (parsed1.core[i] < parsed2.core[i]) return -1;
+  }
+
+  return comparePrerelease(parsed1.prerelease, parsed2.prerelease);
+}
+
+function parseSemver(version) {
+  const normalized = String(version || '').trim().replace(/^v/, '').split('+')[0];
+  const prereleaseIndex = normalized.indexOf('-');
+  const corePart = prereleaseIndex === -1 ? normalized : normalized.slice(0, prereleaseIndex);
+  const prereleasePart = prereleaseIndex === -1 ? '' : normalized.slice(prereleaseIndex + 1);
+  const core = corePart.split('.').slice(0, 3).map(part => parseInt(part, 10) || 0);
+  while (core.length < 3) core.push(0);
+
+  return {
+    core,
+    prerelease: prereleasePart ? prereleasePart.split(/[.-]/) : []
+  };
+}
+
+function comparePrerelease(pre1, pre2) {
+  if (pre1.length === 0 && pre2.length === 0) return 0;
+  if (pre1.length === 0) return 1;
+  if (pre2.length === 0) return -1;
+
+  const length = Math.max(pre1.length, pre2.length);
+  for (let i = 0; i < length; i++) {
+    const id1 = pre1[i];
+    const id2 = pre2[i];
+    if (id1 === undefined) return -1;
+    if (id2 === undefined) return 1;
+    if (id1 === id2) continue;
+
+    const id1Numeric = /^[0-9]+$/.test(id1);
+    const id2Numeric = /^[0-9]+$/.test(id2);
+    if (id1Numeric && id2Numeric) {
+      const n1 = parseInt(id1, 10);
+      const n2 = parseInt(id2, 10);
+      if (n1 > n2) return 1;
+      if (n1 < n2) return -1;
+      continue;
+    }
+    if (id1Numeric) return -1;
+    if (id2Numeric) return 1;
+    return id1 > id2 ? 1 : -1;
   }
 
   return 0;

package/src/hooks/plan-guard.js

@@ -48,8 +48,8 @@ process.stdin.on('end', () => {
         ? ` CRITICAL: Block #${blockCount}. You have attempted to break out of planning ${blockCount} times. You MUST return to your current step in the Progress Checklist, complete your planning artifact, output the completion message, and STOP. Do NOT attempt any other action.`
         : '';
       process.stderr.write(
-        `BLOCKED: EnterPlanMode is not allowed during workflow planning phases. ` +
-        `The 5-phase workflow has its own planning process. ` +
+        `BLOCKED: EnterPlanMode is not allowed during workflow planning. ` +
+        `dev-workflow has its own planning process. ` +
         `REDIRECT: You are in ${phase || 'a planning phase'}. Return to your Progress Checklist. ` +
         `Find the last "✓ Step N complete" you output, then continue with Step N+1. ` +
         `Write your output to .5/features/{name}/ and output the completion message when done.${escalation}`
@@ -63,12 +63,12 @@ process.stdin.on('end', () => {
         const blockCount = incrementBlockCount(workspaceDir);
         const phase = getPlanningPhase(workspaceDir);
         const escalation = blockCount >= 3
-          ? ` CRITICAL: Block #${blockCount}. You are a planner, NOT an implementer. You have attempted to spawn non-Explore agents ${blockCount} times. This is Phase 1 or 2 — implementation happens in Phase 3. Return to your Progress Checklist immediately, complete your planning artifact, and STOP.`
+          ? ` CRITICAL: Block #${blockCount}. You are a planner, NOT an implementer. You have attempted to spawn non-Explore agents ${blockCount} times. Implementation happens in /5:implement. Return to your Progress Checklist immediately, complete your planning artifact, and STOP.`
           : '';
         process.stderr.write(
-          `BLOCKED: Only Explore agents are allowed during planning phases. ` +
+          `BLOCKED: Only Explore agents are allowed during planning. ` +
           `Attempted: subagent_type="${agentType}". ` +
-          `You are in ${phase || 'a planning phase'}. Implementation agents are Phase 3 only. ` +
+          `You are in ${phase || 'the planning phase'}. Implementation agents are /5:implement only. ` +
           `REDIRECT: Return to your Progress Checklist. Find your last "✓ Step N complete" and continue with Step N+1. ` +
           `If you need codebase information, use subagent_type=Explore. ` +
           `If you are done planning, output the completion message and STOP.${escalation}`
@@ -88,8 +88,8 @@ process.stdin.on('end', () => {
           ? ` CRITICAL: Block #${blockCount}. You are repeatedly attempting to write files via Bash to bypass planning guards. STOP immediately.`
           : '';
         process.stderr.write(
-          `BLOCKED: File-writing Bash commands are not allowed during planning phases. ` +
-          `You are in ${phase || 'a planning phase'}. ` +
+          `BLOCKED: File-writing Bash commands are not allowed during planning. ` +
+          `You are in ${phase || 'the planning phase'}. ` +
           `REDIRECT: Return to your Progress Checklist. Planners do not create or modify source files. ` +
           `Complete your planning artifact and output the completion message.${escalation}`
         );
@@ -110,33 +110,32 @@ process.stdin.on('end', () => {
         const blockCount = incrementBlockCount(workspaceDir);
         const isSourceFile = !filePath.includes('.5/') && !filePath.includes('.claude/');
         const escalation = blockCount >= 3
-          ? ` CRITICAL: Block #${blockCount}. You have attempted to write source files ${blockCount} times. You are a PLANNER, not an implementer. Writing source code is Phase 3's job. Return to your Progress Checklist, finish your planning artifact, and STOP.`
+          ? ` CRITICAL: Block #${blockCount}. You have attempted to write source files ${blockCount} times. You are a PLANNER, not an implementer. Writing source code is /5:implement's job. Return to your Progress Checklist, finish your planning artifact, and STOP.`
           : '';
         const redirectMsg = isSourceFile
-          ? `REDIRECT: You are in ${phase || 'a planning phase'}. You may ONLY write to .5/features/. ` +
-            `Source file creation happens in Phase 3 (/5:implement-feature). ` +
+          ? `REDIRECT: You are in ${phase || 'the planning phase'}. You may ONLY write to .5/features/. ` +
+            `Source file creation happens in /5:implement. ` +
             `Return to your Progress Checklist — find your last "✓ Step N complete" and continue with Step N+1.`
           : `REDIRECT: The path "${filePath}" is outside the allowed .5/ directory. ` +
             `Check your file path — you should be writing to .5/features/{name}/.`;
         process.stderr.write(
-          `BLOCKED: ${toolName} outside .5/ is not allowed during planning phases. ` +
+          `BLOCKED: ${toolName} outside .5/ is not allowed during planning. ` +
           `Attempted: "${filePath}". ${redirectMsg}${escalation}`
         );
         process.exit(2);
       }
 
-      // Second check: during plan-feature, only allow specific files
-      if (phase === 'plan-feature' && !isAllowedPlanFeatureFile(filePath, workspaceDir)) {
+      // Second check: during plan, only allow specific files
+      if (normalizePlanningPhase(phase) === 'plan' && !isAllowedPlanFile(filePath, workspaceDir)) {
         const blockCount = incrementBlockCount(workspaceDir);
         const escalation = blockCount >= 3
-          ? ` CRITICAL: Block #${blockCount}. You are attempting to create implementation artifacts during Phase 1. Phase 1 ONLY produces feature.md. STOP and output your completion message.`
+          ? ` CRITICAL: Block #${blockCount}. You are attempting to create implementation artifacts during planning. Planning ONLY produces plan.md and codebase-scan.md. STOP and output your completion message.`
           : '';
         process.stderr.write(
-          `BLOCKED: During plan-feature (Phase 1), you may only write to .planning-active, codebase-scan.md, and feature.md. ` +
+          `BLOCKED: During plan, you may only write to .planning-active, codebase-scan.md, and plan.md. ` +
           `Attempted: "${filePath}". ` +
-          `You are creating implementation artifacts (e.g., plan.md) which belongs to Phase 2. ` +
-          `REDIRECT: If you have already written feature.md, output the completion message and STOP. ` +
-          `Do NOT create implementation plans, file lists, or any other artifacts.${escalation}`
+          `REDIRECT: If you have already written plan.md, output the completion message and STOP. ` +
+          `Do NOT create source files or state.json during planning.${escalation}`
         );
         process.exit(2);
       }
@@ -149,18 +148,18 @@ process.stdin.on('end', () => {
   }
 });
 
-function isAllowedPlanFeatureFile(filePath, workspaceDir) {
+function isAllowedPlanFile(filePath, workspaceDir) {
   const resolved = path.resolve(workspaceDir, filePath);
   const dotFiveDir = path.join(workspaceDir, '.5');
 
   // Allow .5/.planning-active
   if (resolved === path.join(dotFiveDir, '.planning-active')) return true;
 
-  // Allow .5/features/{name}/feature.md and .5/features/{name}/codebase-scan.md
+  // Allow .5/features/{name}/plan.md and .5/features/{name}/codebase-scan.md
   const featuresDir = path.join(dotFiveDir, 'features');
   if (resolved.startsWith(featuresDir + path.sep)) {
     const basename = path.basename(resolved);
-    if (basename === 'feature.md' || basename === 'codebase-scan.md') return true;
+    if (basename === 'plan.md' || basename === 'codebase-scan.md') return true;
   }
 
   return false;
@@ -254,8 +253,15 @@ function getPlanningPhase(workspaceDir) {
   }
 }
 
+function normalizePlanningPhase(phase) {
+  if (!phase) return 'plan';
+  if (phase === 'plan-feature' || phase === 'plan-implementation') return 'plan';
+  if (phase === 'plan') return 'plan';
+  return 'plan';
+}
+
 function isFeatureInImplementationMode(workspaceDir, featureName) {
-  // Check if this specific feature has a state.json (created in Phase 3)
+  // Check if this specific feature has a state.json (created by /5:implement)
   const stateFile = path.join(
     workspaceDir, '.5', 'features', featureName, 'state.json'
   );

package/src/hooks/statusline.js

@@ -113,6 +113,11 @@ process.stdin.on('end', () => {
       if (fs.existsSync(flagFile)) {
         parts.push(`\x1b[35m↻ /5:reconfigure\x1b[0m`);
       }
+
+      const migrationFlag = path.join(dir, '.5', '.migration-v2');
+      if (fs.existsSync(migrationFlag)) {
+        parts.push(`\x1b[31m⚠ v1→v2: /5:reconfigure\x1b[0m`);
+      }
     } catch (e) {}
 
     process.stdout.write(parts.join(' | '));
@@ -124,11 +129,57 @@ process.stdin.on('end', () => {
 
 // Compare semver versions: returns -1 if v1 < v2, 0 if equal, 1 if v1 > v2
 function compareVersions(v1, v2) {
-  const parts1 = v1.split('.').map(p => parseInt(p, 10) || 0);
-  const parts2 = v2.split('.').map(p => parseInt(p, 10) || 0);
+  const parsed1 = parseSemver(v1);
+  const parsed2 = parseSemver(v2);
+
   for (let i = 0; i < 3; i++) {
-    if (parts1[i] > parts2[i]) return 1;
-    if (parts1[i] < parts2[i]) return -1;
+    if (parsed1.core[i] > parsed2.core[i]) return 1;
+    if (parsed1.core[i] < parsed2.core[i]) return -1;
   }
+
+  return comparePrerelease(parsed1.prerelease, parsed2.prerelease);
+}
+
+function parseSemver(version) {
+  const normalized = String(version || '').trim().replace(/^v/, '').split('+')[0];
+  const prereleaseIndex = normalized.indexOf('-');
+  const corePart = prereleaseIndex === -1 ? normalized : normalized.slice(0, prereleaseIndex);
+  const prereleasePart = prereleaseIndex === -1 ? '' : normalized.slice(prereleaseIndex + 1);
+  const core = corePart.split('.').slice(0, 3).map(part => parseInt(part, 10) || 0);
+  while (core.length < 3) core.push(0);
+
+  return {
+    core,
+    prerelease: prereleasePart ? prereleasePart.split(/[.-]/) : []
+  };
+}
+
+function comparePrerelease(pre1, pre2) {
+  if (pre1.length === 0 && pre2.length === 0) return 0;
+  if (pre1.length === 0) return 1;
+  if (pre2.length === 0) return -1;
+
+  const length = Math.max(pre1.length, pre2.length);
+  for (let i = 0; i < length; i++) {
+    const id1 = pre1[i];
+    const id2 = pre2[i];
+    if (id1 === undefined) return -1;
+    if (id2 === undefined) return 1;
+    if (id1 === id2) continue;
+
+    const id1Numeric = /^[0-9]+$/.test(id1);
+    const id2Numeric = /^[0-9]+$/.test(id2);
+    if (id1Numeric && id2Numeric) {
+      const n1 = parseInt(id1, 10);
+      const n2 = parseInt(id2, 10);
+      if (n1 > n2) return 1;
+      if (n1 < n2) return -1;
+      continue;
+    }
+    if (id1Numeric) return -1;
+    if (id2Numeric) return 1;
+    return id1 > id2 ? 1 : -1;
+  }
+
   return 0;
 }