galangal-orchestrate 0.13.0__py3-none-any.whl → 0.13.4__py3-none-any.whl

galangal/__init__.py

@@ -19,7 +19,7 @@ from galangal.logging import (
     workflow_logger,
 )
 
-__version__ = "0.13.0"
+__version__ = "0.13.4"
 
 __all__ = [
     # Exceptions

galangal/ai/claude.py

@@ -83,55 +83,11 @@ class ClaudeBackend(AIBackend):
         """Invoke Claude Code with a prompt."""
         # State for output processing
         pending_tools: list[tuple[str, str]] = []
-        log_handle = None
-
-        # Open log file for streaming if provided
-        if log_file:
-            try:
-                log_handle = open(log_file, "a")
-            except OSError as e:
-                logger.warning("failed_to_open_log_file", path=log_file, error=str(e))
-
-        def should_log_line(line: str) -> bool:
-            """Determine if a line should be logged (errors, warnings, results)."""
-            if not line.strip():
-                return False
-            try:
-                data = json.loads(line.strip())
-                msg_type = data.get("type", "")
-
-                # Always log errors and results
-                if msg_type in ("error", "result"):
-                    return True
-
-                # Log system messages (rate limiting, etc.)
-                if msg_type == "system":
-                    return True
-
-                # Log tool errors
-                if msg_type == "user":
-                    content = data.get("message", {}).get("content", [])
-                    for item in content:
-                        if item.get("type") == "tool_result" and item.get("is_error"):
-                            return True
-
-                return False
-            except (json.JSONDecodeError, KeyError, TypeError):
-                # Log non-JSON lines that look like errors
-                lower = line.lower()
-                return "error" in lower or "warning" in lower or "failed" in lower
 
         def on_output(line: str) -> None:
             """Process each output line."""
             if ui:
                 ui.add_raw_line(line)
-            # Only log errors, warnings, and results to file
-            if log_handle and should_log_line(line):
-                try:
-                    log_handle.write(line + "\n")
-                    log_handle.flush()  # Ensure immediate write
-                except OSError:
-                    pass
             self._process_stream_line(line, ui, pending_tools)
 
         def on_idle(elapsed: float) -> None:
@@ -160,6 +116,7 @@ class ClaudeBackend(AIBackend):
                     idle_interval=3.0,
                     poll_interval_active=0.05,
                     poll_interval_idle=0.5,
+                    output_file=log_file,
                 )
 
                 result = runner.run()
@@ -209,13 +166,6 @@ class ClaudeBackend(AIBackend):
 
         except Exception as e:
             return StageResult.error(f"Claude invocation error: {e}")
-        finally:
-            # Close log file handle
-            if log_handle:
-                try:
-                    log_handle.close()
-                except OSError:
-                    pass
 
     def _process_stream_line(
         self,

galangal/ai/codex.py

@@ -188,7 +188,7 @@ class CodexBackend(AIBackend):
             ui: Optional TUI for progress display
             pause_check: Optional callback for pause detection
             stage: Stage name for schema customization (e.g., "QA", "SECURITY")
-            log_file: Optional path to log file (unused for Codex read-only)
+            log_file: Optional path to log file for streaming raw output
 
         Returns:
             StageResult with structured JSON in the output field
@@ -256,6 +256,7 @@ class CodexBackend(AIBackend):
                     idle_interval=5.0,
                     poll_interval_active=0.05,
                     poll_interval_idle=0.5,
+                    output_file=log_file,
                 )
 
                 result = runner.run()

galangal/ai/subprocess.py

@@ -7,6 +7,7 @@ from __future__ import annotations
 import select
 import subprocess
 import time
+from collections import deque
 from collections.abc import Callable
 from dataclasses import dataclass
 from enum import Enum
@@ -88,6 +89,8 @@ class SubprocessRunner:
         idle_interval: float = 3.0,
         poll_interval_active: float = 0.05,
         poll_interval_idle: float = 0.5,
+        max_output_chars: int | None = 1_000_000,
+        output_file: str | None = None,
     ):
         """
         Initialize the subprocess runner.
@@ -102,6 +105,8 @@ class SubprocessRunner:
             idle_interval: Seconds between idle callbacks
             poll_interval_active: Sleep between polls when receiving output
             poll_interval_idle: Sleep between polls when idle
+            max_output_chars: Max output chars kept in memory (None for unlimited)
+            output_file: Optional file path to stream full output
         """
         self.command = command
         self.timeout = timeout
@@ -112,6 +117,8 @@ class SubprocessRunner:
         self.idle_interval = idle_interval
         self.poll_interval_active = poll_interval_active
         self.poll_interval_idle = poll_interval_idle
+        self.max_output_chars = max_output_chars
+        self.output_file = output_file
 
     def run(self) -> RunResult:
         """
@@ -129,16 +136,39 @@ class SubprocessRunner:
             text=True,
         )
 
-        output_lines: list[str] = []
+        output_buffer: deque[str] = deque()
+        output_chars = 0
+        output_handle = None
         start_time = time.time()
         last_idle_callback = start_time
 
+        if self.output_file:
+            try:
+                output_handle = open(self.output_file, "a", encoding="utf-8", buffering=1)
+            except OSError:
+                output_handle = None
+
+        def record_output(chunk: str) -> None:
+            nonlocal output_chars, output_handle
+            if output_handle:
+                try:
+                    output_handle.write(chunk)
+                except OSError:
+                    output_handle = None
+
+            output_buffer.append(chunk)
+            output_chars += len(chunk)
+            if self.max_output_chars is not None:
+                while output_chars > self.max_output_chars and output_buffer:
+                    removed = output_buffer.popleft()
+                    output_chars -= len(removed)
+
         try:
             while True:
                 retcode = process.poll()
 
                 # Read available output (non-blocking)
-                had_output = self._read_output(process, output_lines)
+                had_output = self._read_output(process, record_output)
 
                 # Update last idle callback time if we had output
                 if had_output:
@@ -151,24 +181,30 @@ class SubprocessRunner:
                 # Check for pause request
                 if self.pause_check and self.pause_check():
                     self._terminate_gracefully(process)
+                    self._capture_remaining(process, record_output)
                     if self.ui:
                         self.ui.add_activity("Paused by user request", "⏸️")
                     return RunResult(
                         outcome=RunOutcome.PAUSED,
                         exit_code=None,
-                        output="".join(output_lines),
+                        output="".join(output_buffer),
                     )
 
                 # Check for timeout
                 elapsed = time.time() - start_time
                 if elapsed > self.timeout:
                     process.kill()
+                    try:
+                        process.wait(timeout=5)
+                    except subprocess.TimeoutExpired:
+                        pass
+                    self._capture_remaining(process, record_output)
                     if self.ui:
                         self.ui.add_activity(f"Timeout after {self.timeout}s", "❌")
                     return RunResult(
                         outcome=RunOutcome.TIMEOUT,
                         exit_code=None,
-                        output="".join(output_lines),
+                        output="".join(output_buffer),
                         timeout_seconds=self.timeout,
                     )
 
@@ -182,28 +218,33 @@ class SubprocessRunner:
                 time.sleep(self.poll_interval_active if had_output else self.poll_interval_idle)
 
             # Capture any remaining output
-            remaining = self._capture_remaining(process)
-            if remaining:
-                output_lines.append(remaining)
+            self._capture_remaining(process, record_output)
 
             return RunResult(
                 outcome=RunOutcome.COMPLETED,
                 exit_code=process.returncode,
-                output="".join(output_lines),
+                output="".join(output_buffer),
             )
 
         except Exception:
             # Ensure process is terminated on any error
             try:
                 process.kill()
+                process.wait(timeout=5)
             except Exception:
                 pass
             raise
+        finally:
+            if output_handle:
+                try:
+                    output_handle.close()
+                except OSError:
+                    pass
 
     def _read_output(
         self,
         process: subprocess.Popen[str],
-        output_lines: list[str],
+        record_output: Callable[[str], None],
     ) -> bool:
         """
         Read all available output lines (non-blocking).
@@ -225,7 +266,7 @@ class SubprocessRunner:
                 if not line:
                     break
 
-                output_lines.append(line)
+                record_output(line)
                 had_output = True
 
                 if self.on_output:
@@ -245,10 +286,15 @@ class SubprocessRunner:
         except subprocess.TimeoutExpired:
             process.kill()
 
-    def _capture_remaining(self, process: subprocess.Popen[str]) -> str:
+    def _capture_remaining(
+        self,
+        process: subprocess.Popen[str],
+        record_output: Callable[[str], None],
+    ) -> None:
         """Capture any remaining output after process completes."""
         try:
             remaining, _ = process.communicate(timeout=10)
-            return remaining or ""
+            if remaining:
+                record_output(remaining)
         except (OSError, ValueError, subprocess.TimeoutExpired):
-            return ""
+            return

galangal/commands/complete.py

@@ -303,6 +303,11 @@ def finalize_task(
     if dest.exists():
         dest = done_dir / f"{task_name}-{datetime.now().strftime('%Y%m%d%H%M%S')}"
 
+    # Remove logs directory before moving (not needed after completion)
+    logs_dir = task_dir / "logs"
+    if logs_dir.exists():
+        shutil.rmtree(logs_dir)
+
     report(f"Moving task to {dest.relative_to(project_root)}/...")
     shutil.move(str(task_dir), str(dest))
     clear_active_task()

galangal/commands/start.py

@@ -130,6 +130,12 @@ def cmd_start(args: argparse.Namespace) -> int:
     if not require_initialized():
         return 1
 
+    # Check for newer version on PyPI
+    from galangal.core.version_check import check_and_prompt_update
+
+    if not check_and_prompt_update():
+        return 0  # User chose to quit to update
+
     # Check for new/missing config sections - prompt user if any found
     if not _check_config_updates():
         return 0  # User chose to quit and configure

galangal/config/schema.py

@@ -2,7 +2,7 @@
 Configuration schema using Pydantic models.
 """
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, field_validator
 
 
 class ProjectConfig(BaseModel):
@@ -59,6 +59,12 @@ class TestGateConfig(BaseModel):
         default=True, description="Stop on first test failure instead of running all"
     )
 
+    @field_validator("tests", mode="before")
+    @classmethod
+    def tests_none_to_list(cls, v: list[TestGateTest] | None) -> list[TestGateTest]:
+        """Convert None to empty list (YAML 'tests:' with only comments becomes null)."""
+        return v if v is not None else []
+
 
 class ValidationCommand(BaseModel):
     """A validation command configuration.
@@ -228,6 +234,12 @@ class LoggingConfig(BaseModel):
         default=None,
         description="Log file path (e.g., 'logs/galangal.jsonl'). If not set, logs only to console.",
     )
+    activity_file: str | None = Field(
+        default=None,
+        description=(
+            "Optional activity log file path. Supports {task_name} placeholder for per-task logs."
+        ),
+    )
     json_format: bool = Field(
         default=True, description="Output JSON format (False for pretty console format)"
     )

galangal/core/state.py

@@ -884,6 +884,7 @@ class WorkflowState:
 
         Called when validation fails and triggers a rollback to an earlier stage.
         The history is used to detect rollback loops and prevent infinite retries.
+        Keeps only the last 50 events to prevent state growth.
 
         Args:
             from_stage: Stage that failed and triggered the rollback.
@@ -892,6 +893,9 @@ class WorkflowState:
         """
         event = RollbackEvent.create(from_stage, to_stage, reason)
         self.rollback_history.append(event)
+        # Keep only the last 50 events - plenty for the 1-hour window check
+        if len(self.rollback_history) > 50:
+            self.rollback_history = self.rollback_history[-50:]
 
     def should_allow_rollback(self, target_stage: Stage) -> bool:
         """

galangal/core/version_check.py

@@ -0,0 +1,238 @@
+"""
+Version checking utilities for galangal-orchestrate.
+
+Checks PyPI for newer versions and prompts users to update.
+"""
+
+from __future__ import annotations
+
+import json
+import urllib.request
+from typing import NamedTuple
+
+from galangal import __version__
+
+PYPI_PACKAGE_NAME = "galangal-orchestrate"
+PYPI_URL = f"https://pypi.org/pypi/{PYPI_PACKAGE_NAME}/json"
+REQUEST_TIMEOUT = 3  # seconds
+
+
+class VersionInfo(NamedTuple):
+    """Result of a version check."""
+
+    current: str
+    latest: str | None
+    update_available: bool
+    error: str | None = None
+
+
+def parse_version(version: str) -> tuple[int, ...]:
+    """
+    Parse a version string into a tuple of integers for comparison.
+
+    Handles versions like "0.13.0", "1.2.3", etc.
+    Non-numeric parts (like "rc1", "beta") are ignored.
+
+    Args:
+        version: Version string (e.g., "0.13.0")
+
+    Returns:
+        Tuple of integers (e.g., (0, 13, 0))
+    """
+    parts = []
+    for part in version.split("."):
+        # Extract numeric portion only
+        numeric = ""
+        for char in part:
+            if char.isdigit():
+                numeric += char
+            else:
+                break
+        if numeric:
+            parts.append(int(numeric))
+    return tuple(parts)
+
+
+def compare_versions(current: str, latest: str) -> int:
+    """
+    Compare two version strings.
+
+    Args:
+        current: Current version string
+        latest: Latest version string
+
+    Returns:
+        -1 if current < latest (update available)
+         0 if current == latest (up to date)
+         1 if current > latest (ahead, e.g., dev version)
+    """
+    current_parts = parse_version(current)
+    latest_parts = parse_version(latest)
+
+    # Pad shorter version with zeros
+    max_len = max(len(current_parts), len(latest_parts))
+    current_parts = current_parts + (0,) * (max_len - len(current_parts))
+    latest_parts = latest_parts + (0,) * (max_len - len(latest_parts))
+
+    if current_parts < latest_parts:
+        return -1
+    elif current_parts > latest_parts:
+        return 1
+    return 0
+
+
+def get_latest_version() -> str | None:
+    """
+    Fetch the latest version from PyPI.
+
+    Returns:
+        Latest version string, or None if fetch failed.
+    """
+    try:
+        request = urllib.request.Request(
+            PYPI_URL,
+            headers={"Accept": "application/json"},
+        )
+        with urllib.request.urlopen(request, timeout=REQUEST_TIMEOUT) as response:
+            data = json.loads(response.read().decode("utf-8"))
+            version = data.get("info", {}).get("version")
+            return str(version) if version else None
+    except Exception:
+        return None
+
+
+def check_for_updates() -> VersionInfo:
+    """
+    Check if a newer version is available on PyPI.
+
+    Returns:
+        VersionInfo with current/latest versions and update status.
+    """
+    current = __version__
+    latest = get_latest_version()
+
+    if latest is None:
+        return VersionInfo(
+            current=current,
+            latest=None,
+            update_available=False,
+            error="Could not check PyPI",
+        )
+
+    update_available = compare_versions(current, latest) < 0
+
+    return VersionInfo(
+        current=current,
+        latest=latest,
+        update_available=update_available,
+    )
+
+
+def get_update_command() -> str:
+    """
+    Get the pip command to update galangal-orchestrate.
+
+    Returns:
+        Command string for updating the package.
+    """
+    return f"pip install --upgrade {PYPI_PACKAGE_NAME}"
+
+
+def check_and_prompt_update() -> bool:
+    """
+    Check for updates and prompt user if one is available.
+
+    This is designed to be called at the start of `galangal start`.
+    It's non-blocking on errors and doesn't interrupt workflow if
+    the user declines to update.
+
+    Returns:
+        True if user wants to continue (or no update needed).
+        False if user wants to quit to update.
+    """
+    from rich.prompt import Confirm
+
+    from galangal.ui.console import console, print_info
+
+    try:
+        info = check_for_updates()
+
+        if info.error:
+            # Silently skip if we can't reach PyPI
+            return True
+
+        if not info.update_available:
+            return True
+
+        # Show update notification
+        console.print()
+        print_info(
+            f"New version available: [cyan]{info.latest}[/cyan] "
+            f"(you have {info.current})"
+        )
+        console.print(f"[dim]  Update with: {get_update_command()}[/dim]\n")
+
+        # Ask if they want to continue or quit to update
+        continue_anyway = Confirm.ask(
+            "Continue without updating?",
+            default=True,
+        )
+
+        if not continue_anyway:
+            # Offer to run the update
+            run_update = Confirm.ask(
+                "Run update now?",
+                default=True,
+            )
+
+            if run_update:
+                return _run_update()
+
+            console.print(f"\n[dim]Run: {get_update_command()}[/dim]")
+            return False
+
+        console.print()  # Add spacing before TUI starts
+        return True
+
+    except Exception:
+        # Non-critical, don't interrupt task creation
+        return True
+
+
+def _run_update() -> bool:
+    """
+    Run pip upgrade and return whether to continue.
+
+    Returns:
+        False (user should restart after update).
+    """
+    import subprocess
+    import sys
+
+    from galangal.ui.console import console, print_error, print_success
+
+    console.print("\n[dim]Running update...[/dim]")
+
+    try:
+        # Use sys.executable to ensure we use the same Python
+        result = subprocess.run(
+            [sys.executable, "-m", "pip", "install", "--upgrade", PYPI_PACKAGE_NAME],
+            capture_output=True,
+            text=True,
+            timeout=120,
+        )
+
+        if result.returncode == 0:
+            print_success("Update complete! Please restart galangal.")
+        else:
+            print_error(f"Update failed: {result.stderr[:200]}")
+            console.print(f"[dim]Try manually: {get_update_command()}[/dim]")
+
+    except subprocess.TimeoutExpired:
+        print_error("Update timed out")
+        console.print(f"[dim]Try manually: {get_update_command()}[/dim]")
+    except Exception as e:
+        print_error(f"Update failed: {e}")
+        console.print(f"[dim]Try manually: {get_update_command()}[/dim]")
+
+    return False  # Always return False so user restarts

galangal/core/workflow/core.py

@@ -250,6 +250,8 @@ def _execute_test_gate(
     This is a non-AI stage that runs shell commands to verify tests pass.
     All configured tests must pass for the stage to succeed.
 
+    Output is streamed line-by-line to the TUI for real-time visibility.
+
     Args:
         state: Current workflow state.
         tui_app: TUI app for progress display.
@@ -259,6 +261,9 @@ def _execute_test_gate(
         StageResult indicating success or failure with rollback to DEV.
     """
     import subprocess
+    import threading
+    from collections import deque
+    from queue import Empty, Full, Queue
 
     from galangal.config.loader import get_project_root
     from galangal.logging import workflow_logger
@@ -266,6 +271,15 @@ def _execute_test_gate(
     task_name = state.task_name
     test_config = config.test_gate
     project_root = get_project_root()
+    logs_dir = get_task_dir(task_name) / "logs"
+    logs_dir.mkdir(parents=True, exist_ok=True)
+
+    max_output_chars = 200_000
+    output_queue_size = 200
+
+    def _sanitize_filename(name: str) -> str:
+        cleaned = "".join(c if c.isalnum() or c in ("-", "_") else "_" for c in name.lower())
+        return cleaned.strip("_") or "test"
 
     tui_app.add_activity("Running test gate checks...", "🧪")
 
@@ -274,75 +288,172 @@ def _execute_test_gate(
     all_passed = True
     failed_tests: list[str] = []
 
+    def stream_output(
+        proc: subprocess.Popen,
+        output_tail: deque[str],
+        queue: Queue,
+        log_handle: Any | None,
+        truncated_flag: list[bool],
+    ) -> None:
+        """Read process output, stream to queue, and keep a bounded tail."""
+        output_chars = 0
+        try:
+            for line in iter(proc.stdout.readline, ""):
+                if not line:
+                    break
+                if log_handle:
+                    try:
+                        log_handle.write(line)
+                    except OSError:
+                        log_handle = None
+
+                output_tail.append(line)
+                output_chars += len(line)
+                while output_chars > max_output_chars and output_tail:
+                    truncated_flag[0] = True
+                    removed = output_tail.popleft()
+                    output_chars -= len(removed)
+
+                try:
+                    queue.put(line.rstrip("\n"), timeout=1)
+                except Full:
+                    pass
+        finally:
+            try:
+                queue.put_nowait(None)  # Signal completion
+            except Full:
+                pass
+
     for test in test_config.tests:
         tui_app.add_activity(f"Running: {test.name}", "▶")
         tui_app.show_message(f"Test Gate: {test.name}", "info")
 
+        output_tail: deque[str] = deque()
+        output_truncated = [False]
+        exit_code = -1
+        timed_out = False
+        log_handle = None
+        log_path = logs_dir / f"test_gate_{_sanitize_filename(test.name)}.log"
+
         try:
-            result = subprocess.run(
+            try:
+                log_handle = open(log_path, "w", encoding="utf-8")
+            except OSError:
+                log_handle = None
+
+            # Start process with stdout/stderr combined and piped
+            proc = subprocess.Popen(
                 test.command,
                 shell=True,
                 cwd=project_root,
-                capture_output=True,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
                 text=True,
-                timeout=test.timeout,
+                bufsize=1,  # Line buffered
             )
 
-            passed = result.returncode == 0
-            output = result.stdout + result.stderr
+            # Stream output in background thread
+            output_queue: Queue = Queue(maxsize=output_queue_size)
+            reader_thread = threading.Thread(
+                target=stream_output,
+                args=(proc, output_tail, output_queue, log_handle, output_truncated),
+                daemon=True,
+            )
+            reader_thread.start()
+
+            # Read from queue and display in TUI until process completes or timeout
+            start_time = time.time()
+            while True:
+                try:
+                    line = output_queue.get(timeout=0.1)
+                    if line is None:
+                        break  # Reader finished
+                    # Stream each line to TUI (prefix with test name for context)
+                    tui_app.add_activity(f"  {line[:200]}", "│")
+                except Empty:
+                    pass
+
+                # Check timeout
+                if time.time() - start_time > test.timeout:
+                    proc.kill()
+                    timed_out = True
+                    break
 
-            # Truncate output for display
-            output_preview = output[:2000] if len(output) > 2000 else output
+                # Check if process finished
+                if proc.poll() is not None and output_queue.empty():
+                    break
 
-            results.append({
-                "name": test.name,
-                "command": test.command,
-                "passed": passed,
-                "exit_code": result.returncode,
-                "output": output_preview,
-            })
+            # Wait for reader thread to finish
+            reader_thread.join(timeout=1.0)
 
-            if passed:
-                tui_app.add_activity(f"✓ {test.name} passed", "✅")
+            # Get exit code - must call wait() to ensure returncode is populated
+            if timed_out:
+                exit_code = -1
             else:
-                tui_app.add_activity(f"✗ {test.name} failed (exit code {result.returncode})", "❌")
-                all_passed = False
-                failed_tests.append(test.name)
+                try:
+                    proc.wait(timeout=5)  # Ensure process fully terminated
+                except subprocess.TimeoutExpired:
+                    proc.kill()
+                    proc.wait()
+                exit_code = proc.returncode if proc.returncode is not None else -1
 
-                # Stop on first failure if fail_fast is enabled
-                if test_config.fail_fast:
-                    tui_app.add_activity("Stopping (fail_fast enabled)", "⚠")
-                    break
+        except Exception as e:
+            output_tail.append(f"Error running command: {e}")
+            exit_code = -1
+        finally:
+            if log_handle:
+                try:
+                    log_handle.close()
+                except OSError:
+                    pass
+
+        # Process results - include bounded tail for artifact
+        output = "".join(output_tail)
+        if output_truncated[0]:
+            output = (
+                f"[Output truncated to last {max_output_chars} characters. "
+                f"Full log: {log_path}]\n\n{output}"
+            )
 
-        except subprocess.TimeoutExpired:
-            results.append({
-                "name": test.name,
-                "command": test.command,
-                "passed": False,
-                "exit_code": -1,
-                "output": f"Command timed out after {test.timeout} seconds",
-            })
+        if timed_out:
+            results.append(
+                {
+                    "name": test.name,
+                    "command": test.command,
+                    "passed": False,
+                    "exit_code": -1,
+                    "output": f"Command timed out after {test.timeout} seconds\n\n{output}",
+                }
+            )
             tui_app.add_activity(f"✗ {test.name} timed out", "⏱️")
             all_passed = False
             failed_tests.append(test.name)
 
             if test_config.fail_fast:
                 break
+        else:
+            passed = exit_code == 0
+            results.append(
+                {
+                    "name": test.name,
+                    "command": test.command,
+                    "passed": passed,
+                    "exit_code": exit_code,
+                    "output": output,
+                }
+            )
 
-        except Exception as e:
-            results.append({
-                "name": test.name,
-                "command": test.command,
-                "passed": False,
-                "exit_code": -1,
-                "output": f"Error running command: {e}",
-            })
-            tui_app.add_activity(f"✗ {test.name} error: {e}", "❌")
-            all_passed = False
-            failed_tests.append(test.name)
+            if passed:
+                tui_app.add_activity(f"✓ {test.name} passed", "✅")
+            else:
+                tui_app.add_activity(f"✗ {test.name} failed (exit code {exit_code})", "❌")
+                all_passed = False
+                failed_tests.append(test.name)
 
-            if test_config.fail_fast:
-                break
+                # Stop on first failure if fail_fast is enabled
+                if test_config.fail_fast:
+                    tui_app.add_activity("Stopping (fail_fast enabled)", "⚠")
+                    break
 
     # Build TEST_GATE_RESULTS.md artifact
     passed_count = sum(1 for r in results if r["passed"])
@@ -366,7 +477,9 @@ def _execute_test_gate(
         artifact_lines.append(f"\n**Command:** `{r['command']}`\n")
         artifact_lines.append(f"**Exit Code:** {r['exit_code']}\n")
         if r["output"]:
-            artifact_lines.append(f"\n<details>\n<summary>Output</summary>\n\n```\n{r['output']}\n```\n\n</details>\n")
+            artifact_lines.append(
+                f"\n<details>\n<summary>Output</summary>\n\n```\n{r['output']}\n```\n\n</details>\n"
+            )
 
     write_artifact("TEST_GATE_RESULTS.md", "".join(artifact_lines), task_name)
     tui_app.add_activity("Wrote TEST_GATE_RESULTS.md", "📝")

galangal/core/workflow/tui_runner.py

@@ -80,12 +80,16 @@ def _run_workflow_with_tui(state: WorkflowState) -> str:
 
     # Compute hidden stages based on task type and config
     hidden_stages = frozenset(get_hidden_stages_for_task_type(state.task_type, config.stages.skip))
+    activity_log_path = None
+    if config.logging.activity_file:
+        activity_log_path = config.logging.activity_file.format(task_name=state.task_name)
 
     app = WorkflowTUIApp(
         state.task_name,
         state.stage.value,
         hidden_stages=hidden_stages,
         stage_durations=state.stage_durations,
+        activity_log_path=activity_log_path,
     )
 
     # Create workflow engine

galangal/prompts/defaults/dev.md

@@ -12,11 +12,13 @@ Implement all changes described in PLAN.md while satisfying the acceptance crite
 
 ### If ROLLBACK.md exists (Rollback Run):
 1. Read ROLLBACK.md - contains issues that MUST be fixed
-2. Read the relevant report (QA_REPORT.md, SECURITY_CHECKLIST.md, or REVIEW_NOTES.md)
+2. Read the relevant report (QA_REPORT.md, SECURITY_CHECKLIST.md, REVIEW_NOTES.md, or TEST_GATE_RESULTS.md)
 3. Fix ALL issues documented in ROLLBACK.md
 4. Update DEVELOPMENT.md with fixes made
 5. Done - workflow continues to re-run validation
 
+**CRITICAL - TEST_GATE Rollbacks:** If rolling back from TEST_GATE, you MUST fix ALL failing tests listed in TEST_GATE_RESULTS.md, **even if the tests were not modified by this task and appear to be pre-existing failures**. The workflow cannot proceed until all tests pass. Do not skip fixing a test because it seems "unrelated" - fix it anyway to unblock the pipeline.
+
 ### If DEVELOPMENT.md exists (Resuming):
 1. Read DEVELOPMENT.md to understand progress so far
 2. Continue from where the previous session left off
@@ -73,7 +75,7 @@ Update DEVELOPMENT.md after completing each significant piece of work:
 ## Important Rules
 
 - ONLY implement what's in PLAN.md - nothing more
-- Do NOT fix pre-existing issues unrelated to your task
+- Do NOT fix pre-existing issues unrelated to your task (EXCEPTION: TEST_GATE failures - see above)
 - Follow existing patterns in the codebase
 - Keep changes minimal and focused
 - Do NOT write tests - the TEST stage handles that

galangal/ui/tui/app.py

@@ -22,6 +22,7 @@ Layout:
 import asyncio
 import threading
 import time
+from collections import deque
 from collections.abc import Callable
 from pathlib import Path
 
@@ -86,6 +87,8 @@ class WorkflowTUIApp(WidgetAccessMixin, App[None]):
         _paused: Set to True when user requests pause.
         _workflow_result: Result string set by workflow thread.
     """
+    ACTIVITY_LOG_MAX_ENTRIES = 5000
+    RICH_LOG_MAX_LINES = 1000
 
     TITLE = "Galangal"
     CSS_PATH = "styles/app.tcss"
@@ -107,6 +110,7 @@ class WorkflowTUIApp(WidgetAccessMixin, App[None]):
         max_retries: int = 5,
         hidden_stages: frozenset[str] | None = None,
         stage_durations: dict[str, int] | None = None,
+        activity_log_path: str | Path | None = None,
     ) -> None:
         super().__init__()
         self.task_name = task_name
@@ -121,7 +125,19 @@ class WorkflowTUIApp(WidgetAccessMixin, App[None]):
 
         # Raw lines storage for verbose replay
         self._raw_lines: list[str] = []
-        self._activity_entries: list[ActivityEntry] = []
+        self._activity_entries: deque[ActivityEntry] = deque(
+            maxlen=self.ACTIVITY_LOG_MAX_ENTRIES
+        )
+        self._activity_log_handle = None
+        if activity_log_path:
+            try:
+                log_path = Path(activity_log_path)
+                log_path.parent.mkdir(parents=True, exist_ok=True)
+                self._activity_log_handle = open(
+                    log_path, "a", encoding="utf-8", buffering=1
+                )
+            except OSError:
+                self._activity_log_handle = None
 
         # Workflow control
         self._paused = False
@@ -147,7 +163,12 @@ class WorkflowTUIApp(WidgetAccessMixin, App[None]):
                 yield ErrorPanelWidget(id="error-panel", classes="hidden")
                 with Horizontal(id="content-area"):
                     with VerticalScroll(id="activity-container"):
-                        yield RichLog(id="activity-log", highlight=True, markup=True)
+                        yield RichLog(
+                            id="activity-log",
+                            highlight=True,
+                            markup=True,
+                            max_lines=self.RICH_LOG_MAX_LINES,
+                        )
                     yield FilesPanelWidget(id="files-container")
             yield CurrentActionWidget(id="current-action")
             yield Footer()
@@ -274,7 +295,11 @@ class WorkflowTUIApp(WidgetAccessMixin, App[None]):
             details=details,
         )
         self._activity_entries.append(entry)
-
+        if self._activity_log_handle:
+            try:
+                self._activity_log_handle.write(entry.format_export() + "\n")
+            except OSError:
+                self._activity_log_handle = None
         def _add() -> None:
             # Only show activity in compact (non-verbose) mode
             if not self.verbose:
@@ -804,7 +829,7 @@ class WorkflowTUIApp(WidgetAccessMixin, App[None]):
         else:
             log.write("[#b8bb26]Switched to COMPACT mode[/]")
             # Replay recent activity entries
-            for entry in self._activity_entries[-30:]:
+            for entry in list(self._activity_entries)[-30:]:
                 log.write(entry.format_display())
 
     def action_toggle_files(self) -> None:
@@ -827,7 +852,7 @@ class WorkflowTUIApp(WidgetAccessMixin, App[None]):
     @property
     def activity_entries(self) -> list[ActivityEntry]:
         """Get all activity entries for filtering or export."""
-        return self._activity_entries.copy()
+        return list(self._activity_entries)
 
     def export_activity_log(self, path: str | Path) -> None:
         """
@@ -836,7 +861,7 @@ class WorkflowTUIApp(WidgetAccessMixin, App[None]):
         Args:
             path: File path to write the log to.
         """
-        export_activity_log(self._activity_entries, Path(path))
+        export_activity_log(list(self._activity_entries), Path(path))
 
     def get_entries_by_level(self, level: ActivityLevel) -> list[ActivityEntry]:
         """Filter entries by severity level."""
@@ -846,6 +871,13 @@ class WorkflowTUIApp(WidgetAccessMixin, App[None]):
         """Filter entries by category."""
         return [e for e in self._activity_entries if e.category == category]
 
+    def on_shutdown(self) -> None:
+        if self._activity_log_handle:
+            try:
+                self._activity_log_handle.close()
+            except OSError:
+                pass
+
 
 class StageTUIApp(WorkflowTUIApp):
     """

galangal/ui/tui/widgets.py

@@ -189,6 +189,8 @@ class CurrentActionWidget(Static):
 class FilesPanelWidget(Static):
     """Panel showing files that have been read/written."""
 
+    MAX_FILES_HISTORY = 100
+
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
         self._files: list[tuple[str, str]] = []
@@ -198,6 +200,8 @@ class FilesPanelWidget(Static):
         entry = (action, path)
         if entry not in self._files:
             self._files.append(entry)
+            if len(self._files) > self.MAX_FILES_HISTORY:
+                self._files = self._files[-self.MAX_FILES_HISTORY :]
             self.refresh()
 
     def render(self) -> Text:

galangal/validation/runner.py

@@ -239,26 +239,35 @@ class ValidationRunner:
                 rollback_to="DEV",
             )
 
-        # Check for pass/fail markers in artifacts (for AI-driven stages)
-        if stage_config.artifact and stage_config.pass_marker:
-            result = self._check_artifact_markers(stage_config, task_name)
+        # Decision file checks - these take precedence over artifact markers
+        # because backends (like Codex) write explicit decision files
+
+        # TEST stage: check TEST_DECISION file
+        if stage_lower == "test":
+            result = validate_stage_decision("TEST", task_name, "TEST_PLAN.md")
             if not result.success:
                 return result
 
-        # QA stage: always check QA_DECISION file first
+        # QA stage: check QA_DECISION file
         if stage_lower == "qa":
             result = self._check_qa_report(task_name)
             if not result.success:
                 return result
 
-        # REVIEW stage: check REVIEW_DECISION file first (for Codex/independent reviews)
+        # REVIEW stage: check REVIEW_DECISION file (for Codex/independent reviews)
         if stage_lower == "review":
             result = validate_stage_decision("REVIEW", task_name, "REVIEW_NOTES.md")
             if result.success or result.rollback_to:
-                # Either passed or has a clear rollback target - return this result
+                # Valid decision found - use it
                 return result
             # Fall through to artifact marker check if decision file missing/unclear
 
+        # Check for pass/fail markers in artifacts (fallback for AI-driven stages)
+        if stage_config.artifact and stage_config.pass_marker:
+            result = self._check_artifact_markers(stage_config, task_name)
+            if not result.success:
+                return result
+
         # Check required artifacts
         for artifact_name in stage_config.artifacts_required:
             if not artifact_exists(artifact_name, task_name):

{galangal_orchestrate-0.13.0.dist-info → galangal_orchestrate-0.13.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: galangal-orchestrate
-Version: 0.13.0
+Version: 0.13.4
 Summary: AI-driven development workflow orchestrator
 Project-URL: Homepage, https://github.com/Galangal-Media/galangal-orchestrate
 Project-URL: Repository, https://github.com/Galangal-Media/galangal-orchestrate

{galangal_orchestrate-0.13.0.dist-info → galangal_orchestrate-0.13.4.dist-info}/RECORD

@@ -1,4 +1,4 @@
-galangal/__init__.py,sha256=XPwSFfqz5vAUsOJqKfHiscXlx3Ft0nzeKsgBvu4G808,727
+galangal/__init__.py,sha256=0C6zySvsBdJkFxn1BwmA6sO2V2WSSUVcUd2nXUHZhh4,727
 galangal/__main__.py,sha256=zd1kDtEp65NKzxMYIf7eg48aXFxR3FlQgCcaVP5hGbg,114
 galangal/cli.py,sha256=cBPgMpxQD691l5Xs3GKXg-QbNS5YRnnmWhPK83DHgCY,11990
 galangal/exceptions.py,sha256=skJSzdtrB58J_d7qqIuDyDlc1DlhPF-kV8xbgGTmIwA,697
@@ -6,12 +6,12 @@ galangal/logging.py,sha256=rCgAW9Eux4-AmK2nsBKtWD-w_6jydPaG3YD9RxYvZ2g,9798
 galangal/results.py,sha256=Q6kINppudmM8fMYkLZxpqqbzGd5oClURk_vV_fYnkgM,5277
 galangal/ai/__init__.py,sha256=JewgRcJ_N9RkoyM-lC9wUOA_uS-ZeTTviLBep-0hN5E,4663
 galangal/ai/base.py,sha256=GPshLQbNwaPw2ROxiSwM805sxNDv7Vz6Oh-bWdhy9Sw,4993
-galangal/ai/claude.py,sha256=BWeWYRdDGtTMxrllweGU-r0kzHS9A9P8fxE1mCr5hQU,13085
-galangal/ai/codex.py,sha256=vQxXY2j_kPLWLHio29doJaPRG7m5LQHWVD_9k8f5pZs,13403
+galangal/ai/claude.py,sha256=7la3zQL7EiCfXj3QwwgH1zkJvVArVqOBJ2sA0BS5gxU,11176
+galangal/ai/codex.py,sha256=5_84f42zUkTNfn3X-yiXqo9-NyaLMERrq4I9pnHMb6g,13441
 galangal/ai/gemini.py,sha256=cqjYvu1cawC_Cn5ETAmaCn1CZBYO1HjbwpY8gjFGjBQ,1097
-galangal/ai/subprocess.py,sha256=2W41YdpxpP-qLMTvJh_6ySmGpyxo6KJDQ1cozm1FmRM,7803
+galangal/ai/subprocess.py,sha256=rxaMyqtE_WJKmiMWCbLX69C3yzMMICnsElrCISGKnUE,9542
 galangal/commands/__init__.py,sha256=zYzp6PFc3tIVQXuufv9xZG0LNsmq5Eu9lQb3mDT-WrI,750
-galangal/commands/complete.py,sha256=ThAN6r76eq9rx6iYqUTdcpr9Al92KBHe1aOozxZVTuA,11698
+galangal/commands/complete.py,sha256=Xff1-P2I0saUJAga2pVZoJ8VXiCBCt7cIf_XVNdqlCA,11862
 galangal/commands/github.py,sha256=W7hA7qMuTsJThcLudOFvONZr5L4EC-8rKf69EK6pCYM,12553
 galangal/commands/init.py,sha256=TWpUO-ofjHC7htPyXrl5CI6b05MzcwJm3A9GR_T6gwI,6549
 galangal/commands/init_wizard.py,sha256=v-h0fsdVPaOqCWUEzD2Qje-bEp17qwVtq6bRBZ7gFuo,24596
@@ -21,23 +21,24 @@ galangal/commands/prompts.py,sha256=xj4wv5QV1o1z0-4sLZDeO7l4AJYc26724we6jXFD1U8,
 galangal/commands/reset.py,sha256=9D1X0okJ_8IjzJXTpKn6xRBxokp4CCJSzJ3fzKNpBBE,1038
 galangal/commands/resume.py,sha256=EOc0HME1B7CeF_tFnNrB7L_8A4GgmwKQK8Rpbv-glSo,921
 galangal/commands/skip.py,sha256=dXVLx6Ek6lPBO8qPWtNXDpTVQ_C6EyU9jlF4xRSy0_w,2040
-galangal/commands/start.py,sha256=2gwFxoy9aNKsdDCLkZPdKR1KWWMvI8-7xXYCyDfAQ2g,21883
+galangal/commands/start.py,sha256=59NFWc5xfPC6mWyEHX6GgcrRkIgf6qUViyBYs8wtx-Y,22078
 galangal/commands/status.py,sha256=OyW4OIaC6t_YksXZhRNn0rooZFR2B3UPnQRKg9MylPk,1278
 galangal/commands/switch.py,sha256=DMSZOs0052Ixwj1WbEdPOk6ymiCyJ1tn57kx2Pkk2KY,873
 galangal/config/__init__.py,sha256=o8JFiRGhfcGx0SZOn9TMEzbFQ3ZpIEHEY2lEaQZ-XMw,389
 galangal/config/defaults.py,sha256=NSopfnc1xV2u84NaCyG3k5mf_5P6RSKBRAIHIoZUDEY,5116
 galangal/config/loader.py,sha256=qBj73K7WpIn6Fx4aSZ2Qq4AIxhMfXQFvzdZdUwpug4I,4503
-galangal/config/schema.py,sha256=s6f7DOr-VDxBzq1hTT_AMJuIBECy5lW5UWqao6iEGqU,12183
+galangal/config/schema.py,sha256=0XS3QY8lKiG2364jqJK9BBBnVWeWVyYH1ztx-ljLYq4,12679
 galangal/core/__init__.py,sha256=xwdbMC3dRVRva7nx6Z-ldvsHJpRQ0AuJ2y7BDty-KXk,752
 galangal/core/artifacts.py,sha256=ESDjRR-W6gxJw-w7M1dzvjf1-AObeAnqvMrWsDfNp1c,4101
-galangal/core/state.py,sha256=wASC_We2JZd07cW9wqEwDNV3e1ola5znX1iXX1cQYu4,35557
+galangal/core/state.py,sha256=ASyXwd9rPjl7RCb-DCCc3etIwPdmrCul3UNN3iMgKOk,35804
 galangal/core/tasks.py,sha256=nf5S959ZxmLINuOml-KppxLrq__2BjyirZZ9LNwbDtE,14251
 galangal/core/utils.py,sha256=_x-IUKQIMfyVUrdXNEkOO_86Cu3U3RaYb6tk6cud4pI,3168
+galangal/core/version_check.py,sha256=06_FTIj31AQeEpRoJSgJ4j8ZvMbHiFzDZjXWuGHRA8c,6422
 galangal/core/workflow/__init__.py,sha256=czmKbueeASxSroOtlImSE86AOikmtNkpnGCUSP7JgSw,1879
-galangal/core/workflow/core.py,sha256=Q0lksYjGnv_iMndGA0ZJ4kZK4qrHe5cHXc-chrEoZTc,27898
+galangal/core/workflow/core.py,sha256=1iJdUxhbk6_qM-F1DYlbfqyCEzXS82358lbLbROgeaE,31872
 galangal/core/workflow/engine.py,sha256=XJKSkvRAQgeMIQLOs0Q_7dL8RnnVmfkIOezTcABIVRw,26506
 galangal/core/workflow/pause.py,sha256=N9lpNIWLW7B7hOYcAyV_UgCXMNnKtj9jDkk5x_fE-zE,1258
-galangal/core/workflow/tui_runner.py,sha256=GTcgLzyRvSO2lGpUwHGIXJNvG1huWuD68xY-la0F_6k,48833
+galangal/core/workflow/tui_runner.py,sha256=ansGUiBzydBkOXyMnfZg-5J8DmcQsf0-92SfZjJY34U,49035
 galangal/github/__init__.py,sha256=CwSVvTQhVpwAJjyNsc7mXTKgNMFtZy7Eav7m_9ivG7o,765
 galangal/github/client.py,sha256=zY7yrFJLp9Cn079fQDz5aIj5ddB7XOfbf75sY0RBUe8,12563
 galangal/github/images.py,sha256=belPmFLClmwxjcV5dRbm8Dt3HUz8LnHZxOIHmwa5glY,9769
@@ -47,7 +48,7 @@ galangal/prompts/builder.py,sha256=ljuxp3-oBihebzI7Vr8HQLBhG6_98rYx9kObdCnehik,2
 galangal/prompts/defaults/benchmark.md,sha256=xWIinvjn04gLVSoPkeNWZqvPB33iwUP9RCpIH5bsySA,951
 galangal/prompts/defaults/contract.md,sha256=sYc8Rf5Qr7Ql_D5euzVAZDypH1NocRVAERtc37g82Zk,1085
 galangal/prompts/defaults/design.md,sha256=8Wa_saExSlWsBMG78GFSQAC2OoiNIC4Mgg-RPYoBqEE,1280
-galangal/prompts/defaults/dev.md,sha256=kTV_C9HTDOKl7u7LXwoL75cgx_IBKiYw23e8mpfukFs,2918
+galangal/prompts/defaults/dev.md,sha256=KBpjemCKL7lr7pEYIRCNPamJfDSbWu8gZTs1ewCW5eI,3355
 galangal/prompts/defaults/docs.md,sha256=myjqZtOdthZo2go_vCa4zcylKZj44bmyVLeoVSOhnGA,3348
 galangal/prompts/defaults/migration.md,sha256=4Gu8V8b0qp9_UAdo1eabl-HLRJ2Y_ohRL1SLHNaiuHo,1615
 galangal/prompts/defaults/pm.md,sha256=Moj7jw978HeesTowxPIoJxtbLRdI1eyIdQY-wcmO370,2982
@@ -62,18 +63,18 @@ galangal/ui/__init__.py,sha256=B-VP2_Fsnc_W-sbg39pjo933wynRhFG5wJFEBohNLyk,203
 galangal/ui/console.py,sha256=dBUd9ANZvPHefnQGSFLmDBPUrJ7MyRcW1_dq_NAgl20,3859
 galangal/ui/tui/__init__.py,sha256=iCRDcdcRPoXMbVg6tsMqShZH47usbztKwU6FDly9QQY,1474
 galangal/ui/tui/adapters.py,sha256=aM9T2x5ru8-ZFYSOzGf3qAHi2bVAnR7nzQsp1Oky_iE,5920
-galangal/ui/tui/app.py,sha256=a9iEKsle01uTaODeM0QfkNgT4-swib-zgfdXX6MkOJY,33566
+galangal/ui/tui/app.py,sha256=zwRi9YA7UwF50l2JhMfiuX22thKB5t2ddHC2Ek1bssQ,34779
 galangal/ui/tui/entry.py,sha256=Y3hKKxfyFstt6BvEdyAaKQyyvUZnccZVXK1d-RtwuIA,463
 galangal/ui/tui/mixins.py,sha256=6UBbuRCGG8r9YEF_7mgYbToE4sfTGrcU7oQHF1o6I-o,5770
 galangal/ui/tui/modals.py,sha256=8njkQYeYKZ7r8aIhde82yaW4cxBrSZGSuQEEbUb6tFA,11308
 galangal/ui/tui/types.py,sha256=I6p6FNOUZxYM3o2x3qiBeuIA1IWYOF3FQ_QaqloN1CA,3251
-galangal/ui/tui/widgets.py,sha256=gjtbJH-POmQov92vIJ6P-E1UfLD6ailoqPALN5dAtzY,8857
+galangal/ui/tui/widgets.py,sha256=BbhE4yxW1QSwDH2QSjfb04Cq6ug1t7FyFyz-0bU0TBY,9013
 galangal/ui/tui/styles/app.tcss,sha256=qxPdBLQLrDAOoEN-v0nk7EydvkIlk0wd5oTEY4PdsWg,1236
 galangal/ui/tui/styles/modals.tcss,sha256=IxJcvs9gPuK9JDXTQgiYlcZaa_Kz3wbc_mrOOGvfgXA,3404
 galangal/validation/__init__.py,sha256=mS82eDVJXG32rMB9-fI2gMHlKXHVE8KrcvwFH8VHrmU,152
-galangal/validation/runner.py,sha256=51igBlz8ImEwk46XHc6jDmT2so4qakoBsKwL3bFGqmc,41359
-galangal_orchestrate-0.13.0.dist-info/METADATA,sha256=TW8VvTB6-iVpdwkqFKmCmXzziF-iRqc7hyGTTsA3kPs,29547
-galangal_orchestrate-0.13.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-galangal_orchestrate-0.13.0.dist-info/entry_points.txt,sha256=ePx9z6dVezeZmGtiuGb2MfQmmXpcYfawF6HtP0WKNfk,47
-galangal_orchestrate-0.13.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-galangal_orchestrate-0.13.0.dist-info/RECORD,,
+galangal/validation/runner.py,sha256=gMGXyQtp5tP6nbogO2r1KvuVpdvF9vqLUX5AMxhbGIE,41688
+galangal_orchestrate-0.13.4.dist-info/METADATA,sha256=PcAfVDYFR226nNi3XdkccO7A9SiBs0N1bW2bjFojQEY,29547
+galangal_orchestrate-0.13.4.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+galangal_orchestrate-0.13.4.dist-info/entry_points.txt,sha256=ePx9z6dVezeZmGtiuGb2MfQmmXpcYfawF6HtP0WKNfk,47
+galangal_orchestrate-0.13.4.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+galangal_orchestrate-0.13.4.dist-info/RECORD,,