atomadic-forge 0.16.0__tar.gz → 0.16.2__tar.gz

{atomadic_forge-0.16.0 → atomadic_forge-0.16.2}/CHANGELOG.md

@@ -2,6 +2,53 @@
 
 ## Unreleased
 
+## v0.16.2 — 2026-05-06 welcome scope guard + Boris pre-demo hardening
+
+Pre-Boris-demo stress test surfaced a single class of welcome failure:
+running ``forge welcome`` (or the welcome MCP tool) from a workspace
+root walks every source file in every subdirectory.  In the rehearsal
+that meant 38 972 .py files instead of the 280 inside atomadic-forge,
+and the call appeared to "hang."  This release stops that at the
+substrate.
+
+- **welcome scope guard** — ``forge welcome`` now refuses to walk a
+  project root that holds more than ``--max-files`` (default 5 000)
+  source files, returning a structured ``verdict: REFUSE`` with the
+  observed file count and a clear "pass --project-root <narrower>
+  or --force" message.  CLI exits 2; MCP returns the same shape.
+  Counted via an ``itertools.islice`` over ``iter_source_files``,
+  so the guard itself bails in milliseconds.
+- **--force / --max-files** flags on ``forge welcome`` for the rare
+  case where a 5 000+ file repo is the right scope.
+- **PyPI install hygiene note** — the v0.16.x rehearsal also surfaced
+  that interrupted ``pip install --upgrade`` runs on Windows leave
+  ``~tomadic_forge*`` shadow distribution directories in
+  ``site-packages`` which can mask the active editable install on
+  long-running MCP processes.  Standard pip recovery is
+  ``pip install --upgrade --force-reinstall atomadic-forge`` (then
+  delete any remaining ``~*`` dirs).  Documented in
+  ``docs/troubleshooting/pip-shadow-dirs.md``.
+
+## v0.16.1 — 2026-05-06 six new CLI verbs (verify, smell, call-graph, cna-check, trust-gate, commit-compose)
+
+Six MCP-only tools that had no corresponding CLI verb are now reachable
+from the shell.  No behavioural changes to existing verbs.
+
+- **forge verify** — composite wire + certify gate; single PASS / REFINE / FAIL
+  verdict + non-zero exit code for CI steps.  Wraps the `verify` MCP tool.
+- **forge smell** — cyclomatic-complexity + long-function + duplicate-code scan;
+  emits a `smell_score` (0–100) and a ranked offender list.  Wraps `smell_scan`.
+- **forge call-graph** — AST call-graph for one symbol; shows callers and callees
+  up to `--max-depth` with optional `--direction` filter.  Wraps `call_graph`.
+- **forge cna-check** — Compose-Not-Add guard; fails with exit 1 when a proposed
+  symbol name is semantically equivalent to an existing one.  Wraps `cna_check`.
+- **forge trust-gate** — LLM response hallucination detector; reads a response from
+  a file or stdin, scores it against known capabilities, exits 1 when
+  `safe_to_act` is False.  Wraps `trust_gate_response`.
+- **forge commit-compose** — structured commit-message assembler; writes a
+  Forge-signed subject + body + optional Co-Authored-By trailer to stdout.
+  Wraps `commit_compose`.
+
 ## v0.16.0 — 2026-05-06 dress-rehearsal hardening (six bugfixes, 11 new tests)
 
 Live stress-test on real third-party Python repos (atomadic-forge,

{atomadic_forge-0.16.0 → atomadic_forge-0.16.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: atomadic-forge
-Version: 0.16.0
+Version: 0.16.2
 Summary: Atomadic Forge — absorb, enforce, emerge. Polyglot (Python · JavaScript/TypeScript · Swift · Kotlin · Go) architecture guardian for AI-generated code.
 Author: Atomadic
 License-Expression: BUSL-1.1
@@ -74,7 +74,7 @@ stays in the loop.
 
 ### What just shipped (v0.16.0)
 
-- **Dress-rehearsal hardening — six bugfixes, eleven new tests** (v0.16.0) — live stress-test on three real Python repos (atomadic-forge, langgraph, crewai) ahead of the Boris demo surfaced six bugs across the synthesis, planning, summary, and pipeline-pipe surfaces. `emergent synthesize` no longer emits broken `from pkg.mod.Class import method`; `forge plan` no longer suggests a literal `your_pkg` placeholder; `forge score-patch --file -` honours the stdin sentinel; `forge sbom` text summary reports the real component count; `recon-swarm/emergent-swarm/guard-install` register both hyphen and underscore forms so `commandsmith smoke` is 100% green; `synergy-then-emergent` and `emergent-then-synergy` pipes use the real `--save FILE` flag. Single-seed `forge create` jumped from certify=60/FAIL to **certify=90/100** with importable code on first generation. Test suite 1,291 → 1,302 passed.
+- ** hardening — six bugfixes, eleven new tests** (v0.16.0) — live stress-test on three real Python repos (atomadic-forge, langgraph, crewai) ahead of the Boris demo surfaced six bugs across the synthesis, planning, summary, and pipeline-pipe surfaces. `emergent synthesize` no longer emits broken `from pkg.mod.Class import method`; `forge plan` no longer suggests a literal `your_pkg` placeholder; `forge score-patch --file -` honours the stdin sentinel; `forge sbom` text summary reports the real component count; `recon-swarm/emergent-swarm/guard-install` register both hyphen and underscore forms so `commandsmith smoke` is 100% green; `synergy-then-emergent` and `emergent-then-synergy` pipes use the real `--save FILE` flag. Single-seed `forge create` jumped from certify=60/FAIL to **certify=90/100** with importable code on first generation. Test suite 1,291 → 1,302 passed.
 
 ### What previously shipped (v0.15.0)
 

{atomadic_forge-0.16.0 → atomadic_forge-0.16.2}/README.md

@@ -42,7 +42,7 @@ stays in the loop.
 
 ### What just shipped (v0.16.0)
 
-- **Dress-rehearsal hardening — six bugfixes, eleven new tests** (v0.16.0) — live stress-test on three real Python repos (atomadic-forge, langgraph, crewai) ahead of the Boris demo surfaced six bugs across the synthesis, planning, summary, and pipeline-pipe surfaces. `emergent synthesize` no longer emits broken `from pkg.mod.Class import method`; `forge plan` no longer suggests a literal `your_pkg` placeholder; `forge score-patch --file -` honours the stdin sentinel; `forge sbom` text summary reports the real component count; `recon-swarm/emergent-swarm/guard-install` register both hyphen and underscore forms so `commandsmith smoke` is 100% green; `synergy-then-emergent` and `emergent-then-synergy` pipes use the real `--save FILE` flag. Single-seed `forge create` jumped from certify=60/FAIL to **certify=90/100** with importable code on first generation. Test suite 1,291 → 1,302 passed.
+- ** hardening — six bugfixes, eleven new tests** (v0.16.0) — live stress-test on three real Python repos (atomadic-forge, langgraph, crewai) ahead of the Boris demo surfaced six bugs across the synthesis, planning, summary, and pipeline-pipe surfaces. `emergent synthesize` no longer emits broken `from pkg.mod.Class import method`; `forge plan` no longer suggests a literal `your_pkg` placeholder; `forge score-patch --file -` honours the stdin sentinel; `forge sbom` text summary reports the real component count; `recon-swarm/emergent-swarm/guard-install` register both hyphen and underscore forms so `commandsmith smoke` is 100% green; `synergy-then-emergent` and `emergent-then-synergy` pipes use the real `--save FILE` flag. Single-seed `forge create` jumped from certify=60/FAIL to **certify=90/100** with importable code on first generation. Test suite 1,291 → 1,302 passed.
 
 ### What previously shipped (v0.15.0)
 

{atomadic_forge-0.16.0 → atomadic_forge-0.16.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "atomadic-forge"
-version = "0.16.0"
+version = "0.16.2"
 description = "Atomadic Forge — absorb, enforce, emerge. Polyglot (Python · JavaScript/TypeScript · Swift · Kotlin · Go) architecture guardian for AI-generated code."
 readme = "README.md"
 requires-python = ">=3.10"

{atomadic_forge-0.16.0 → atomadic_forge-0.16.2}/src/atomadic_forge/a0_qk_constants/welcome_constants.py

@@ -30,9 +30,17 @@ HEALTH_LABEL_THRESHOLDS: Final[tuple[tuple[float, str], ...]] = (
 TOP_N_STRENGTHS: Final[int] = 3
 TOP_N_PRIORITIES: Final[int] = 3
 
+# Scope guard — refuse to walk monstrously large trees by accident.
+# A welcome run scoped at a workspace root rather than a single repo
+# (e.g. ``cd C:\!!AtomadicStandard && forge welcome``) was the actual
+# cause of the v0.16.1 "welcome hangs" report: 38 972 .py files.
+# Boris-demo lesson — prevent it at the substrate.
+SCOPE_GUARD_DEFAULT_MAX_FILES: Final[int] = 5000
+
 __all__ = [
     "HEALTH_LABEL_THRESHOLDS",
     "SCHEMA_VERSION_WELCOME_V1",
+    "SCOPE_GUARD_DEFAULT_MAX_FILES",
     "TOP_N_PRIORITIES",
     "TOP_N_STRENGTHS",
 ]

{atomadic_forge-0.16.0 → atomadic_forge-0.16.2}/src/atomadic_forge/a3_og_features/welcome_feature.py

@@ -18,9 +18,12 @@ import time
 from pathlib import Path
 from typing import Any
 
+import itertools
+
 from .. import __version__
 from ..a0_qk_constants.welcome_constants import (
     SCHEMA_VERSION_WELCOME_V1,
+    SCOPE_GUARD_DEFAULT_MAX_FILES,
 )
 from ..a1_at_functions.certify_checks import certify as _certify
 from ..a1_at_functions.lifetime_savings import (
@@ -31,6 +34,7 @@ from ..a1_at_functions.lifetime_savings import (
 )
 from ..a1_at_functions.mcp_protocol import TOOLS as _TOOLS
 from ..a1_at_functions.scout_walk import harvest_repo as _scout
+from ..a1_at_functions.scout_walk import iter_source_files as _iter_source_files
 from ..a1_at_functions.welcome_narrator import (
     build_agent_guidance,
     build_capability_showcase,
@@ -113,12 +117,24 @@ def _diff_against(
     }
 
 
+def _count_source_files_capped(project_root: Path, *, cap: int) -> int:
+    """Cheaply count source files, stopping after ``cap + 1`` matches.
+
+    Pure: just consumes the existing ``iter_source_files`` iterator.
+    Returns the count seen; if the count equals ``cap + 1`` the caller
+    knows the tree is *at least* that big without walking the rest.
+    """
+    return sum(1 for _ in itertools.islice(_iter_source_files(project_root), cap + 1))
+
+
 def welcome(
     *,
     project_root: Path,
     package: str | None = None,
     since_receipt: Path | str | None = None,
     skip_certify: bool = False,
+    force: bool = False,
+    max_files: int = SCOPE_GUARD_DEFAULT_MAX_FILES,
 ) -> dict[str, Any]:
     """Run the welcome handshake on ``project_root``.
 
@@ -128,12 +144,43 @@ def welcome(
     ``skip_certify`` (test convenience) — when True, skip the
     expensive certify pass and emit a partial welcome (scout + wire
     only). Production callers should leave this False.
+    ``force`` — bypass the scope guard. Use only when you know the
+    tree is genuinely the right scope to scan.
+    ``max_files`` — scope guard threshold. Default is
+    ``SCOPE_GUARD_DEFAULT_MAX_FILES`` (5 000); pass a higher number
+    on intentionally-large monorepos.
     """
     project_root = Path(project_root).resolve()
     repo_name = project_root.name
 
     t0 = time.monotonic()
 
+    # Scope guard — refuse to walk monstrously large trees by accident.
+    # Stops as soon as the cap is exceeded; a 38k-file workspace bails
+    # in milliseconds instead of grinding through the AST walk.
+    if not force:
+        seen = _count_source_files_capped(project_root, cap=max_files)
+        if seen > max_files:
+            return {
+                "schema_version": SCHEMA_VERSION_WELCOME_V1,
+                "forge_version": __version__,
+                "repo_name": repo_name,
+                "repo_path": str(project_root),
+                "duration_ms": int((time.monotonic() - t0) * 1000),
+                "verdict": "REFUSE",
+                "reason": "scope_guard",
+                "source_file_count_at_least": seen,
+                "scope_guard_max_files": max_files,
+                "narrative": (
+                    f"Scope guard tripped: {project_root} has at least "
+                    f"{seen} source files (cap {max_files}). This usually "
+                    "means welcome was run from a workspace root rather "
+                    "than a single repo. Pass --project-root <narrower-path> "
+                    "or --force to override."
+                ),
+                "available_tools": len(_TOOLS),
+            }
+
     # scout / wire / (optional) certify in sequence — they share I/O
     # against the same tree; concurrency wouldn't help much here
     # because the bottleneck is filesystem walk, not CPU.

{atomadic_forge-0.16.0 → atomadic_forge-0.16.2}/src/atomadic_forge/a4_sy_orchestration/cli.py

@@ -1071,6 +1071,278 @@ def status_cmd(
         raise typer.Exit(code=1)
 
 
+@app.command("verify")
+def verify_cmd(
+    project_root: Annotated[Path, typer.Argument(
+        exists=True, file_okay=False, dir_okay=True, resolve_path=True,
+        help="Project root to verify.")] = Path("."),
+    package: Annotated[str | None, typer.Option(
+        "--package", help="Python package sub-directory.")] = None,
+    fail_under: Annotated[float, typer.Option(
+        "--fail-under",
+        help="Certify score threshold; exit 1 when below.")] = 75.0,
+    json_out: Annotated[bool, typer.Option("--json")] = False,
+) -> None:
+    """Composite wire + certify gate — one verdict, one exit code.
+
+    Runs wire (upward-import scanner) and certify (score) in sequence
+    and synthesises a single PASS / REFINE / FAIL verdict.  Designed
+    for CI steps where you want a binary answer and a non-zero exit on
+    failure without having to chain two commands.
+    """
+    wire_report = scan_violations(project_root)
+    certify_report = certify_checks(project_root, project=project_root.name,
+                                    package=package)
+    violations = wire_report["violation_count"]
+    score = float(certify_report["score"])
+
+    if violations == 0 and score >= fail_under:
+        verdict = "PASS"
+    elif violations <= 2 and score >= fail_under * 0.85:
+        verdict = "REFINE"
+    else:
+        verdict = "FAIL"
+
+    result = {
+        "schema_version": "atomadic-forge.verify/v1",
+        "project": str(project_root),
+        "verdict": verdict,
+        "wire": {"violations": violations, "verdict": wire_report.get("verdict")},
+        "certify": {"score": score, "issues": certify_report.get("issues", [])},
+        "threshold": fail_under,
+    }
+    if json_out:
+        typer.echo(json.dumps(result, indent=2, default=str))
+        if verdict == "FAIL":
+            raise typer.Exit(code=1)
+        return
+    typer.echo(f"\nForge verify: {project_root}")
+    typer.echo("-" * 60)
+    typer.echo(f"  wire:    {'PASS' if violations == 0 else 'FAIL':5s}  {violations} violation(s)")
+    typer.echo(f"  certify: {score:.0f}/100  (threshold {fail_under:g})")
+    for issue in certify_report.get("issues", []):
+        typer.echo(f"    - {issue}")
+    typer.echo(f"\n  verdict: {verdict}")
+    if verdict == "FAIL":
+        raise typer.Exit(code=1)
+
+
+@app.command("smell")
+def smell_cmd(
+    project_root: Annotated[Path, typer.Argument(
+        exists=True, file_okay=False, dir_okay=True, resolve_path=True,
+        help="Project root to scan.")] = Path("."),
+    cc_threshold: Annotated[int, typer.Option(
+        "--cc", help="Cyclomatic complexity threshold (default 10).")] = 10,
+    loc_threshold: Annotated[int, typer.Option(
+        "--loc", help="Lines-per-function threshold (default 50).")] = 50,
+    package: Annotated[str | None, typer.Option(
+        "--package", help="Python package sub-directory.")] = None,
+    json_out: Annotated[bool, typer.Option("--json")] = False,
+) -> None:
+    """Code smell scan — cyclomatic complexity, long functions, duplicates.
+
+    Reports a smell_score (0–100, higher is worse) and a prioritised
+    list of the worst offenders so you know exactly where to refactor.
+    """
+    from ..a1_at_functions.smell_scan import smell_scan
+    report = smell_scan(project_root, cc_threshold=cc_threshold,
+                        loc_threshold=loc_threshold, package_subdir=package)
+    if json_out:
+        typer.echo(json.dumps(report.as_dict(), indent=2, default=str))
+        return
+    d = report.as_dict()
+    typer.echo(f"\nForge smell: {project_root}")
+    typer.echo("-" * 60)
+    typer.echo(f"  smell_score:  {d['smell_score']}/100")
+    typer.echo(f"  files scanned:{d.get('files_scanned', '?')}")
+    typer.echo(f"  smells found: {d.get('total_smells', len(d.get('smells', [])))}")
+    smells = d.get("smells", [])[:10]
+    if smells:
+        typer.echo("  top offenders:")
+        for s in smells:
+            typer.echo(f"    [{s.get('code', '?')}] {s.get('location', '?')}  — {s.get('message', '')}")
+    if d["smell_score"] == 0:
+        typer.echo("  ✓ No smells detected")
+
+
+@app.command("call-graph")
+def call_graph_cmd(
+    qualname: Annotated[str, typer.Argument(
+        help="Fully-qualified symbol name (e.g. my_pkg.utils.parse_line).")],
+    project_root: Annotated[Path, typer.Option(
+        "--project",
+        exists=True, file_okay=False, dir_okay=True, resolve_path=True,
+        help="Project root.")] = Path("."),
+    package: Annotated[str | None, typer.Option(
+        "--package", help="Python package name.")] = None,
+    direction: Annotated[str, typer.Option(
+        "--direction",
+        help="callers | callees | both")] = "both",
+    max_depth: Annotated[int, typer.Option(
+        "--max-depth", help="Maximum traversal depth.")] = 3,
+    json_out: Annotated[bool, typer.Option("--json")] = False,
+) -> None:
+    """AST call-graph for a symbol — who calls it, what it calls."""
+    from ..a1_at_functions.call_graph import build_call_graph
+    report = build_call_graph({
+        "qualname": qualname,
+        "project_root": str(project_root),
+        "package": package,
+        "direction": direction,
+        "max_depth": max_depth,
+    })
+    if json_out:
+        typer.echo(json.dumps(report, indent=2, default=str))
+        return
+    typer.echo(f"\nForge call-graph: {qualname}")
+    typer.echo("-" * 60)
+    typer.echo(f"  direction:  {direction}")
+    typer.echo(f"  max_depth:  {max_depth}")
+    callers = report.get("callers", [])
+    callees = report.get("callees", [])
+    if callers:
+        typer.echo(f"  callers ({len(callers)}):")
+        for c in callers[:20]:
+            typer.echo(f"    ← {c}")
+    if callees:
+        typer.echo(f"  callees ({len(callees)}):")
+        for c in callees[:20]:
+            typer.echo(f"    → {c}")
+    if not callers and not callees:
+        typer.echo("  (no edges found — check that qualname and package are correct)")
+
+
+@app.command("cna-check")
+def cna_check_cmd(
+    proposed_name: Annotated[str, typer.Argument(
+        help="Symbol name you are about to create.")],
+    project_root: Annotated[Path, typer.Option(
+        "--project",
+        exists=True, file_okay=False, dir_okay=True, resolve_path=True,
+        help="Project root.")] = Path("."),
+    body: Annotated[str | None, typer.Option(
+        "--body", help="Optional short description of the symbol.")] = None,
+    package: Annotated[str | None, typer.Option(
+        "--package", help="Python package sub-directory.")] = None,
+    json_out: Annotated[bool, typer.Option("--json")] = False,
+) -> None:
+    """Compose-Not-Add check — verify a symbol doesn't already exist.
+
+    Before writing new code Forge checks whether an equivalent symbol
+    already exists in the project.  Exits 1 on REJECT (duplicate found)
+    so this can gate PR pipelines.
+    """
+    from ..a3_og_features.cna_check import cna_check
+    report = cna_check(project_root=project_root, proposed_name=proposed_name,
+                       proposed_body=body, package_subdir=package)
+    if json_out:
+        typer.echo(json.dumps(report.as_dict() if hasattr(report, "as_dict") else report,
+                              indent=2, default=str))
+        if hasattr(report, "verdict") and report.verdict == "REJECT":
+            raise typer.Exit(code=1)
+        return
+    d = report.as_dict() if hasattr(report, "as_dict") else report
+    verdict = d.get("verdict", "?")
+    typer.echo(f"\nForge cna-check: {proposed_name}")
+    typer.echo("-" * 60)
+    typer.echo(f"  verdict:  {verdict}")
+    for match in d.get("top_matches", [])[:5]:
+        score = match.get("score", 0)
+        name = match.get("qualname") or match.get("name", "?")
+        typer.echo(f"    {score:.2f}  {name}")
+    if verdict == "REJECT":
+        raise typer.Exit(code=1)
+
+
+@app.command("trust-gate")
+def trust_gate_cmd(
+    response_file: Annotated[Path | None, typer.Argument(
+        help="File containing the LLM response to gate (omit to read stdin).",
+        exists=False)] = None,
+    known_capabilities: Annotated[str | None, typer.Option(
+        "--capabilities",
+        help="Comma-separated list of capabilities the agent is expected "
+             "to have.  Claims outside this set lower the trust score.")] = None,
+    pkg_prefix: Annotated[str, typer.Option(
+        "--pkg-prefix",
+        help="Local package prefix for import-claim validation.")] = "",
+    json_out: Annotated[bool, typer.Option("--json")] = False,
+) -> None:
+    """Hallucination detector for LLM responses — τ_TRUST gated output.
+
+    Reads an LLM response (from a file or stdin), scores it against
+    known tool capabilities, and returns a trust verdict with a
+    safe_to_act boolean.  Exits 1 when safe_to_act is False.
+    """
+    from ..a1_at_functions.trust_gate_response import gate_response
+    if response_file is not None:
+        try:
+            text = response_file.read_text(encoding="utf-8")
+        except OSError as exc:
+            raise typer.BadParameter(f"could not read {response_file}: {exc}") from exc
+    else:
+        text = sys.stdin.read()
+    caps = [c.strip() for c in known_capabilities.split(",")] if known_capabilities else None
+    verdict = gate_response(text, known_capabilities=caps, local_pkg_prefix=pkg_prefix)
+    d = verdict.schema if hasattr(verdict, "schema") else {}
+    safe = getattr(verdict, "safe_to_act", d.get("safe_to_act", True))
+    score = getattr(verdict, "score", d.get("score", 1.0))
+    if json_out:
+        typer.echo(json.dumps(d, indent=2, default=str))
+        if not safe:
+            raise typer.Exit(code=1)
+        return
+    typer.echo("\nForge trust-gate")
+    typer.echo("-" * 60)
+    typer.echo(f"  score:       {score:.3f}")
+    typer.echo(f"  safe_to_act: {safe}")
+    for flag in d.get("flags", []):
+        typer.echo(f"  ⚠ {flag}")
+    if not safe:
+        raise typer.Exit(code=1)
+
+
+@app.command("commit-compose")
+def commit_compose_cmd(
+    intent: Annotated[str, typer.Argument(
+        help="One-line description of what changed and why.")],
+    project_root: Annotated[Path, typer.Option(
+        "--project",
+        exists=True, file_okay=False, dir_okay=True, resolve_path=True,
+        help="Project root.")] = Path("."),
+    commit_type: Annotated[str, typer.Option(
+        "--type",
+        help="ship | fix | refactor | docs | test | chore")] = "ship",
+    body: Annotated[str, typer.Option(
+        "--body", help="Optional extended commit body.")] = "",
+    no_coauthor: Annotated[bool, typer.Option(
+        "--no-coauthor",
+        help="Omit the Co-Authored-By trailer.")] = False,
+    json_out: Annotated[bool, typer.Option("--json")] = False,
+) -> None:
+    """Generate a structured, Forge-signed commit message.
+
+    Composes a commit message from intent + type, optionally attaches a
+    Co-Authored-By trailer, and validates the result against the project's
+    wisdom DB.  Prints the message ready to paste into ``git commit -m``.
+    """
+    from ..a3_og_features.commit_compose import compose_commit_message
+    artifact = compose_commit_message(
+        project_root=project_root,
+        intent=intent,
+        commit_type=commit_type,
+        body=body,
+        include_coauthor=not no_coauthor,
+    )
+    d = artifact.as_dict() if hasattr(artifact, "as_dict") else artifact
+    if json_out:
+        typer.echo(json.dumps(d, indent=2, default=str))
+        return
+    message = d.get("message") or d.get("commit_message") or str(d)
+    typer.echo(message)
+
+
 @app.command("sbom")
 def sbom_cmd(
     project: Annotated[Path, typer.Argument(

{atomadic_forge-0.16.0 → atomadic_forge-0.16.2}/src/atomadic_forge/commands/welcome.py

@@ -43,6 +43,10 @@ def welcome_cmd(
         resolve_path=True)] = None,  # type: ignore[assignment]
     skip_certify: Annotated[bool, typer.Option("--skip-certify",
         help="Skip the certify pass for a faster (partial) handshake.")] = False,
+    force: Annotated[bool, typer.Option("--force",
+        help="Bypass the scope guard (allow walking trees >max-files).")] = False,
+    max_files: Annotated[int, typer.Option("--max-files",
+        help="Scope guard threshold (default 5000).")] = 5000,
     json_out: Annotated[bool, typer.Option("--json",
         help="Emit machine-readable JSON.")] = False,
 ) -> None:
@@ -52,7 +56,17 @@ def welcome_cmd(
         package=package or None,
         since_receipt=since,
         skip_certify=skip_certify,
+        force=force,
+        max_files=max_files,
     )
+    if out.get("verdict") == "REFUSE":
+        bar = "=" * 64
+        typer.echo(bar, err=True)
+        typer.echo(out["narrative"], err=True)
+        typer.echo(bar, err=True)
+        if json_out:
+            typer.echo(json.dumps(out, indent=2, default=str))
+        raise typer.Exit(code=2)
     if json_out:
         typer.echo(json.dumps(out, indent=2, default=str))
         return

{atomadic_forge-0.16.0 → atomadic_forge-0.16.2}/src/atomadic_forge.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: atomadic-forge
-Version: 0.16.0
+Version: 0.16.2
 Summary: Atomadic Forge — absorb, enforce, emerge. Polyglot (Python · JavaScript/TypeScript · Swift · Kotlin · Go) architecture guardian for AI-generated code.
 Author: Atomadic
 License-Expression: BUSL-1.1
@@ -74,7 +74,7 @@ stays in the loop.
 
 ### What just shipped (v0.16.0)
 
-- **Dress-rehearsal hardening — six bugfixes, eleven new tests** (v0.16.0) — live stress-test on three real Python repos (atomadic-forge, langgraph, crewai) ahead of the Boris demo surfaced six bugs across the synthesis, planning, summary, and pipeline-pipe surfaces. `emergent synthesize` no longer emits broken `from pkg.mod.Class import method`; `forge plan` no longer suggests a literal `your_pkg` placeholder; `forge score-patch --file -` honours the stdin sentinel; `forge sbom` text summary reports the real component count; `recon-swarm/emergent-swarm/guard-install` register both hyphen and underscore forms so `commandsmith smoke` is 100% green; `synergy-then-emergent` and `emergent-then-synergy` pipes use the real `--save FILE` flag. Single-seed `forge create` jumped from certify=60/FAIL to **certify=90/100** with importable code on first generation. Test suite 1,291 → 1,302 passed.
+- ** hardening — six bugfixes, eleven new tests** (v0.16.0) — live stress-test on three real Python repos (atomadic-forge, langgraph, crewai) ahead of the Boris demo surfaced six bugs across the synthesis, planning, summary, and pipeline-pipe surfaces. `emergent synthesize` no longer emits broken `from pkg.mod.Class import method`; `forge plan` no longer suggests a literal `your_pkg` placeholder; `forge score-patch --file -` honours the stdin sentinel; `forge sbom` text summary reports the real component count; `recon-swarm/emergent-swarm/guard-install` register both hyphen and underscore forms so `commandsmith smoke` is 100% green; `synergy-then-emergent` and `emergent-then-synergy` pipes use the real `--save FILE` flag. Single-seed `forge create` jumped from certify=60/FAIL to **certify=90/100** with importable code on first generation. Test suite 1,291 → 1,302 passed.
 
 ### What previously shipped (v0.15.0)
 

{atomadic_forge-0.16.0 → atomadic_forge-0.16.2}/tests/test_welcome.py

@@ -253,6 +253,30 @@ def test_welcome_since_receipt_diff(tmp_path: Path) -> None:
     assert out["since_last_scan"]["prior_score"] == 80
 
 
+def test_welcome_scope_guard_refuses_oversized_tree(tmp_path: Path) -> None:
+    """Synthesise 12 .py files, cap at 5, expect REFUSE without scout."""
+    for i in range(12):
+        (tmp_path / f"mod_{i}.py").write_text("x = 1\n", encoding="utf-8")
+    out = welcome(project_root=tmp_path, max_files=5)
+    assert out["verdict"] == "REFUSE"
+    assert out["reason"] == "scope_guard"
+    assert out["scope_guard_max_files"] == 5
+    assert out["source_file_count_at_least"] >= 6  # cap+1 trip point
+    # Scout/wire/certify keys must not be populated when guard tripped.
+    assert "scan" not in out
+    assert "Scope guard tripped" in out["narrative"]
+
+
+def test_welcome_scope_guard_force_bypasses(tmp_path: Path) -> None:
+    """--force allows the walk even past max-files."""
+    for i in range(8):
+        (tmp_path / f"mod_{i}.py").write_text("x = 1\n", encoding="utf-8")
+    out = welcome(project_root=tmp_path, max_files=3, force=True,
+                   skip_certify=True)
+    assert out.get("verdict") != "REFUSE"
+    assert out["scan"]["scout"]["symbol_count"] >= 0  # didn't bail
+
+
 def test_welcome_since_receipt_missing_returns_none(tmp_path: Path) -> None:
     out = welcome(project_root=tmp_path, skip_certify=True,
                    since_receipt=tmp_path / "doesnotexist.json")