@pennyfarthing/core 11.2.0 → 11.2.2

package/pennyfarthing_scripts/workflow/cli.py

@@ -16,6 +16,8 @@ Usage:
 
 from __future__ import annotations
 
+from datetime import UTC
+
 import click
 
 
@@ -90,17 +92,18 @@ def workflow_phase_check(workflow_name: str, phase: str):
 @workflow.command("handoff")
 @click.argument("next_agent")
 def workflow_handoff(next_agent: str):
-    """Emit a handoff marker for Cyclist.
+    """Emit an environment-aware handoff marker.
+
+    Delegates to generate_marker() which detects Cyclist, relay mode,
+    and context usage to choose the appropriate marker type.
 
     \b
     Arguments:
       NEXT_AGENT  - The agent to hand off to (tea, dev, reviewer, etc.)
     """
-    click.echo("---")
-    click.echo("AGENT_COMMAND:")
-    click.echo(f'  marker: "<!-- CYCLIST:HANDOFF:/{next_agent} -->"')
-    click.echo(f'  fallback: "Run `/{next_agent}` to continue"')
-    click.echo("---")
+    from pennyfarthing_scripts.handoff.marker import generate_marker
+
+    click.echo(generate_marker(next_agent))
 
 
 # ---------------------------------------------------------------------------
@@ -140,7 +143,6 @@ def workflow_list_cmd():
 
     Shows a markdown table with type, phases/steps, modes, and descriptions.
     """
-    import yaml as yaml_mod
 
     from pennyfarthing_scripts.workflow.helpers import (
         count_steps,
@@ -352,7 +354,7 @@ def workflow_start_cmd(name: str, mode: str | None):
     Arguments:
       NAME  - Workflow name (e.g., architecture, release)
     """
-    from datetime import datetime, timezone
+    from datetime import datetime
 
     from pennyfarthing_scripts.common.config import get_project_root
     from pennyfarthing_scripts.workflow.helpers import (
@@ -443,7 +445,7 @@ def workflow_start_cmd(name: str, mode: str | None):
         return
 
     # Create session file
-    now = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+    now = datetime.now(UTC).strftime("%Y-%m-%dT%H:%M:%SZ")
     wf_agent = wf.get("agent", "pm")
     wf_desc = wf.get("description", "-")
 
@@ -515,7 +517,7 @@ def workflow_resume_cmd(name: str | None):
     Arguments:
       NAME  - Workflow name (auto-detects from active session if omitted)
     """
-    from datetime import datetime, timezone
+    from datetime import datetime
 
     from pennyfarthing_scripts.common.config import get_project_root
     from pennyfarthing_scripts.workflow.helpers import (
@@ -600,7 +602,7 @@ def workflow_resume_cmd(name: str | None):
         raise SystemExit(1)
 
     # Update last updated timestamp
-    now = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+    now = datetime.now(UTC).strftime("%Y-%m-%dT%H:%M:%SZ")
     import re
 
     updated_content = re.sub(
@@ -787,7 +789,7 @@ def workflow_fix_phase_cmd(story_id: str, target_phase: str, dry_run: bool):
       TARGET_PHASE  - Target phase to set (e.g., review, approved, finish)
     """
     import re
-    from datetime import datetime, timezone
+    from datetime import datetime
 
     from pennyfarthing_scripts.common.config import get_project_root
     from pennyfarthing_scripts.workflow.helpers import (
@@ -848,17 +850,17 @@ def workflow_fix_phase_cmd(story_id: str, target_phase: str, dry_run: bool):
     # Find indices
     try:
         current_idx = phases.index(current_phase)
-    except ValueError:
+    except ValueError as err:
         click.echo(f"Error: Current phase '{current_phase}' not found in {workflow_name} workflow", err=True)
         click.echo(f"Valid phases: {', '.join(phases)}", err=True)
-        raise SystemExit(1)
+        raise SystemExit(1) from err
 
     try:
         target_idx = phases.index(target_phase)
-    except ValueError:
+    except ValueError as err:
         click.echo(f"Error: Target phase '{target_phase}' not found in {workflow_name} workflow", err=True)
         click.echo(f"Valid phases: {', '.join(phases)}", err=True)
-        raise SystemExit(1)
+        raise SystemExit(1) from err
 
     if target_idx <= current_idx:
         click.echo(f"Error: Target phase '{target_phase}' is not ahead of current phase '{current_phase}'", err=True)
@@ -866,7 +868,7 @@ def workflow_fix_phase_cmd(story_id: str, target_phase: str, dry_run: bool):
         raise SystemExit(1)
 
     # Calculate transitions
-    now = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+    now = datetime.now(UTC).strftime("%Y-%m-%dT%H:%M:%SZ")
     click.echo("")
     click.echo("Transitions needed:")
 
@@ -908,7 +910,7 @@ def workflow_fix_phase_cmd(story_id: str, target_phase: str, dry_run: bool):
 
     # Build handoff history additions
     handoff_lines = []
-    for from_phase, to_phase, from_agent, to_agent, gate in transitions:
+    for _from_phase, _to_phase, from_agent, to_agent, gate in transitions:
         handoff_lines.append(f"| {from_agent} | {to_agent} | {gate} | PASSED | {now} |")
 
     # Insert handoff rows after the last PASSED/FAILED row
@@ -950,7 +952,7 @@ def workflow_complete_step_cmd(name: str | None, step_override: int | None):
       NAME  - Workflow name (auto-detects from session if omitted)
     """
     import re
-    from datetime import datetime, timezone
+    from datetime import datetime
 
     from pennyfarthing_scripts.common.config import get_project_root
     from pennyfarthing_scripts.workflow.helpers import (
@@ -1035,7 +1037,7 @@ def workflow_complete_step_cmd(name: str | None, step_override: int | None):
     new_status = "completed" if completed_count >= step_count else "in_progress"
 
     # Update session file
-    now = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+    now = datetime.now(UTC).strftime("%Y-%m-%dT%H:%M:%SZ")
 
     content = re.sub(
         r"^- \*\*Current Step:\*\*.*$",

package/pennyfarthing_scripts/workflow/state.py

@@ -7,7 +7,6 @@ state detection from .session/ files.
 
 from typing import Any
 
-
 # Phase ownership mapping for TDD workflow
 # Canonical YAML names: setup, red, green, review, finish
 TDD_PHASE_OWNERS: dict[str, str] = {

package/pennyfarthing_scripts/workflow/team_lifecycle.py

@@ -0,0 +1,256 @@
+"""
+Phase-scoped Team Lifecycle for Story 86-10.
+
+Manages the lifecycle of native Agent Teams within workflow phases.
+When a workflow phase has a `team:` config block, the lead agent creates
+a team at phase start, spawns teammates, and cleans up before handoff.
+
+Python port of packages/core/dist/workflow/team-lifecycle.js.
+"""
+
+from __future__ import annotations
+
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+
+# =============================================================================
+# In-memory registries
+# =============================================================================
+
+_active_teams: dict[str, dict[str, Any]] = {}
+"""Active teams keyed by story_id."""
+
+_sidecar_locks: dict[str, dict[str, Any]] = {}
+"""Sidecar locks keyed by file path."""
+
+
+def _reset_for_testing() -> None:
+    """Reset all in-memory state. For testing only."""
+    _active_teams.clear()
+    _sidecar_locks.clear()
+
+
+async def create_team(
+    phase: dict[str, Any],
+    story_id: str,
+    adapter: Any | None = None,
+) -> dict[str, Any]:
+    """Create a phase-scoped team.
+
+    If phase has no team config, returns success with no handle (no-op).
+    If phase has team config, creates team and returns handle.
+    """
+    if not phase.get("team"):
+        return {"success": True}
+
+    team_name = f"{story_id}-{phase['name']}"
+
+    # Clean up existing team for same story
+    existing = _active_teams.get(story_id)
+    if existing and adapter:
+        try:
+            await adapter.delete_team(existing["teamName"])
+        except Exception:
+            pass
+        del _active_teams[story_id]
+
+    handle: dict[str, Any] = {
+        "teamName": team_name,
+        "storyId": story_id,
+        "phase": phase["name"],
+        "teammates": [],
+        "createdAt": datetime.now(UTC).isoformat(),
+    }
+
+    if adapter:
+        try:
+            await adapter.create_team({"teamName": team_name})
+        except Exception as exc:
+            return {"success": False, "error": str(exc)}
+
+    _active_teams[story_id] = handle
+    return {"success": True, "data": handle}
+
+
+async def spawn_teammates(
+    handle: dict[str, Any],
+    config: dict[str, Any],
+    story_id: str,
+    phase: dict[str, Any],
+    adapter: Any | None = None,
+) -> dict[str, Any]:
+    """Spawn all teammates for a team based on workflow YAML config."""
+    teammates: list[dict[str, Any]] = []
+
+    for member in config["teammates"]:
+        teammate: dict[str, Any] = {
+            "agent": member["agent"],
+            "task": member["task"],
+            "status": "spawned",
+        }
+        if adapter:
+            try:
+                await adapter.spawn_teammate({
+                    "teamName": handle["teamName"],
+                    "agent": member["agent"],
+                    "prompt": f'pf agent start "{member["agent"]}"',
+                    "model": config.get("model"),
+                })
+            except Exception:
+                teammate["status"] = "crashed"
+        teammates.append(teammate)
+
+    handle["teammates"] = teammates
+
+    # Update registry
+    if handle.get("storyId") in _active_teams:
+        _active_teams[handle["storyId"]] = handle
+
+    return {"success": True, "data": teammates}
+
+
+async def shutdown_all_teammates(
+    handle: dict[str, Any],
+    adapter: Any | None = None,
+) -> dict[str, Any]:
+    """Shut down all active teammates in a team."""
+    shutdown_count = 0
+
+    for teammate in handle["teammates"]:
+        if teammate["status"] in ("shutdown", "crashed"):
+            continue
+        if adapter:
+            try:
+                await adapter.shutdown_teammate({
+                    "teamName": handle["teamName"],
+                    "agent": teammate["agent"],
+                })
+            except Exception:
+                pass  # Graceful degradation — swallow adapter errors
+        teammate["status"] = "shutdown"
+        shutdown_count += 1
+
+    return {"success": True, "data": {"shutdownCount": shutdown_count}}
+
+
+async def cleanup_team(
+    handle: dict[str, Any],
+    adapter: Any | None = None,
+) -> dict[str, Any]:
+    """Clean up a team entirely (TeamDelete). Must run before pf handoff."""
+    if adapter:
+        try:
+            await adapter.delete_team(handle["teamName"])
+        except Exception:
+            pass
+
+    _active_teams.pop(handle.get("storyId", ""), None)
+    return {"success": True, "data": {"cleaned": True}}
+
+
+def check_gate_on_task_completed(
+    handle: dict[str, Any],
+    phase: dict[str, Any],
+) -> dict[str, Any]:
+    """Check gate condition when a TaskCompleted event fires."""
+    if not phase.get("gate"):
+        return {"passed": True, "gate": "none"}
+
+    gate_type = phase["gate"].get("type", "unknown")
+    has_active = any(t["status"] == "active" for t in handle["teammates"])
+
+    if has_active:
+        return {"passed": False, "gate": gate_type, "reason": "Teammates still active"}
+
+    return {"passed": True, "gate": gate_type}
+
+
+def check_gate_on_teammate_idle(
+    handle: dict[str, Any],
+    teammate: dict[str, Any],
+    phase: dict[str, Any],
+) -> dict[str, Any]:
+    """Check gate condition when a TeammateIdle event fires."""
+    if not phase.get("gate"):
+        return {"passed": True, "gate": "none"}
+
+    gate_type = phase["gate"].get("type", "unknown")
+
+    if teammate["status"] == "crashed":
+        return {"passed": False, "gate": gate_type, "reason": "Teammate crashed"}
+
+    return {"passed": True, "gate": gate_type}
+
+
+def generate_team_summary(handle: dict[str, Any]) -> dict[str, Any]:
+    """Generate a team activity summary for the session file audit trail."""
+    return {
+        "teamName": handle["teamName"],
+        "storyId": handle["storyId"],
+        "phase": handle["phase"],
+        "members": [
+            {"agent": t["agent"], "status": t["status"], "task": t["task"]}
+            for t in handle["teammates"]
+        ],
+        "cleanShutdown": all(t["status"] == "shutdown" for t in handle["teammates"]),
+    }
+
+
+def acquire_sidecar_lock(
+    file_path: str,
+    story_id: str,
+    timeout: int = 5000,
+) -> dict[str, Any]:
+    """Acquire an exclusive lock for sidecar file writing."""
+    existing = _sidecar_locks.get(file_path)
+    if existing:
+        if existing["storyId"] == story_id:
+            return {"success": True, "data": existing}
+        return {"success": False, "error": f"Lock held by story {existing['storyId']}"}
+
+    lock: dict[str, Any] = {
+        "lockPath": f"{file_path}.lock",
+        "storyId": story_id,
+        "acquiredAt": datetime.now(UTC).isoformat(),
+    }
+    _sidecar_locks[file_path] = lock
+    return {"success": True, "data": lock}
+
+
+def release_sidecar_lock(lock: dict[str, Any]) -> dict[str, Any]:
+    """Release a sidecar file lock."""
+    for path, held in list(_sidecar_locks.items()):
+        if held["lockPath"] == lock["lockPath"]:
+            del _sidecar_locks[path]
+            break
+    return {"success": True}
+
+
+def get_active_team(story_id: str) -> dict[str, Any] | None:
+    """Get the active team for a story, if any."""
+    return _active_teams.get(story_id)
+
+
+def update_session_with_summary(
+    session_path: str | Path,
+    summary: dict[str, Any],
+) -> dict[str, Any]:
+    """Write team activity summary to session file for audit trail."""
+    path = Path(session_path)
+    content = path.read_text() if path.exists() else ""
+
+    lines = [
+        "\n## Team Activity Summary\n",
+        f"**Team:** {summary['teamName']}",
+        f"**Phase:** {summary['phase']}",
+        f"**Clean Shutdown:** {'Yes' if summary.get('cleanShutdown') else 'No'}\n",
+        "| Agent | Status | Task |",
+        "|-------|--------|------|",
+    ]
+    for member in summary.get("members", []):
+        lines.append(f"| {member['agent']} | {member['status']} | {member['task']} |")
+
+    content += "\n".join(lines) + "\n"
+    path.write_text(content)
+    return {"success": True}

package/packages/core/dist/cli/cyclist-migration.test.d.ts

@@ -1,16 +0,0 @@
-/**
- * Story 11-3: Cyclist Migration Tests
- *
- * These tests verify the Cyclist Electron GUI is correctly migrated
- * into the pnpm workspace as @pennyfarthing/cyclist.
- * Tests are designed to FAIL until the migration is complete.
- *
- * Acceptance Criteria:
- * 1. packages/cyclist/ contains Cyclist source
- * 2. Dependencies use workspace:* for internal packages
- * 3. Portrait resolution uses @pennyfarthing/shared
- * 4. Electron app starts and shows portraits
- * 5. Dogfooding scenario works (portraits load from pennyfarthing-dist/)
- */
-export {};
-//# sourceMappingURL=cyclist-migration.test.d.ts.map

package/packages/core/dist/cli/cyclist-migration.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cyclist-migration.test.d.ts","sourceRoot":"","sources":["../../src/cli/cyclist-migration.test.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG"}

package/packages/core/dist/cli/cyclist-migration.test.js

@@ -1,229 +0,0 @@
-/**
- * Story 11-3: Cyclist Migration Tests
- *
- * These tests verify the Cyclist Electron GUI is correctly migrated
- * into the pnpm workspace as @pennyfarthing/cyclist.
- * Tests are designed to FAIL until the migration is complete.
- *
- * Acceptance Criteria:
- * 1. packages/cyclist/ contains Cyclist source
- * 2. Dependencies use workspace:* for internal packages
- * 3. Portrait resolution uses @pennyfarthing/shared
- * 4. Electron app starts and shows portraits
- * 5. Dogfooding scenario works (portraits load from pennyfarthing-dist/)
- */
-import { describe, it } from 'node:test';
-import assert from 'node:assert';
-import { existsSync, readFileSync, readdirSync } from 'node:fs';
-import { join } from 'node:path';
-import { findMonorepoRoot } from './utils/files.js';
-const __dirname = import.meta.dirname;
-const PROJECT_ROOT = findMonorepoRoot(__dirname);
-describe('Story 11-3: Cyclist Migration into Monorepo', () => {
-    describe('AC1: packages/cyclist/ contains Cyclist source', () => {
-        it('should have packages/cyclist directory', () => {
-            const cyclistDir = join(PROJECT_ROOT, 'packages', 'cyclist');
-            assert.ok(existsSync(cyclistDir), 'packages/cyclist/ directory must exist');
-        });
-        it('should have packages/cyclist/src directory', () => {
-            const srcDir = join(PROJECT_ROOT, 'packages', 'cyclist', 'src');
-            assert.ok(existsSync(srcDir), 'packages/cyclist/src/ directory must exist');
-        });
-        it('should have packages/cyclist/src/main.ts (Electron main process)', () => {
-            const mainTs = join(PROJECT_ROOT, 'packages', 'cyclist', 'src', 'main.ts');
-            assert.ok(existsSync(mainTs), 'packages/cyclist/src/main.ts must exist');
-        });
-        it('should have packages/cyclist/src/paths.ts (path resolution)', () => {
-            const pathsTs = join(PROJECT_ROOT, 'packages', 'cyclist', 'src', 'paths.ts');
-            assert.ok(existsSync(pathsTs), 'packages/cyclist/src/paths.ts must exist');
-        });
-        it('should have packages/cyclist/src/public directory', () => {
-            const publicDir = join(PROJECT_ROOT, 'packages', 'cyclist', 'src', 'public');
-            assert.ok(existsSync(publicDir), 'packages/cyclist/src/public/ directory must exist');
-        });
-        it('should have packages/cyclist/package.json', () => {
-            const packageJson = join(PROJECT_ROOT, 'packages', 'cyclist', 'package.json');
-            assert.ok(existsSync(packageJson), 'packages/cyclist/package.json must exist');
-        });
-        it('should have @pennyfarthing/cyclist as package name', () => {
-            const packageJsonPath = join(PROJECT_ROOT, 'packages', 'cyclist', 'package.json');
-            if (!existsSync(packageJsonPath)) {
-                assert.fail('packages/cyclist/package.json must exist first');
-            }
-            const pkg = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
-            assert.strictEqual(pkg.name, '@pennyfarthing/cyclist', 'Package name must be @pennyfarthing/cyclist');
-        });
-        it('should have packages/cyclist/tsconfig.json', () => {
-            const tsconfig = join(PROJECT_ROOT, 'packages', 'cyclist', 'tsconfig.json');
-            assert.ok(existsSync(tsconfig), 'packages/cyclist/tsconfig.json must exist');
-        });
-    });
-    describe('AC2: Dependencies use workspace:* for internal packages', () => {
-        it('should have @pennyfarthing/shared as workspace dependency', () => {
-            const packageJsonPath = join(PROJECT_ROOT, 'packages', 'cyclist', 'package.json');
-            if (!existsSync(packageJsonPath)) {
-                assert.fail('packages/cyclist/package.json must exist first');
-            }
-            const pkg = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
-            const deps = pkg.dependencies || {};
-            assert.ok(deps['@pennyfarthing/shared'], 'packages/cyclist should depend on @pennyfarthing/shared');
-            // Dependency can use workspace:* or a version range
-            assert.ok(deps['@pennyfarthing/shared'].includes('workspace') || /^\^?\d/.test(deps['@pennyfarthing/shared']), '@pennyfarthing/shared dependency should use workspace protocol or version range');
-        });
-        it('should NOT have pennyfarthing GitHub dependency', () => {
-            const packageJsonPath = join(PROJECT_ROOT, 'packages', 'cyclist', 'package.json');
-            if (!existsSync(packageJsonPath)) {
-                assert.fail('packages/cyclist/package.json must exist first');
-            }
-            const pkg = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
-            const deps = pkg.dependencies || {};
-            assert.ok(!deps['pennyfarthing'] || !deps['pennyfarthing'].includes('github'), 'packages/cyclist should NOT have GitHub pennyfarthing dependency (use workspace instead)');
-        });
-        it('should be listed in pnpm-workspace.yaml packages', () => {
-            const workspaceYamlPath = join(PROJECT_ROOT, 'pnpm-workspace.yaml');
-            const content = readFileSync(workspaceYamlPath, 'utf-8');
-            // packages/* pattern should include packages/cyclist
-            assert.ok(content.includes('packages/*') || content.includes('packages/cyclist'), 'pnpm-workspace.yaml should include packages/cyclist (via packages/* pattern)');
-        });
-    });
-    describe('AC3: Portrait resolution uses shared resolver pattern', () => {
-        // Note: paths.ts inlines the shared resolver functions for standalone npm distribution
-        // This is valid - we test for the functions existing, not the import pattern
-        it('should have resolvePennyfarthingDist function', () => {
-            const pathsPath = join(PROJECT_ROOT, 'packages', 'cyclist', 'src', 'paths.ts');
-            if (!existsSync(pathsPath)) {
-                assert.fail('packages/cyclist/src/paths.ts must exist first');
-            }
-            const content = readFileSync(pathsPath, 'utf-8');
-            assert.ok(content.includes('resolvePennyfarthingDist'), 'paths.ts should have resolvePennyfarthingDist function (inlined or imported)');
-        });
-        it('should have getPortraitPaths function', () => {
-            const pathsPath = join(PROJECT_ROOT, 'packages', 'cyclist', 'src', 'paths.ts');
-            if (!existsSync(pathsPath)) {
-                assert.fail('packages/cyclist/src/paths.ts must exist first');
-            }
-            const content = readFileSync(pathsPath, 'utf-8');
-            assert.ok(content.includes('getPortraitPaths'), 'paths.ts should have getPortraitPaths function (inlined or imported)');
-        });
-        it('should NOT have hardcoded pennyfarthing path in getPortraitsDir', () => {
-            const pathsPath = join(PROJECT_ROOT, 'packages', 'cyclist', 'src', 'paths.ts');
-            if (!existsSync(pathsPath)) {
-                assert.fail('packages/cyclist/src/paths.ts must exist first');
-            }
-            const content = readFileSync(pathsPath, 'utf-8');
-            // Should not contain the old hardcoded path logic (join calls, not comments)
-            // Old pattern was: join(..., 'pennyfarthing', 'pennyfarthing-dist')
-            const hasOldPattern = content.includes("join(__dirname, 'pennyfarthing', 'pennyfarthing-dist')") ||
-                content.includes('join(__dirname, "pennyfarthing", "pennyfarthing-dist")');
-            assert.ok(!hasOldPattern, 'paths.ts should NOT have hardcoded pennyfarthing path - use shared resolver instead');
-        });
-        it('should depend on @pennyfarthing/shared in package.json', () => {
-            const packageJsonPath = join(PROJECT_ROOT, 'packages', 'cyclist', 'package.json');
-            if (!existsSync(packageJsonPath)) {
-                assert.fail('packages/cyclist/package.json must exist first');
-            }
-            const pkg = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
-            const deps = pkg.dependencies || {};
-            assert.ok(deps['@pennyfarthing/shared'], 'packages/cyclist should depend on @pennyfarthing/shared');
-        });
-    });
-    describe('AC4: Electron app starts and shows portraits', () => {
-        // Note: Full build verification requires pnpm install which needs workspace resolution
-        // These tests verify the package configuration is correct for building
-        it('should have Electron dependency', () => {
-            const packageJsonPath = join(PROJECT_ROOT, 'packages', 'cyclist', 'package.json');
-            if (!existsSync(packageJsonPath)) {
-                assert.fail('packages/cyclist/package.json must exist first');
-            }
-            const pkg = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
-            const devDeps = pkg.devDependencies || {};
-            assert.ok(devDeps['electron'], 'packages/cyclist should have electron as devDependency');
-        });
-        it('should have build script in package.json', () => {
-            const packageJsonPath = join(PROJECT_ROOT, 'packages', 'cyclist', 'package.json');
-            if (!existsSync(packageJsonPath)) {
-                assert.fail('packages/cyclist/package.json must exist first');
-            }
-            const pkg = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
-            assert.ok(pkg.scripts?.build, 'packages/cyclist should have a build script');
-        });
-        it('should have main entry point configured', () => {
-            const packageJsonPath = join(PROJECT_ROOT, 'packages', 'cyclist', 'package.json');
-            if (!existsSync(packageJsonPath)) {
-                assert.fail('packages/cyclist/package.json must exist first');
-            }
-            const pkg = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
-            assert.ok(pkg.main, 'packages/cyclist should have a main entry point');
-        });
-    });
-    describe('AC5: Dogfooding scenario works', () => {
-        it('should resolve portraits from pennyfarthing-dist in monorepo', () => {
-            // This test validates that portrait resolution works in the monorepo context
-            const pennyfarthingDist = join(PROJECT_ROOT, 'pennyfarthing-dist');
-            assert.ok(existsSync(pennyfarthingDist), 'pennyfarthing-dist/ should exist at monorepo root for dogfooding');
-        });
-        it('should have portraits directory in pennyfarthing-dist', () => {
-            const portraitsDir = join(PROJECT_ROOT, 'pennyfarthing-dist', 'personas', 'portraits');
-            assert.ok(existsSync(portraitsDir), 'pennyfarthing-dist/personas/portraits/ should exist');
-        });
-        it('should have at least one theme with portraits', () => {
-            const portraitsDir = join(PROJECT_ROOT, 'pennyfarthing-dist', 'personas', 'portraits');
-            if (!existsSync(portraitsDir)) {
-                assert.fail('portraits directory must exist first');
-            }
-            const themes = readdirSync(portraitsDir);
-            assert.ok(themes.length > 0, 'Should have at least one theme directory in portraits');
-        });
-        it('should have paths.ts configured to use shared resolver', () => {
-            // Verify paths.ts source code uses the shared resolver
-            // Runtime verification requires pnpm install + build
-            const pathsPath = join(PROJECT_ROOT, 'packages', 'cyclist', 'src', 'paths.ts');
-            if (!existsSync(pathsPath)) {
-                assert.fail('packages/cyclist/src/paths.ts must exist');
-            }
-            const content = readFileSync(pathsPath, 'utf-8');
-            assert.ok(content.includes('resolvePennyfarthingDist') && content.includes('getPortraitPaths'), 'paths.ts should use resolvePennyfarthingDist and getPortraitPaths from shared');
-        });
-    });
-    describe('Build Integration', () => {
-        // Note: Full TypeScript compilation requires pnpm install to resolve workspace dependencies
-        // These tests verify the build configuration is correct
-        it('should have valid tsconfig.json extending base', () => {
-            const tsconfigPath = join(PROJECT_ROOT, 'packages', 'cyclist', 'tsconfig.json');
-            if (!existsSync(tsconfigPath)) {
-                assert.fail('packages/cyclist/tsconfig.json must exist');
-            }
-            const content = readFileSync(tsconfigPath, 'utf-8');
-            const tsconfig = JSON.parse(content);
-            assert.ok(tsconfig.extends?.includes('tsconfig.base.json'), 'tsconfig.json should extend ../../tsconfig.base.json');
-        });
-        it('should have outDir configured for dist', () => {
-            const tsconfigPath = join(PROJECT_ROOT, 'packages', 'cyclist', 'tsconfig.json');
-            if (!existsSync(tsconfigPath)) {
-                assert.fail('packages/cyclist/tsconfig.json must exist');
-            }
-            const content = readFileSync(tsconfigPath, 'utf-8');
-            const tsconfig = JSON.parse(content);
-            assert.strictEqual(tsconfig.compilerOptions?.outDir, 'dist', 'tsconfig.json should output to dist directory');
-        });
-    });
-    describe('Source File Completeness', () => {
-        it('should have pennyfarthing.ts (persona/theme loading)', () => {
-            const pennyfarthingTs = join(PROJECT_ROOT, 'packages', 'cyclist', 'src', 'pennyfarthing.ts');
-            assert.ok(existsSync(pennyfarthingTs), 'packages/cyclist/src/pennyfarthing.ts must exist');
-        });
-        it('should have server.ts (Express server)', () => {
-            const serverTs = join(PROJECT_ROOT, 'packages', 'cyclist', 'src', 'server.ts');
-            assert.ok(existsSync(serverTs), 'packages/cyclist/src/server.ts must exist');
-        });
-        it('should have api/ directory', () => {
-            const apiDir = join(PROJECT_ROOT, 'packages', 'cyclist', 'src', 'api');
-            assert.ok(existsSync(apiDir), 'packages/cyclist/src/api/ directory must exist');
-        });
-        it('should have tests/ directory', () => {
-            const testsDir = join(PROJECT_ROOT, 'packages', 'cyclist', 'tests');
-            assert.ok(existsSync(testsDir), 'packages/cyclist/tests/ directory must exist');
-        });
-    });
-});
-//# sourceMappingURL=cyclist-migration.test.js.map