devflow-engine 1.0.0__py3-none-any.whl

devin/nodes/iterate/scenarios/routing-matrix.md

@@ -0,0 +1,45 @@
+# Iterate routing scenario matrix
+
+## Purpose
+
+This file makes the lane boundary concrete. It should stay aligned with:
+- `pipeline/01-objectives-requirements.md` for route-fit rules
+- `pipeline/02-evals.md` for what routing mistakes must be catchable
+- the Iterator, Framer, Observer, Coder model, where Iterator owns final lane judgment and may re-route when better truth appears
+
+## Routing matrix
+
+| Scenario | Initial read | Why | Expected route |
+| --- | --- | --- | --- |
+| concrete_error_fix | User reports a specific failure on an existing surface and wants it fixed | bounded implementation ask with observable failure | `iterate` |
+| quick_behavior_change | User wants a small change to current behavior on an existing page, route, or component | targeted delta, not broad planning | `iterate` |
+| targeted_ui_improvement | User wants a narrow UX or UI improvement on an existing surface | bounded improvement with scoped success criteria | `iterate` |
+| explain_why_error_happens | User wants diagnosis or explanation only | read-only intent, no implementation requested | `insight` |
+| investigate_before_any_change | User asks for analysis first and does not yet want a fix | read-only investigation | `insight` |
+| broad_feature_request | Request introduces a new workflow, broader feature area, or story-scale planning need | no longer task-scale | `idea` |
+| task_grows_after_framing | Initial ask sounds small, but Framer discovers broader planning or architecture work is required | promote when better truth appears | promote to `idea` |
+
+## Notes on who owns the decision
+
+- intake may make the first route guess
+- `Framer` may surface evidence that the ask is broader or less concrete than it looked
+- `Observer` may surface evidence that the user actually wanted diagnosis only or that the task lacks observable truth
+- `Iterator` owns the final judgment on whether the work stays in iterate, reroutes to insight, or promotes to idea
+- when rerouting or promoting after iterate has started, Iterator should leave an iterate-owned `promotion_handoff.json` rather than making the lane transition visible only in response text
+
+The lane should optimize for truthful routing, not for preserving the initial choice.
+
+## Additional scenario guidance
+
+### Stay in iterate
+Stay in `iterate` when the work can still be described as a bounded delta on an existing surface, even if implementation is nontrivial.
+
+### Promote to idea
+Promote to `idea` when success now depends on choosing among broader product, workflow, or architecture options rather than delivering the originally bounded delta.
+
+### Route to insight
+Route to `insight` when the user wants explanation, diagnosis, or investigation and would reasonably be surprised if the system started changing code.
+
+## Review note
+
+If a reviewer cannot tell why a scenario belongs in `iterate`, `insight`, or `idea`, the upstream objectives are still too fuzzy.

devin/nodes/shared/filemaker_expert.md

@@ -0,0 +1,80 @@
+# FileMaker Expert — advisor for Devin's insight agent
+# Pi-Pi pattern: Devin (primary) calls query_filemaker_expert → spawns PI subprocess
+#                 with this prompt → expert reads DDR artifacts → returns text response
+#                 → Devin synthesizes into answer
+
+---
+name: filemaker_expert
+description: >
+  FileMaker database expert — read-only advisor. Reads DDR analysis artifacts
+  and answers questions about database structure, layouts, scripts, entities,
+  user flows, and feature clusters. Does NOT run ddr-docs — only reads.
+tools: read,grep,find,ls,cat
+---
+You are a **FileMaker Database Expert** — a narrow, read-only advisor agent.
+
+Your job: receive a question about a FileMaker database, read the relevant DDR analysis artifacts, and return a thorough, grounded response.
+
+## Your domain
+
+DDR analysis artifacts live under:
+`{repo_root}/ai_docs/context/source_docs/ddr/{database_name}/`
+
+**Detailed JSON (use first for anything requiring precision):**
+- `03_scripts_detailed.json` — complete script steps with full calculations (use INSTEAD of the summary for script logic)
+- `01_schema_detailed.json` — full field definitions with calculations, auto-enter, validation
+- `05_layouts_detailed.json` — complete layout object inventory
+- `02_relationships_detailed.json` — full relationship graph with all join paths
+- `04_custom_functions_detailed.json` — custom functions with full formula text
+
+**Summary markdown (overviews only):**
+- `01_schema_summary.md` — table count and field type overview
+- `05_layouts_summary.md` — layout counts and object counts
+- `03_scripts_summary.md` — script/folder list (truncates all calculations at ~50 chars — do NOT rely on it for step details)
+- `02_relationships_summary.md` — relationship graph overview
+
+## Source priority
+
+**JSON is the source for details. Markdown summaries are for overviews only.**
+
+- For anything involving calculations, SQL queries, script step logic, field-level detail, or specific values: read from the detailed JSON files
+- Markdown summaries are useful for navigation and overview — they tell you what exists and the general structure
+- Detailed JSON files (`*_detailed.json`) have the complete untruncated content
+
+**Key detailed files:**
+- `03_scripts_detailed.json` — every script step with FULL calculation text, untruncated (vs. summary's 50-char cutoff)
+- `01_schema_detailed.json` — complete field definitions, calculations, auto-enter logic
+- `05_layouts_detailed.json` — full layout object inventory
+- `02_relationships_detailed.json` — complete relationship graph
+
+**For script analysis:** always start from `03_scripts_detailed.json`. The summary (`03_scripts_summary.md`) truncates every calculation to ~50 chars — `JSONGetElement(Get(ScriptResult);"qbID")` becomes `JSONGetElement(Get(ScriptResult);"q` — making it unreadable. The detailed JSON has the complete text.
+
+JSON in `analysis/` subdirectory:
+- `analysis/feature_clusters.json` — grouped capabilities with descriptions
+- `analysis/user_flows_entry_points.json` — entry point patterns
+- `analysis/cruft_summary.json` — code health (uncalled scripts, unreachable layouts)
+
+Context files in `ai_docs/context/source_docs/`:
+- `domain_entities.json`, `user_workflows.json`, `product_brief.json`
+
+## How to work
+
+1. Determine which database(s) the question is about
+2. Identify the DDR output directory for that database
+3. Use `read` / `cat` to read the relevant artifact files
+4. Synthesize a response with specific names, counts, and structural facts
+5. Return plain text — the primary agent will incorporate it
+
+## Answer style
+
+- Be concrete: "Clean Sweep has 455 layouts across 115 tables, including Account Page (654 objects), My Page/Cleaner dashboards, and Inspection Form III (225 objects)"
+- Use headers: ## Database Overview, ## Layouts, ## Scripts, ## Code Health
+- If the artifacts don't cover something, say "not in DDR analysis" and describe what's available
+- Do not speculate — if it's not in the files, say so
+
+## Constraints
+
+- Do NOT run ddr-docs or any analysis pipeline
+- Do NOT write or modify any files
+- Do not answer questions outside the FileMaker database domain
+- Do not use search tools unless needed to locate a specific artifact path

devin/nodes/shared/filemaker_expert.py

@@ -0,0 +1,354 @@
+"""FileMaker Expert advisor — read-only DDR analysis reader.
+
+Pi-Pi pattern: Devin (primary agent) calls FileMaker Expert as an advisor when it
+needs to answer FileMaker database questions. The expert reads pre-existing DDR
+analysis artifacts and returns a grounded, synthesized response.
+
+The expert does NOT re-run ddr-docs. Analysis is done once on import by the
+devflow_event_worker. The expert just reads what's already there.
+
+Location convention:
+  - Source XML: ai_docs/context/source_docs/<name>.xml
+  - DDR analysis:  ai_docs/context/source_docs/ddr/<name>/
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from pathlib import Path
+
+from devin.nodes.shared.tools import ToolResult
+
+
+@dataclass
+class DDRArtifacts:
+    """Paths to all available DDR analysis artifacts for one database."""
+    name: str
+    ddr_root: Path
+
+    @property
+    def analysis_dir(self) -> Path:
+        return self.ddr_root / "analysis"
+
+    def schema_summary_md(self) -> Path | None:
+        p = self.ddr_root / "01_schema_summary.md"
+        return p if p.exists() else None
+
+    def layouts_summary_md(self) -> Path | None:
+        p = self.ddr_root / "05_layouts_summary.md"
+        return p if p.exists() else None
+
+    def scripts_summary_md(self) -> Path | None:
+        p = self.ddr_root / "03_scripts_summary.md"
+        return p if p.exists() else None
+
+    def relationships_summary_md(self) -> Path | None:
+        p = self.ddr_root / "02_relationships_summary.md"
+        return p if p.exists() else None
+
+    def feature_clusters_json(self) -> Path | None:
+        p = self.analysis_dir / "feature_clusters.json"
+        return p if p.exists() else None
+
+    def entry_points_json(self) -> Path | None:
+        p = self.analysis_dir / "user_flows_entry_points.json"
+        return p if p.exists() else None
+
+    def cruft_summary_json(self) -> Path | None:
+        p = self.analysis_dir / "cruft_summary.json"
+        return p if p.exists() else None
+
+    def domain_entities_json(self) -> Path | None:
+        p = self.ddr_root.parent / "domain_entities.json"
+        return p if p.exists() else None
+
+    def user_workflows_json(self) -> Path | None:
+        p = self.ddr_root.parent / "user_workflows.json"
+        return p if p.exists() else None
+
+    def product_brief_json(self) -> Path | None:
+        p = self.ddr_root.parent / "product_brief.json"
+        return p if p.exists() else None
+
+
+def _read_text(path: Path | None, max_lines: int = 80) -> str:
+    if not path or not path.exists():
+        return "(not available)"
+    try:
+        lines = path.read_text(encoding="utf-8", errors="replace").splitlines()
+        return "\n".join(lines[:max_lines])
+    except Exception:
+        return "(read error)"
+
+
+def _read_json(path: Path | None) -> dict:
+    if not path or not path.exists():
+        return {}
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except Exception:
+        return {}
+
+
+def _summarize(md_path: Path | None, prefix: str) -> str:
+    """Extract the Total X count from a summary markdown header."""
+    if not md_path or not md_path.exists():
+        return "unknown"
+    try:
+        for line in md_path.read_text(encoding="utf-8", errors="replace").splitlines():
+            if prefix.lower() in line.lower():
+                parts = line.rsplit(":", 1)
+                if len(parts) == 2:
+                    return parts[-1].strip()
+    except Exception:
+        pass
+    return "unknown"
+
+
+def _synthesize_report(
+    artifacts: DDRArtifacts,
+    question: str,
+    include_summaries: bool = True,
+    include_workflows: bool = True,
+) -> str:
+    """Read all DDR artifacts and produce a synthesized expert report."""
+    sections: list[str] = []
+
+    # Database overview
+    schema_md = artifacts.schema_summary_md()
+    layouts_md = artifacts.layouts_summary_md()
+    scripts_md = artifacts.scripts_summary_md()
+    rels_md = artifacts.relationships_summary_md()
+
+    table_count = _summarize(schema_md, "Total Tables")
+    layout_count = _summarize(layouts_md, "Total Layouts")
+    script_count = _summarize(scripts_md, "Total Scripts")
+
+    sections.append(f"# FileMaker Expert Report: {artifacts.name}")
+    sections.append("")
+    sections.append("## Database Overview")
+    sections.append(f"- Tables: {table_count}")
+    sections.append(f"- Layouts: {layout_count}")
+    sections.append(f"- Scripts: {script_count}")
+    sections.append("")
+
+    # Schema excerpt
+    if include_summaries and schema_md:
+        sections.append("## Schema (excerpt)")
+        sections.append(_read_text(schema_md, max_lines=40))
+        sections.append("")
+
+    # Layouts excerpt
+    if include_summaries and layouts_md:
+        sections.append("## Layouts (excerpt)")
+        sections.append(_read_text(layouts_md, max_lines=50))
+        sections.append("")
+
+    # Scripts excerpt
+    if include_summaries and scripts_md:
+        sections.append("## Scripts (excerpt)")
+        sections.append(_read_text(scripts_md, max_lines=40))
+        sections.append("")
+
+    # Relationships
+    if include_summaries and rels_md:
+        sections.append("## Relationships (excerpt)")
+        sections.append(_read_text(rels_md, max_lines=30))
+        sections.append("")
+
+    # Feature clusters
+    fc_json = artifacts.feature_clusters_json()
+    if fc_json:
+        clusters = _read_json(fc_json)
+        cluster_list = clusters.get("clusters", [])
+        sections.append(f"## Feature Clusters ({len(cluster_list)} total)")
+        for c in cluster_list[:15]:
+            name = c.get("name", "unknown")
+            desc = c.get("description", "")[:100]
+            sections.append(f"- **{name}**: {desc}")
+        sections.append("")
+
+    # Entry points
+    ep_json = artifacts.entry_points_json()
+    if ep_json:
+        eps = _read_json(ep_json)
+        summary = eps.get("summary", {})
+        total = summary.get("total_entry_points", 0)
+        sections.append(f"## Entry Points (total: {total})")
+        entry_pts = eps.get("entry_points", {})
+        for key, val in entry_pts.items():
+            count = val.get("count", 0) if isinstance(val, dict) else 0
+            if count > 0:
+                sections.append(f"- {key}: {count}")
+        sections.append("")
+
+    # Cruft / code health
+    cruft_json = artifacts.cruft_summary_json()
+    if cruft_json:
+        cruft = _read_json(cruft_json)
+        problems: list[str] = []
+        for key in ("uncalled_scripts", "unreachable_layouts", "unreferenced_fields", "uncalled_functions"):
+            entry = cruft.get(key, {})
+            count = entry.get("count", 0) if isinstance(entry, dict) else 0
+            if count > 0:
+                problems.append(f"- {key}: {count}")
+        if problems:
+            sections.append("## Code Health (cruft detected)")
+            sections.extend(problems)
+            sections.append("")
+
+    # Domain entities
+    if include_workflows:
+        de_json = artifacts.domain_entities_json()
+        if de_json:
+            de = _read_json(de_json)
+            entities = de.get("entities", de.get("domain_entities", []))
+            if entities:
+                sections.append(f"## Domain Entities ({len(entities)} defined)")
+                for e in entities[:20]:
+                    name = e.get("name", "unknown")
+                    etype = e.get("type", "")
+                    fields = e.get("fields", [])
+                    sections.append(f"- **{name}** ({etype}, {len(fields)} fields)")
+                sections.append("")
+
+    # User workflows
+    uw_json = artifacts.user_workflows_json()
+    if include_workflows and uw_json:
+        uw = _read_json(uw_json)
+        workflows = uw.get("workflows", uw.get("user_workflows", []))
+        if workflows:
+            sections.append(f"## User Workflows ({len(workflows)} defined)")
+            for w in workflows[:15]:
+                name = w.get("name", "unknown")
+                steps = w.get("steps", w.get("stages", []))
+                sections.append(f"- **{name}**: {len(steps)} steps/stages")
+            sections.append("")
+
+    # Product brief
+    pb_json = artifacts.product_brief_json()
+    if include_workflows and pb_json:
+        pb = _read_json(pb_json)
+        brief_text = pb.get("brief", pb.get("description", pb.get("product_brief", "")))
+        if brief_text and len(brief_text) > 20:
+            sections.append("## Product Brief")
+            sections.append(str(brief_text)[:500])
+            sections.append("")
+
+    # Question answered
+    sections.append(f"---\n**Question:** {question}")
+
+    return "\n".join(sections)
+
+
+def filemaker_expert(
+    *,
+    question: str,
+    repo_root: Path,
+    include_summaries: bool = True,
+    include_workflows: bool = True,
+    database_name: str | None = None,
+) -> ToolResult:
+    """FileMaker Expert advisor — read-only DDR analysis reader.
+
+    Devin (primary agent) calls this to get a grounded FileMaker database report.
+    The expert reads pre-existing DDR analysis artifacts from:
+      ai_docs/context/source_docs/ddr/<database_name>/
+
+    It does NOT re-run ddr-docs. Analysis was done on import by devflow_event_worker.
+
+    Args:
+        question:       The question about the FileMaker database
+        repo_root:      Project repo root (e.g. /Users/devflow/repos/cleaner)
+        include_summaries: Include schema/layouts/scripts/relationships excerpts (default: true)
+        include_workflows: Include domain entities, user workflows, product brief (default: true)
+        database_name:  Specific database to focus on (derived from XML filename, e.g. "Clean Sweep_fmp12").
+                       If not provided, reports on all databases found.
+    """
+    try:
+        source_docs = repo_root / "ai_docs" / "context" / "source_docs"
+        ddr_base = source_docs / "ddr"
+
+        if not ddr_base.exists():
+            return ToolResult(
+                ok=False,
+                tool_name="FileMakerExpert",
+                output={},
+                error=f"DDR analysis directory not found: {ddr_base}. "
+                      "DDR analysis runs automatically on FileMaker file import — "
+                      "if no analysis exists yet, the files were imported but analysis may have failed.",
+            )
+
+        # Find all DDR outputs
+        ddr_dirs = sorted(ddr_base.iterdir())
+        if not ddr_dirs:
+            return ToolResult(
+                ok=False,
+                tool_name="FileMakerExpert",
+                output={},
+                error=f"No DDR analysis results in {ddr_base}",
+            )
+
+        # Filter to specific database if named
+        if database_name:
+            ddr_dirs = [d for d in ddr_dirs if d.name == database_name]
+            if not ddr_dirs:
+                available = [d.name for d in sorted(ddr_base.iterdir())]
+                return ToolResult(
+                    ok=False,
+                    tool_name="FileMakerExpert",
+                    output={},
+                    error=f"Database '{database_name}' not found. Available: {available}",
+                )
+
+        databases: dict[str, dict] = {}
+        reports: list[str] = []
+
+        for ddr_dir in ddr_dirs:
+            artifacts = DDRArtifacts(name=ddr_dir.name, ddr_root=ddr_dir)
+
+            schema_md = artifacts.schema_summary_md()
+            layouts_md = artifacts.layouts_summary_md()
+            scripts_md = artifacts.scripts_summary_md()
+
+            table_count = _summarize(schema_md, "Total Tables")
+            layout_count = _summarize(layouts_md, "Total Layouts")
+            script_count = _summarize(scripts_md, "Total Scripts")
+
+            report = _synthesize_report(
+                artifacts,
+                question=question,
+                include_summaries=include_summaries,
+                include_workflows=include_workflows,
+            )
+            reports.append(report)
+
+            databases[ddr_dir.name] = {
+                "table_count": table_count,
+                "layout_count": layout_count,
+                "script_count": script_count,
+                "ddr_root": str(ddr_dir.relative_to(repo_root)),
+                "has_schema": bool(schema_md),
+                "has_layouts": bool(layouts_md),
+                "has_scripts": bool(scripts_md),
+                "has_cruft": bool(artifacts.cruft_summary_json()),
+                "has_feature_clusters": bool(artifacts.feature_clusters_json()),
+            }
+
+        combined = "\n\n---\n\n".join(reports) if reports else "No analysis results found."
+
+        return ToolResult(
+            ok=True,
+            tool_name="FileMakerExpert",
+            output={
+                "question": question,
+                "databases": databases,
+                "expert_report": combined,
+                "database_count": len(databases),
+                "database_names": list(databases.keys()),
+            },
+        )
+
+    except Exception as e:
+        return ToolResult(ok=False, tool_name="FileMakerExpert", output={}, error=str(e))

devin/nodes/shared/filemaker_expert_eval/runner.py

@@ -0,0 +1,176 @@
+"""Eval harness for FileMaker expert advisor.
+
+Runs the filemaker_expert through the PI subprocess (matching devflow-tools.ts
+queryFilemakerExpert pattern) against scenario fixtures and scores the output.
+
+Usage:
+    python3 -m devin.nodes.shared.filemaker_expert_eval.runner
+"""
+
+from __future__ import annotations
+
+import json
+import re
+import subprocess
+import time
+from dataclasses import dataclass
+from pathlib import Path
+
+# _PROJECT_ROOT points to the devflow_engine repo root
+_PROJECT_ROOT = Path(__file__).resolve().parents[5]  # devflow_engine/
+_AGENT_FILE = ".pi/agents/filemaker-expert/filemaker-expert.md"
+
+# Default test project
+_DEFAULT_REPO_ROOT = "/Users/devflow/repos/cleaner"
+_DEFAULT_DATABASE = "Clean Sweep_fmp12"
+_DEFAULT_MODEL = "minimax/MiniMax-M2.7"
+
+
+@dataclass
+class ScenarioResult:
+    scenario_id: str
+    passed: bool
+    score: int
+    max_score: int
+    output: str
+    details: dict[str, int]
+    elapsed: float = 0.0
+
+
+def load_expert_prompt() -> str:
+    """Extract system prompt from expert definition file."""
+    content = _PROJECT_ROOT.joinpath(_AGENT_FILE).read_text()
+    match = re.match(r"^---\n[\s\S]*?\n---\n([\s\S]*)$", content, re.M)
+    return match.group(1).strip() if match else content
+
+
+def run_filemaker_expert(
+    question: str,
+    repo_root: str = _DEFAULT_REPO_ROOT,
+    database: str = _DEFAULT_DATABASE,
+    model: str = _DEFAULT_MODEL,
+    timeout: int = 90,
+) -> tuple[str, float]:
+    """Run the filemaker expert via PI subprocess and return (output, elapsed)."""
+    system_prompt = load_expert_prompt()
+
+    context_block = (
+        f"Context: repo_root={repo_root}, database={database}\n\n"
+        f"Question: {question}"
+    )
+
+    args = [
+        "pi",
+        "--mode", "text",
+        "--no-session",
+        "--no-extensions",
+        "--model", model,
+        "--tools", "read,grep,find,ls",
+        "--thinking", "off",
+        "--append-system-prompt", system_prompt + "\n\n" + context_block,
+        question,
+    ]
+
+    start = time.time()
+    proc = subprocess.Popen(
+        args,
+        stdin=subprocess.PIPE,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
+        cwd=str(_PROJECT_ROOT),
+    )
+    stdout, _ = proc.communicate(timeout=timeout)
+    elapsed = time.time() - start
+
+    return stdout, elapsed
+
+
+def score_scenario(output: str, scenario: dict) -> ScenarioResult:
+    """Score an expert output against a scenario's expected keys and structure."""
+    score = 0
+    max_score = sum(scenario["scoring"].values())
+    details = {}
+
+    for key, weight in scenario["scoring"].items():
+        # Check for expected keys in output
+        key_lower = key.lower().replace("_", " ")
+        if any(k in output for k in scenario["expected_keys"]):
+            details[key] = weight
+            score += weight
+        else:
+            details[key] = 0
+
+    return ScenarioResult(
+        scenario_id=scenario["id"],
+        passed=score == max_score,
+        score=score,
+        max_score=max_score,
+        output=output[:500],
+        details=details,
+    )
+
+
+def run_all_scenarios(
+    scenarios_path: str | Path | None = None,
+    repo_root: str = _DEFAULT_REPO_ROOT,
+    database: str = _DEFAULT_DATABASE,
+) -> list[ScenarioResult]:
+    """Run all scenarios and return results."""
+    if scenarios_path is None:
+        scenarios_path = Path(__file__).parent / "scenarios.json"
+
+    scenarios = json.loads(Path(scenarios_path).read_text())
+
+    results = []
+    for scenario in scenarios:
+        print(f"\nRunning: {scenario['id']}")
+        output, elapsed = run_filemaker_expert(
+            question=scenario["question"],
+            repo_root=repo_root,
+            database=database,
+        )
+        result = score_scenario(output, scenario)
+        result.elapsed = elapsed
+        results.append(result)
+
+        print(f"  Score: {result.score}/{result.max_score} ({elapsed:.1f}s)")
+        if not result.passed:
+            print(f"  Missing: {[k for k, v in result.details.items() if v == 0]}")
+
+    return results
+
+
+def print_report(results: list[ScenarioResult]) -> None:
+    """Print a formatted report of scenario results."""
+    total = sum(r.score for r in results)
+    max_total = sum(r.max_score for r in results)
+
+    print(f"\n{'='*60}")
+    print(f"FILEMAKER EXPERT EVAL REPORT")
+    print(f"{'='*60}")
+
+    for r in results:
+        status = "✓ PASS" if r.passed else "✗ FAIL"
+        print(f"\n{status} {r.scenario_id}  {r.score}/{r.max_score}")
+        for key, val in r.details.items():
+            icon = "✓" if val > 0 else "✗"
+            print(f"    {icon} {key}: {val}")
+
+    print(f"\n{'='*60}")
+    print(f"TOTAL: {total}/{max_total}  ({100*total/max_total:.0f}%)")
+    print(f"{'='*60}")
+
+
+if __name__ == "__main__":
+    import sys
+
+    repo_root = sys.argv[1] if len(sys.argv) > 1 else _DEFAULT_REPO_ROOT
+    database = sys.argv[2] if len(sys.argv) > 2 else _DEFAULT_DATABASE
+
+    print(f"Testing filemaker_expert against cleaner DDR artifacts")
+    print(f"repo_root: {repo_root}")
+    print(f"database: {database}")
+
+    results = run_all_scenarios(repo_root=repo_root, database=database)
+    print_report(results)