pi-bmad-flow 0.1.0

package/README.md

@@ -0,0 +1,111 @@
+# pi-bmad-flow
+
+Pi-native orchestration overlay for BMAD.
+
+This package is designed to run on top of:
+
+1. upstream `pi`
+2. official BMAD install targeting `pi`
+
+It adds a thin control plane for phase routing and story-loop automation.
+
+## Install in a BMAD project
+
+Install Pi and BMAD first, then install this package into the project:
+
+```bash
+npm install -g @mariozechner/pi-coding-agent
+cd /path/to/project
+npx bmad-method install
+pi install -l npm:pi-bmad-flow```
+
+For early access builds before npm publish, install from git or a local path:
+
+```bash
+pi install -l git:github.com/<your-org>/pi-bmad-flow
+pi install -l /absolute/path/to/pi-bmad-flow
+```
+
+After install, open `pi` in the project and run:
+
+```text
+/bmad-status
+```
+
+Recommended BMAD modules for this overlay:
+
+- core
+- bmm
+- cis
+- wds
+- tea
+- bmb
+
+Package docs:
+
+- [`docs/install-model.md`](./docs/install-model.md)
+- [`docs/workflow-wireframe.md`](./docs/workflow-wireframe.md)
+
+## Publish
+
+From `pi-bmad-flow/`:
+
+```bash
+npm run check
+npm run smoke:fixture
+npm publish --access public
+```
+
+`prepublishOnly` also runs package validation automatically before publish.
+
+If `pi-bmad-flow` is already taken on npm, choose another unscoped name in `package.json`, run `npm view <name>` to confirm availability, and publish that name instead.
+
+## Validate against a project
+
+```bash
+npm run audit:project -- --project-dir /absolute/path/to/project
+```
+
+## Expected project layout
+
+The extension expects standard BMAD folders:
+
+- `_bmad/`
+- `_bmad-output/planning-artifacts/`
+- `_bmad-output/implementation-artifacts/`
+
+Optional:
+
+- `design-artifacts/`
+- `docs/`
+
+## Commands
+
+- `/bmad-next`
+- `/bmad-start`
+- `/bmad-review`
+- `/bmad-gate`
+- `/bmad-status`
+- `/bmad-phase`
+
+## Current scope
+
+This overlay keeps BMAD adaptation inside Pi-native runtime features instead of prompt wrappers.
+
+Current behavior:
+
+- BMAD detection
+- module detection
+- artifact-aware phase detection
+- sprint status parsing
+- next-step routing
+- plain-English BMAD intent routing through Pi input interception
+- dedicated story sessions created by `/bmad-start`
+- lean versus full packet selection
+- WDS-aware packet assembly for UI stories
+- TEA-aware review and gate routing
+- BMAD-specific compaction summaries
+- lightweight BMAD status widget and footer state
+- optional LLM access to deterministic BMAD state through the `bmad_orchestrator` tool
+
+This package does not replace official BMAD workflows. It reduces routing overhead around them.

package/docs/install-model.md

@@ -0,0 +1,64 @@
+# Install Model
+
+`pi-bmad-flow` is a thin overlay. It should not replace either `pi` or BMAD.
+
+## Recommended install order
+
+1. Install upstream `pi`
+2. Install official BMAD into the project
+3. Install `pi-bmad-flow` project-locally
+
+```bash
+npm install -g @mariozechner/pi-coding-agent
+cd /path/to/project
+npx bmad-method install
+pi install -l /absolute/path/to/pi-bmad-flow
+```
+
+## BMAD installer choices
+
+Use the official BMAD installer and keep your existing module selection:
+
+- `BMad Core Module`
+- `BMad Method Agile-AI Driven-Development`
+- `BMad Builder`
+- `BMad Creative Intelligence Suite`
+- `Test Architect`
+- `Whiteport Design Studio`
+
+That gives you the official artifact model under `_bmad/` and `_bmad-output/`. `pi-bmad-flow` reads that structure and adds orchestration on top.
+
+## Why this install shape is correct
+
+- Upstream `pi` stays updateable without maintaining a fork.
+- Official BMAD stays updateable without maintaining a fork.
+- Your custom behavior lives in one overlay package that can evolve independently.
+- If BMAD changes, the overlay can adapt at the routing layer instead of forcing a reinstall strategy rewrite.
+
+## Day-to-day usage
+
+Inside a BMAD project:
+
+```bash
+pi
+```
+
+Then use:
+
+- `/bmad-status`
+- `/bmad-next`
+- `/bmad-start`
+- `/bmad-review`
+- `/bmad-gate`
+
+`/bmad-start` should be the normal entry into implementation. It creates a dedicated Pi story session, attaches lean or full packet guidance, and keeps the planning session clean.
+
+## Distribution model for your version
+
+Your install story should become:
+
+1. User installs upstream `pi`
+2. User runs official BMAD installer with the module set you standardize
+3. User installs your overlay package
+
+Later, you can wrap this with a bootstrap script, but the bootstrap should still execute the same three layers under the hood. Do not hard-fork BMAD unless upstream compatibility stops mattering.

package/docs/workflow-wireframe.md

@@ -0,0 +1,122 @@
+# Workflow Wireframe
+
+This is the Pi-native BMAD operating loop optimized for low token usage, high reliability, and minimal manual routing.
+
+## Operating model
+
+```text
+Install Project
+  -> official BMAD install
+  -> install pi-bmad-flow overlay
+  -> start pi
+
+Project Start
+  -> /bmad-status
+  -> /bmad-next
+  -> overlay identifies missing phase artifact
+
+Planning Loop
+  -> create PRD
+  -> create UX/WDS artifacts
+  -> create architecture
+  -> create epics and stories
+  -> run implementation-readiness gate
+
+Delivery Loop
+  -> /bmad-start
+  -> overlay selects next ready story
+  -> overlay opens a dedicated Pi story session
+  -> overlay chooses lean or full packet
+  -> BMAD dev workflow executes story inside that story session
+  -> /bmad-review
+  -> /bmad-gate
+  -> story moves forward in sprint-status.yaml
+
+Epic Completion
+  -> retrospective
+  -> next epic
+```
+
+## Human role
+
+You should make fewer routing decisions and more approval decisions.
+
+Your job becomes:
+
+- approve planning outputs
+- approve story boundaries
+- intervene on ambiguous tradeoffs
+- inspect review findings when risk is high
+
+Pi should take over:
+
+- phase detection
+- next-step routing
+- story pickup
+- lean versus full context selection
+- story-session setup
+- gate selection
+
+## Recommended lane split
+
+Use two planning lanes, but keep one delivery loop.
+
+### Lane A: BMAD core
+
+- `bmad-create-prd`
+- `bmad-create-architecture`
+- `bmad-create-epics-and-stories`
+- `bmad-check-implementation-readiness`
+
+### Lane B: WDS depth
+
+- UX and scenario work
+- page specs
+- design delivery
+- design system artifacts when reusable UI matters
+
+The overlay should treat WDS artifacts as implementation inputs, not parallel decoration. That means UI stories should pull WDS page specs into the packet automatically when present.
+
+## Token minimization strategy
+
+Default to lean packets.
+
+Use full packets only when:
+
+- story is security, auth, billing, migration, infra, or public API related
+- project-context is missing or weak
+- architecture is still unstable
+- story is UI-heavy and depends on multiple WDS artifacts
+
+Lean packet should usually include:
+
+- current story file
+- project-context if present
+- relevant architecture section
+- relevant WDS or UX file only if the story touches UI
+
+Full packet adds:
+
+- PRD context
+- prior review or retrospective notes
+- additional architecture and WDS support files
+
+## Reliability rules
+
+- Never begin dev without a story file.
+- Never start a new story while another is `in-progress`.
+- Never skip architecture for medium or large work.
+- Never treat WDS outputs as optional for UI-heavy stories.
+- Never let operational session metadata become the source of truth over BMAD artifacts.
+
+## Best install experience for your eventual distribution
+
+The cleanest user flow is:
+
+1. `npx bmad-method install`
+2. choose your standard BMAD module set
+3. `pi install -l your-overlay-package`
+4. open `pi`
+5. run `/bmad-status`
+
+That keeps installation simple and preserves upstream compatibility.

package/extensions/bmad-orchestrator/commands.ts

@@ -0,0 +1,238 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { detectBmadInstall, detectBmadProjectState } from "./detector.js";
+import { decideGate } from "./gates.js";
+import { buildStoryPacket, packetHint, selectPacketMode } from "./packets.js";
+import { decideNextAction } from "./router.js";
+import { updateStoryStatus } from "./sprint.js";
+import type { GatePlan, StoryPacket } from "./types.js";
+import { refreshBmadUi } from "./ui.js";
+
+function now(): string {
+  return new Date().toISOString();
+}
+
+function appendBmadState(
+  pi: ExtensionAPI,
+  payload: {
+    event: "status" | "next" | "story-start" | "review" | "gate";
+    storyKey?: string;
+    packetMode?: "lean" | "full";
+    nextCommand?: string;
+    gateLevel?: "lightweight" | "strong";
+    files?: string[];
+  },
+): void {
+  pi.appendEntry("bmad-state", {
+    ...payload,
+    generatedAt: now(),
+  });
+}
+
+function formatPacketLaunchMessage(story: string, packet: StoryPacket): string {
+  const lines = [
+    `You are now in the dedicated story session for ${story}.`,
+    "",
+    `Start implementation with packet mode: ${packet.mode}`,
+    ...packet.notes.map((note) => `- ${note}`),
+  ];
+
+  if (packet.files.length > 0) {
+    lines.push("", "Load these files first:");
+    lines.push(...packet.files.map((file) => `- ${file}`));
+  }
+
+  lines.push("", `Then run the BMAD delivery workflow for ${story} and keep this session focused on that story only.`);
+  return lines.join("\n");
+}
+
+function formatGateMessage(plan: GatePlan): string {
+  const lines = [
+    `Gate level: ${plan.level}`,
+    `Reason: ${plan.reason}`,
+    "",
+    "Run these workflows in order:",
+    ...plan.commands.map((command, index) => `${index + 1}. ${command}`),
+  ];
+
+  if (plan.evidenceFiles.length > 0) {
+    lines.push("", "Available TEA evidence:");
+    lines.push(...plan.evidenceFiles.map((file) => `- ${file}`));
+  }
+
+  return lines.join("\n");
+}
+
+export function registerBmadCommands(pi: ExtensionAPI, cwd: string): void {
+  pi.registerCommand("bmad-status", {
+    description: "Show BMAD install, phase, and story queue status",
+    handler: async (_args, ctx) => {
+      const install = detectBmadInstall(cwd);
+      const state = detectBmadProjectState(cwd);
+      const next = decideNextAction(state);
+      const moduleText = install.modules.length > 0 ? install.modules.join(", ") : "none";
+      const planningSummary = `PRD ${state.inventory.prdFiles.length}, UX ${state.inventory.uxFiles.length}, Architecture ${state.inventory.architectureFiles.length}, Epics ${state.inventory.epicFiles.length}`;
+      const deliverySummary = `Stories ${state.inventory.storyFiles.length}, Reviews ${state.inventory.reviewFiles.length}, Sprint ${state.hasSprintStatus ? "yes" : "no"}`;
+      const designSummary = `WDS scenarios ${state.inventory.wdsScenarioFiles.length}, page specs ${state.inventory.wdsPageSpecFiles.length}, deliveries ${state.inventory.wdsDeliveryFiles.length}`;
+      const teaSummary = `TEA reviews ${state.inventory.teaReviewFiles.length}, trace ${state.inventory.teaTraceFiles.length}, NFR ${state.inventory.teaNfrFiles.length}`;
+
+      ctx.ui.notify(`BMAD installed: ${install.installed ? "yes" : "no"}`, "info");
+      ctx.ui.notify(`Modules: ${moduleText}`, "info");
+      ctx.ui.notify(`Phase: ${state.phase}`, "info");
+      ctx.ui.notify(`Planning: ${planningSummary}`, "info");
+      ctx.ui.notify(`Delivery: ${deliverySummary}`, "info");
+      ctx.ui.notify(`Design: ${designSummary}`, "info");
+      ctx.ui.notify(`TEA: ${teaSummary}`, "info");
+      ctx.ui.notify(`Next: ${next.command} - ${next.summary}`, "info");
+
+      refreshBmadUi(ctx, state, next);
+      appendBmadState(pi, { event: "status", nextCommand: next.command });
+    },
+  });
+
+  pi.registerCommand("bmad-phase", {
+    description: "Show current workflow phase and recommended route",
+    handler: async (_args, ctx) => {
+      const state = detectBmadProjectState(cwd);
+      const next = decideNextAction(state);
+      ctx.ui.notify(`Current phase: ${state.phase}`, "info");
+      ctx.ui.notify(
+        `Artifacts: PRD ${state.inventory.prdFiles.length}, UX ${state.inventory.uxFiles.length}, Architecture ${state.inventory.architectureFiles.length}, Stories ${state.inventory.storyFiles.length}`,
+        "info",
+      );
+      ctx.ui.notify(`Recommended: ${next.command} (${next.reason})`, "info");
+      refreshBmadUi(ctx, state, next);
+      appendBmadState(pi, { event: "status", nextCommand: next.command });
+    },
+  });
+
+  pi.registerCommand("bmad-next", {
+    description: "Determine next action from BMAD artifacts",
+    handler: async (_args, ctx) => {
+      const install = detectBmadInstall(cwd);
+      if (!install.installed) {
+        ctx.ui.notify("No BMAD installation detected at _bmad/_config/manifest.yaml", "warning");
+        return;
+      }
+
+      const state = detectBmadProjectState(cwd);
+      const next = decideNextAction(state);
+      ctx.ui.notify(next.summary, "info");
+      ctx.ui.notify(`Recommended command: ${next.command}`, "info");
+      refreshBmadUi(ctx, state, next);
+      appendBmadState(pi, { event: "next", nextCommand: next.command });
+
+      if (!ctx.hasUI) return;
+      const shouldLaunch = await ctx.ui.confirm("Launch recommended workflow?", next.command);
+      if (shouldLaunch) {
+        pi.sendUserMessage(next.command, { source: "extension" });
+      }
+    },
+  });
+
+  pi.registerCommand("bmad-start", {
+    description: "Start the next ready story in a dedicated story session with lean/full packet selection",
+    handler: async (_args, ctx) => {
+      const install = detectBmadInstall(cwd);
+      const state = detectBmadProjectState(cwd);
+
+      if (!install.installed || !state.hasSprintStatus) {
+        ctx.ui.notify("BMAD sprint status not found. Run bmad-sprint-planning first.", "warning");
+        return;
+      }
+
+      const story = state.nextReadyStory;
+      if (!story) {
+        ctx.ui.notify("No ready-for-dev story found. Run bmad-create-story first.", "warning");
+        return;
+      }
+
+      const mode = selectPacketMode(state);
+      const packet = buildStoryPacket(state, story, mode);
+      const statusUpdated = updateStoryStatus(install.paths.sprintStatusPath, story, "in-progress");
+      if (!statusUpdated) {
+        ctx.ui.notify(`Could not update sprint status for ${story}.`, "warning");
+      }
+
+      const originLeafId = ctx.sessionManager.getLeafId();
+      if (originLeafId) {
+        pi.setLabel(originLeafId, `handoff:${story}`);
+      }
+
+      await ctx.waitForIdle();
+      const sessionResult = await ctx.newSession({
+        parentSession: ctx.sessionManager.getSessionFile(),
+      });
+      if (sessionResult.cancelled) {
+        ctx.ui.notify("Story session creation was cancelled.", "warning");
+        return;
+      }
+
+      pi.setSessionName(`Story ${story}`);
+      appendBmadState(pi, {
+        event: "story-start",
+        storyKey: story,
+        packetMode: mode,
+        files: packet.files,
+      });
+
+      ctx.ui.notify(`Opened story session for ${story}`, "info");
+      ctx.ui.notify(packetHint(mode), "info");
+      if (packet.uiRelevant) {
+        ctx.ui.notify("WDS artifacts were added because this appears to be a UI-facing story.", "info");
+      }
+
+      const refreshedState = detectBmadProjectState(cwd);
+      const refreshedNext = decideNextAction(refreshedState);
+      refreshBmadUi(ctx, refreshedState, refreshedNext);
+      pi.sendUserMessage(formatPacketLaunchMessage(story, packet), { source: "extension" });
+    },
+  });
+
+  pi.registerCommand("bmad-review", {
+    description: "Run review workflow for active story",
+    handler: async (_args, ctx) => {
+      const state = detectBmadProjectState(cwd);
+      const story = state.activeStory ?? state.nextReadyStory;
+      if (!story) {
+        ctx.ui.notify("No active or ready story found to review.", "warning");
+        return;
+      }
+
+      ctx.ui.notify(`Running review for ${story}`, "info");
+      appendBmadState(pi, { event: "review", storyKey: story });
+      refreshBmadUi(ctx, state, decideNextAction(state));
+      pi.sendUserMessage(`bmad-code-review ${story}`, { source: "extension" });
+    },
+  });
+
+  pi.registerCommand("bmad-gate", {
+    description: "Run lightweight or TEA quality gate based on risk",
+    handler: async (_args, ctx) => {
+      const install = detectBmadInstall(cwd);
+      const state = detectBmadProjectState(cwd);
+      const story = state.activeStory ?? state.nextReadyStory;
+      if (!story) {
+        ctx.ui.notify("No active or ready story found to gate.", "warning");
+        return;
+      }
+      const decision = decideGate(state, install.modules.includes("tea"));
+      const plan: GatePlan = {
+        storyKey: story,
+        level: decision.level,
+        reason: decision.reason,
+        commands: decision.commands,
+        evidenceFiles: decision.evidenceFiles,
+        generatedAt: now(),
+      };
+      ctx.ui.notify(`Gate: ${decision.level}`, "info");
+      ctx.ui.notify(decision.reason, "info");
+      ctx.ui.notify(`Commands: ${decision.commands.length}`, "info");
+      if (decision.evidenceFiles.length > 0) {
+        ctx.ui.notify(`Evidence files: ${decision.evidenceFiles.length}`, "info");
+      }
+      appendBmadState(pi, { event: "gate", storyKey: story, gateLevel: decision.level });
+      refreshBmadUi(ctx, state, decideNextAction(state));
+      pi.sendUserMessage(formatGateMessage(plan), { source: "extension" });
+    },
+  });
+}

package/extensions/bmad-orchestrator/detector.ts

@@ -0,0 +1,168 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { collectMarkdownFiles, collectYamlFiles } from "./files.js";
+import { loadSprintStatus, resolveStoryLocation } from "./sprint.js";
+import type { ArtifactInventory, BmadInstallState, BmadPaths, BmadPhase, BmadProjectState } from "./types.js";
+
+function matches(files: string[], pattern: RegExp): string[] {
+  return files.filter((file) => pattern.test(file.toLowerCase()));
+}
+
+function unique(files: string[]): string[] {
+  return Array.from(new Set(files)).sort();
+}
+
+function collectStructuredFiles(dirPath: string): string[] {
+  return unique([...collectMarkdownFiles(dirPath), ...collectYamlFiles(dirPath)]);
+}
+
+function detectInventory(paths: BmadPaths): ArtifactInventory {
+  const sprint = loadSprintStatus(paths.sprintStatusPath);
+  const storyLocationDir = resolveStoryLocation(paths.sprintStatusPath, sprint);
+  const planningFiles = collectMarkdownFiles(paths.planningArtifactsDir);
+  const implementationFiles = collectMarkdownFiles(paths.implementationArtifactsDir);
+  const storyLocationFiles =
+    storyLocationDir !== paths.implementationArtifactsDir ? collectMarkdownFiles(storyLocationDir) : implementationFiles;
+  const designFiles = collectStructuredFiles(paths.designArtifactsDir);
+  const docsFiles = collectStructuredFiles(paths.docsDir);
+  const teaFiles = unique([
+    ...collectStructuredFiles(paths.teaArtifactsDir),
+    ...collectStructuredFiles(join(paths.root, "test-artifacts")),
+  ]);
+  const allContextFiles = unique([
+    ...planningFiles,
+    ...implementationFiles,
+    ...storyLocationFiles,
+    ...designFiles,
+    ...docsFiles,
+    ...teaFiles,
+  ]);
+
+  const wdsScenarioFiles = matches(allContextFiles, /\/c-ux-scenarios\//);
+  const wdsPageSpecFiles = matches(
+    allContextFiles,
+    /\/c-ux-scenarios\/.*(specifications\.md|page-spec|page-specification|\/frontend\/.*\.md)/,
+  );
+  const wdsStoryboardFiles = matches(allContextFiles, /storyboard/);
+  const wdsDeliveryFiles = matches(allContextFiles, /(design-deliver(y|ies)|\/deliveries\/|dd-\d+)/);
+  const wdsDesignSystemFiles = matches(allContextFiles, /\/d-design-system\//);
+  const wdsProgressFiles = matches(allContextFiles, /\/_progress\/00-design-log\.md$|scenario-tracking\.ya?ml|validation-report\.md/);
+  const teaTraceFiles = matches(allContextFiles, /traceability|gate-decision/);
+  const teaReviewFiles = matches(allContextFiles, /test-review/);
+  const teaNfrFiles = matches(allContextFiles, /nfr-assessment|nfr-report/);
+  const teaAutomationFiles = matches(allContextFiles, /automation-summary|atdd-checklist/);
+
+  return {
+    planningFiles,
+    implementationFiles,
+    designFiles,
+    docsFiles,
+    teaFiles,
+    prdFiles: matches(allContextFiles, /(^|\/)(prd|.*prd.*)\.md$/),
+    uxFiles: matches(
+      allContextFiles,
+      /(ux|wds-|wireframe|storyboard|page-spec|page-specification|design-delivery|scenario)/,
+    ),
+    architectureFiles: matches(allContextFiles, /architecture|adr/),
+    epicFiles: matches(allContextFiles, /(^|\/)epics?\/|epic-/),
+    storyFiles: matches(allContextFiles, /(^|\/)story-.*\.md$/),
+    reviewFiles: matches(allContextFiles, /review|retrospective|readiness-report|validation-report/),
+    projectContextFiles: matches(allContextFiles, /project-context/),
+    wdsScenarioFiles,
+    wdsPageSpecFiles,
+    wdsStoryboardFiles,
+    wdsDeliveryFiles,
+    wdsDesignSystemFiles,
+    wdsProgressFiles,
+    teaTraceFiles,
+    teaReviewFiles,
+    teaNfrFiles,
+    teaAutomationFiles,
+  };
+}
+
+function detectPhase(inventory: ArtifactInventory, hasSprintStatus: boolean): BmadPhase {
+  if (inventory.prdFiles.length === 0 && inventory.uxFiles.length === 0 && inventory.architectureFiles.length === 0) {
+    return "discovery";
+  }
+
+  if ((inventory.prdFiles.length > 0 || inventory.uxFiles.length > 0) && inventory.architectureFiles.length === 0) {
+    return "planning";
+  }
+
+  if ((inventory.architectureFiles.length > 0 || inventory.epicFiles.length > 0) && !hasSprintStatus) {
+    return "solutioning";
+  }
+
+  if (hasSprintStatus && inventory.storyFiles.length === 0) {
+    return "implementation-setup";
+  }
+
+  return "delivery";
+}
+
+export function getBmadPaths(cwd: string): BmadPaths {
+  const root = cwd;
+  const bmadDir = join(root, "_bmad");
+  const planningArtifactsDir = join(root, "_bmad-output", "planning-artifacts");
+  const implementationArtifactsDir = join(root, "_bmad-output", "implementation-artifacts");
+
+  return {
+    root,
+    bmadDir,
+    manifestPath: join(bmadDir, "_config", "manifest.yaml"),
+    planningArtifactsDir,
+    implementationArtifactsDir,
+    teaArtifactsDir: join(root, "_bmad-output", "test-artifacts"),
+    designArtifactsDir: join(root, "design-artifacts"),
+    docsDir: join(root, "docs"),
+    sprintStatusPath: join(implementationArtifactsDir, "sprint-status.yaml"),
+    extensionStateDir: join(root, ".pi", "bmad"),
+    extensionStatePath: join(root, ".pi", "bmad", "state.json"),
+  };
+}
+
+export function detectBmadInstall(cwd: string): BmadInstallState {
+  const paths = getBmadPaths(cwd);
+  const installed = existsSync(paths.manifestPath);
+  const knownModules = ["core", "bmm", "cis", "wds", "tea", "bmb"];
+  const modules = knownModules.filter((moduleId) => existsSync(join(paths.bmadDir, moduleId)));
+  return { installed, modules, paths };
+}
+
+export function detectBmadProjectState(cwd: string): BmadProjectState {
+  const install = detectBmadInstall(cwd);
+  const inventory = detectInventory(install.paths);
+  const hasPlanningArtifacts = inventory.planningFiles.length > 0;
+  const hasImplementationArtifacts = inventory.implementationFiles.length > 0;
+  const hasSprintStatus = existsSync(install.paths.sprintStatusPath);
+  const phase = detectPhase(inventory, hasSprintStatus);
+  const hasWdsArtifacts =
+    inventory.wdsScenarioFiles.length > 0 ||
+    inventory.wdsPageSpecFiles.length > 0 ||
+    inventory.wdsDeliveryFiles.length > 0 ||
+    inventory.wdsDesignSystemFiles.length > 0;
+  const hasTeaArtifacts =
+    inventory.teaFiles.length > 0 ||
+    inventory.teaTraceFiles.length > 0 ||
+    inventory.teaReviewFiles.length > 0 ||
+    inventory.teaNfrFiles.length > 0;
+
+  const sprint = hasSprintStatus ? loadSprintStatus(install.paths.sprintStatusPath) : undefined;
+  const nextBacklogStory = sprint?.storyOrder.find((story) => sprint.developmentStatus[story] === "backlog");
+  const nextReadyStory = sprint?.storyOrder.find((story) => sprint.developmentStatus[story] === "ready-for-dev");
+  const activeStory = sprint?.storyOrder.find((story) => sprint.developmentStatus[story] === "in-progress");
+
+  return {
+    phase,
+    hasPlanningArtifacts,
+    hasImplementationArtifacts,
+    hasSprintStatus,
+    hasWdsArtifacts,
+    hasTeaArtifacts,
+    inventory,
+    nextBacklogStory,
+    nextReadyStory,
+    activeStory,
+  };
+}