atomadic-forge 0.3.3__tar.gz → 0.3.5__tar.gz

{atomadic_forge-0.3.3 → atomadic_forge-0.3.5}/CHANGELOG.md

@@ -1,5 +1,120 @@
 # Changelog
 
+## 0.3.5 — Copilot's Copilot CLI parity + GUI version sync
+
+The MCP exposes 21 tools. Until 0.3.5, only 12 of them had CLI
+front-doors — the other 9 were JSON-RPC-only, which meant a developer
+or agent shell-running `forge` couldn't sample the same intelligence
+without spawning the MCP server, speaking JSON-RPC, and parsing
+`content[0].text`. This release closes the gap.
+
+### Added — 9 new top-level CLI verbs
+
+Every MCP-only Codex tool now has a CLI sibling that prints JSON to
+stdout, suitable for piping into `jq`, scripts, or an agent's Bash
+subprocess:
+
+| Verb | Codex # | What it does |
+|---|---|---|
+| `forge explain-repo <root>` | #6 | Humane operational orientation: one-liner + core flow + do_not_break list + important tests + release state |
+| `forge score-patch [--file diff.patch]` | #3 | Patch risk scorer: arch / test / public-API / release risk + needs_human_review boolean |
+| `forge select-tests <intent> --file ... --file ...` | #7 | Minimum + full-confidence test sets per intent; mirror-name matches plus tier-mate tests |
+| `forge rollback-plan --file ... --file ...` | #11 | Structured undo plan: files to remove, caches to clean, docs to restore, tests to rerun, risk level |
+| `forge compose-tools <goal>` | #9 | Tool-use planner: keyword → ordered MCP tool sequence (orient / release_check / fix_violation / before_edit / verify_patch) |
+| `forge why-did-this-change <file>` | #5 | Agent memory: every lineage entry + plan event that touched the file |
+| `forge what-failed-last-time <area>` | #5 | Failed / rolled-back plan events matching an area substring |
+| `forge adapt-plan --cap apply --cap shell` | #8 | Capability-aware card filtering: tag each card with recommended_handling |
+| `forge load-policy <root>` | #10 | Read `[tool.forge.agent]` from pyproject.toml (protected_files / release_gate / max_files_per_patch / require_human_review_for) |
+
+All verbs default to JSON output. None mutate the repo.
+
+### Why this matters for agents
+
+Before 0.3.5, an agent that wanted to compose a release-check tool
+chain had to either spawn `forge mcp serve`, hand-craft a tools/call
+JSON-RPC envelope, send it over stdio, and parse the wrapped text
+content — or skip the intelligence entirely. After 0.3.5, the same
+agent runs:
+
+```bash
+forge compose-tools "release_check" | jq .steps
+forge select-tests "fix(api): rate limit" --file src/api/limit.py
+forge score-patch --file my.diff
+```
+
+Three Bash calls. Same data. Zero JSON-RPC.
+
+### GUI version sync
+
+`forge-web` PWA + `forge-studio` Tauri both pull their version label
+from `forge-ui-core`'s `ForgeShell.tsx` default. That default was
+still pinned to `0.3.2`. Now `0.3.5` so both shells correctly identify
+themselves at the bottom of the sidebar.
+
+### Tests
+
+902 passing, 2 skipped (no test changes — every new verb is a thin
+wrapper around an already-tested a1 function).
+`forge wire src/atomadic_forge` PASS, `forge certify .` holds at
+**100/100**.
+
+---
+
+## 0.3.4 — `forge whoami` for agents and humans
+
+Adds the agent-empowerment QOL win that 0.3.3 was missing: when the
+MCP gate refuses with `subscription required`, agents (and humans)
+need a cheap way to ask **"who is the gate seeing me as, and from
+which source?"** without burning a real tool call. `forge whoami` is
+that command.
+
+### Added
+
+- **`forge whoami`** new top-level CLI verb (and `--json` for scripted
+  consumers). Returns:
+  ```json
+  {
+    "ok": true,
+    "source": "credentials_file" | "env" | "missing",
+    "key_prefix": "fk_live_b3502…",
+    "email": "tom@example.com",
+    "plan": "pro",
+    "verify_ok": true,
+    "verify_reason": "",
+    "credentials_path": "~/.atomadic-forge/credentials.toml",
+    "env_var": "FORGE_API_KEY"
+  }
+  ```
+  Resolution order matches the MCP gate exactly (env → credentials.toml).
+  `--no-verify` skips the network roundtrip for offline triage.
+- **6 new unit tests** for whoami covering missing-key, env-key,
+  credentials-file-key, env-wins-over-file, --no-verify, and
+  verify-rejection.
+
+### Why this matters for agents
+
+Before 0.3.4, an agent that hit `MCP error -32001: Forge subscription
+required` had two options: ask the human to restart the MCP, or fail.
+With 0.3.4 the agent can call `forge whoami --json` (via Bash) and
+get a structured answer it can act on:
+
+  * `source == "missing"` → tell the user to run `forge login`
+  * `source == "credentials_file"` + `verify_ok == false` → key is
+    revoked or stale; `forge login` again
+  * `source == "env"` + `verify_ok == false` → CI env var is wrong
+  * everything green → restart the MCP host (the running subprocess
+    needs a respawn to see the new env)
+
+This closes the loop for the auth experience — the agent can diagnose
+its own failure mode.
+
+### Tests
+
+902 passing, 2 skipped. `forge wire src/atomadic_forge` PASS,
+`forge certify .` holds at **100/100**.
+
+---
+
 ## 0.3.3 — MCP gate reads credentials.toml + actionable error message
 
 Hot-fix release. Closes the gap where `forge login` writes a key to

{atomadic_forge-0.3.3 → atomadic_forge-0.3.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: atomadic-forge
-Version: 0.3.3
+Version: 0.3.5
 Summary: Atomadic Forge — absorb, enforce, emerge. Polyglot (Python + JavaScript/TypeScript) architecture guardian for AI-generated code.
 Author: Atomadic
 License-Expression: BUSL-1.1

{atomadic_forge-0.3.3 → atomadic_forge-0.3.5}/pyproject.toml

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

{atomadic_forge-0.3.3 → atomadic_forge-0.3.5}/src/atomadic_forge/__init__.py

@@ -9,4 +9,4 @@ Public version surface only — every symbol lives in its tier package and
 is re-exported lazily by the CLI.
 """
 
-__version__ = "0.3.3"
+__version__ = "0.3.5"

{atomadic_forge-0.3.3 → atomadic_forge-0.3.5}/src/atomadic_forge/a4_sy_orchestration/cli.py

@@ -64,7 +64,9 @@ from ..a3_og_features.forge_pipeline import (
 )
 from ..a3_og_features.forge_plan_apply import apply_all_applyable, apply_card
 from ..a3_og_features.mcp_server import serve_stdio as mcp_serve_stdio
+from .copilots_cmd import COPILOTS_VERBS as _COPILOTS_VERBS
 from .login_cmd import app as _login_app
+from .whoami_cmd import app as _whoami_app
 
 # Suppress SyntaxWarnings from third-party code in seed/forged directories.
 warnings.filterwarnings("ignore", category=SyntaxWarning)
@@ -1153,6 +1155,18 @@ app.add_typer(mcp_app, name="mcp",
 app.add_typer(_login_app, name="login",
                help="Capture a Forge subscription key (required by `forge mcp serve`).")
 
+# Lane C W6 — `forge whoami` resolves the current auth state without
+# burning a real tool call. Pairs with `forge login` so agents can
+# verify what the gate is reading and where it came from.
+app.add_typer(_whoami_app, name="whoami",
+               help="Show the current Forge auth state — email, plan, source.")
+
+# Lane C W7 — Codex 'Copilot's Copilot' surface as CLI verbs.
+# Until 0.3.5 these were MCP-only (tools/call); now they're shell-runnable
+# so any agent that can spawn Bash can sample the same intelligence.
+for _verb_name, _verb_app, _verb_help in _COPILOTS_VERBS:
+    app.add_typer(_verb_app, name=_verb_name, help=_verb_help)
+
 
 def _check_optional_dep(module: str) -> str:
     try:

atomadic_forge-0.3.5/src/atomadic_forge/a4_sy_orchestration/copilots_cmd.py

@@ -0,0 +1,234 @@
+"""Tier a4 — `forge` CLI parity for the Codex 'Copilot's Copilot' surface.
+
+These verbs were already exposed via MCP (tools/call) but had no CLI
+front-door. That gap meant a developer or agent shell-running `forge`
+couldn't sample the same intelligence the MCP exposes — they had to
+spawn the MCP server, speak JSON-RPC, and parse `content[0].text`.
+
+This module surfaces every MCP-only tool as a top-level CLI verb that
+prints JSON to stdout, suitable for piping into jq, scripts, or an
+agent's Bash subprocess. Each verb is a thin a4 orchestrator around
+the a1 implementation — no business logic lives here.
+
+Verbs added:
+  * forge explain-repo <project_root>      — Codex #6 humane orientation
+  * forge score-patch                      — Codex #3 patch risk scorer (diff on stdin or --file)
+  * forge select-tests <project_root>      — Codex #7 minimum + full-confidence test sets
+  * forge rollback-plan <project_root>     — Codex #11 structured undo plan
+  * forge compose-tools <goal>             — Codex #9 tool-use planner (goal keyword)
+  * forge why-did-this-change <file>       — Codex #5 lineage history for a file
+  * forge what-failed-last-time <area>     — Codex #5 failures matching an area substring
+  * forge adapt-plan                       — Codex #8 capability-aware card filtering (plan on stdin/--file)
+  * forge load-policy <project_root>       — Codex #10 [tool.forge.agent] reader
+
+All verbs default to printing JSON. None mutate the repo.
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from dataclasses import asdict, is_dataclass
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+from ..a1_at_functions.agent_memory import (
+    what_failed_last_time as _what_failed_last_time,
+)
+from ..a1_at_functions.agent_memory import why_did_this_change as _why_did_this_change
+from ..a1_at_functions.patch_scorer import score_patch as _score_patch
+from ..a1_at_functions.plan_adapter import adapt_plan as _adapt_plan
+from ..a1_at_functions.policy_loader import load_policy as _load_policy
+from ..a1_at_functions.repo_explainer import explain_repo as _explain_repo
+from ..a1_at_functions.rollback_planner import rollback_plan as _rollback_plan
+from ..a1_at_functions.test_selector import select_tests as _select_tests
+from ..a1_at_functions.tool_composer import compose_tools as _compose_tools
+
+
+def _to_jsonable(obj: object) -> object:
+    """Convert dataclasses, Paths, sets to JSON-serializable form."""
+    if is_dataclass(obj):
+        return asdict(obj)  # type: ignore[arg-type]
+    if isinstance(obj, Path):
+        return str(obj)
+    if isinstance(obj, set):
+        return sorted(obj)
+    if isinstance(obj, (list, tuple)):
+        return [_to_jsonable(v) for v in obj]
+    if isinstance(obj, dict):
+        return {k: _to_jsonable(v) for k, v in obj.items()}
+    return obj
+
+
+def _emit(result: object) -> None:
+    """Print JSON to stdout. Used by every verb in this module."""
+    typer.echo(json.dumps(_to_jsonable(result), indent=2, default=str))
+
+
+def _read_stdin_or_file(file: Path | None) -> str:
+    if file is not None:
+        return Path(file).read_text(encoding="utf-8")
+    if sys.stdin.isatty():
+        raise typer.BadParameter(
+            "no input on stdin and --file not given. Pipe a diff via stdin or pass --file path.txt"
+        )
+    return sys.stdin.read()
+
+
+# ---- Top-level Typer apps (one per verb) -------------------------------
+
+explain_app = typer.Typer(no_args_is_help=False, help="Codex #6 — humane operational orientation.")
+score_app = typer.Typer(no_args_is_help=False, help="Codex #3 — patch risk scorer.")
+tests_app = typer.Typer(no_args_is_help=False, help="Codex #7 — minimum + full-confidence test sets.")
+rollback_app = typer.Typer(no_args_is_help=False, help="Codex #11 — structured undo plan.")
+compose_app = typer.Typer(no_args_is_help=False, help="Codex #9 — tool-use planner.")
+why_app = typer.Typer(no_args_is_help=False, help="Codex #5 — agent memory: lineage for a file.")
+failed_app = typer.Typer(no_args_is_help=False, help="Codex #5 — failed events matching an area.")
+adapt_app = typer.Typer(no_args_is_help=False, help="Codex #8 — capability-aware card filtering.")
+policy_app = typer.Typer(no_args_is_help=False, help="Codex #10 — read [tool.forge.agent] policy.")
+
+
+@explain_app.callback(invoke_without_command=True)
+def explain_repo_cmd(
+    project_root: Annotated[
+        Path,
+        typer.Argument(exists=True, file_okay=False, dir_okay=True, resolve_path=True),
+    ] = Path("."),
+    depth: Annotated[str, typer.Option("--depth")] = "agent",
+) -> None:
+    _emit(_explain_repo(project_root=project_root, depth=depth))
+
+
+@score_app.callback(invoke_without_command=True)
+def score_patch_cmd(
+    file: Annotated[
+        Path | None,
+        typer.Option(
+            "--file", "-f",
+            help="Read the unified diff from this file. Without --file, reads from stdin.",
+        ),
+    ] = None,
+    project_root: Annotated[
+        Path,
+        typer.Option("--project-root", "-p", exists=True, file_okay=False, resolve_path=True),
+    ] = Path("."),
+) -> None:
+    diff = _read_stdin_or_file(file)
+    _emit(_score_patch(diff, project_root=project_root))
+
+
+@tests_app.callback(invoke_without_command=True)
+def select_tests_cmd(
+    intent: Annotated[str, typer.Argument(help="One-line description of the intent.")] ,
+    files: Annotated[
+        list[str],
+        typer.Option(
+            "--file", "-f",
+            help="Repeat for each changed file. Example: --file src/a/b.py --file src/a/c.py",
+        ),
+    ] = [],
+    project_root: Annotated[
+        Path,
+        typer.Option("--project-root", "-p", exists=True, file_okay=False, resolve_path=True),
+    ] = Path("."),
+) -> None:
+    _emit(_select_tests(
+        intent=intent,
+        changed_files=list(files),
+        project_root=project_root,
+    ))
+
+
+@rollback_app.callback(invoke_without_command=True)
+def rollback_plan_cmd(
+    files: Annotated[
+        list[str],
+        typer.Option(
+            "--file", "-f",
+            help="Repeat for each changed file you want a rollback plan for.",
+        ),
+    ] = [],
+    project_root: Annotated[
+        Path,
+        typer.Option("--project-root", "-p", exists=True, file_okay=False, resolve_path=True),
+    ] = Path("."),
+) -> None:
+    _emit(_rollback_plan(changed_files=list(files), project_root=project_root))
+
+
+@compose_app.callback(invoke_without_command=True)
+def compose_tools_cmd(
+    goal: Annotated[str, typer.Argument(help="One-line goal keyword (orient / release_check / ...).")] ,
+) -> None:
+    _emit(_compose_tools(goal=goal))
+
+
+@why_app.callback(invoke_without_command=True)
+def why_cmd(
+    file: Annotated[str, typer.Argument(help="File path to look up (relative or absolute).")] ,
+    project_root: Annotated[
+        Path,
+        typer.Option("--project-root", "-p", exists=True, file_okay=False, resolve_path=True),
+    ] = Path("."),
+) -> None:
+    _emit(_why_did_this_change(file=file, project_root=project_root))
+
+
+@failed_app.callback(invoke_without_command=True)
+def failed_cmd(
+    area: Annotated[str, typer.Argument(help="Substring match against the area string.")] ,
+    project_root: Annotated[
+        Path,
+        typer.Option("--project-root", "-p", exists=True, file_okay=False, resolve_path=True),
+    ] = Path("."),
+) -> None:
+    _emit(_what_failed_last_time(area=area, project_root=project_root))
+
+
+@adapt_app.callback(invoke_without_command=True)
+def adapt_plan_cmd(
+    capabilities: Annotated[
+        list[str],
+        typer.Option(
+            "--cap", "-c",
+            help="Repeat for each capability the agent advertises (e.g. -c apply -c shell).",
+        ),
+    ] = [],
+    file: Annotated[
+        Path | None,
+        typer.Option(
+            "--file", "-f",
+            help="Read the agent_plan/v1 JSON from this file. Without --file, reads from stdin.",
+        ),
+    ] = None,
+) -> None:
+    plan_text = _read_stdin_or_file(file)
+    plan = json.loads(plan_text)
+    _emit(_adapt_plan(plan, agent_capabilities=list(capabilities)))
+
+
+@policy_app.callback(invoke_without_command=True)
+def policy_cmd(
+    project_root: Annotated[
+        Path,
+        typer.Argument(exists=True, file_okay=False, dir_okay=True, resolve_path=True),
+    ] = Path("."),
+) -> None:
+    policy = _load_policy(project_root)
+    _emit(policy)
+
+
+# Public registry — cli.py imports this and registers each.
+COPILOTS_VERBS: list[tuple[str, "typer.Typer", str]] = [
+    ("explain-repo",        explain_app,  "Codex #6 — humane operational orientation of any repo."),
+    ("score-patch",         score_app,    "Codex #3 — patch risk scorer (diff via stdin or --file)."),
+    ("select-tests",        tests_app,    "Codex #7 — minimum + full-confidence test sets per intent."),
+    ("rollback-plan",       rollback_app, "Codex #11 — structured undo plan for a set of changed files."),
+    ("compose-tools",       compose_app,  "Codex #9 — tool-use planner: keyword → ordered MCP tool sequence."),
+    ("why-did-this-change", why_app,      "Codex #5 — lineage + plan events that touched a file."),
+    ("what-failed-last-time", failed_app, "Codex #5 — failed/rolled-back plan events matching an area."),
+    ("adapt-plan",          adapt_app,    "Codex #8 — capability-aware card filtering (plan via stdin or --file)."),
+    ("load-policy",         policy_app,   "Codex #10 — read [tool.forge.agent] policy from pyproject.toml."),
+]

atomadic_forge-0.3.5/src/atomadic_forge/a4_sy_orchestration/whoami_cmd.py

@@ -0,0 +1,159 @@
+"""Tier a4 — `forge whoami` orchestration command.
+
+Resolves the current Forge authentication state and prints (or returns
+as JSON) the email, plan, source (env vs credentials.toml), and verify
+result. Pairs with `forge login`: after a successful login, `whoami`
+confirms the credential file is being read and the verify endpoint
+agrees with what's there.
+
+Why a dedicated verb (and MCP tool):
+  * Agents need to ASK "am I authenticated and what's my plan?" without
+    burning a real tool call. Today an agent that hits "subscription
+    required" has no cheap follow-up — `whoami` is that follow-up.
+  * Humans running into MCP gate failures need a one-liner that says
+    exactly which key the gate read and where it came from.
+  * `--json` makes it scriptable in CI / shell wrappers.
+"""
+
+from __future__ import annotations
+
+import json as _json
+import os
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+from ..a0_qk_constants.auth_constants import API_KEY_ENV
+from ..a1_at_functions.forge_auth import (
+    read_api_key_from_credentials_file,
+    read_api_key_from_env,
+)
+from ..a2_mo_composites.forge_auth_client import ForgeAuthClient
+
+CREDENTIALS_FILE = Path("~/.atomadic-forge/credentials.toml").expanduser()
+
+
+def _resolve_key(env: dict[str, str], creds_path: Path) -> tuple[str | None, str]:
+    """Return (api_key, source) using the same resolution order the MCP gate uses.
+
+    source ∈ {"env", "credentials_file", "missing"}.
+    """
+    env_key = read_api_key_from_env(env)
+    if env_key:
+        return env_key, "env"
+    file_key = read_api_key_from_credentials_file(creds_path)
+    if file_key:
+        return file_key, "credentials_file"
+    return None, "missing"
+
+
+app = typer.Typer(
+    no_args_is_help=False,
+    help="Show the current Forge authentication state — email, plan, source.",
+)
+
+
+@app.callback(invoke_without_command=True)
+def whoami_cmd(
+    json_out: Annotated[
+        bool,
+        typer.Option(
+            "--json",
+            help="Emit the result as JSON for scripted consumers.",
+        ),
+    ] = False,
+    no_verify: Annotated[
+        bool,
+        typer.Option(
+            "--no-verify",
+            help="Skip the network verify roundtrip; just report the key shape "
+                 "and source (useful when the verify endpoint is offline).",
+        ),
+    ] = False,
+) -> None:
+    """Resolve and print the current Forge auth state."""
+    env_dict = dict(os.environ)
+    api_key, source = _resolve_key(env_dict, CREDENTIALS_FILE)
+
+    if api_key is None:
+        result: dict = {
+            "ok": False,
+            "source": "missing",
+            "email": "",
+            "plan": "",
+            "reason": (
+                "No Forge subscription key configured. Run "
+                "`forge login` to capture one, or export "
+                f"{API_KEY_ENV}=fk_live_… in the environment."
+            ),
+            "credentials_path": str(CREDENTIALS_FILE),
+        }
+        if json_out:
+            typer.echo(_json.dumps(result, indent=2))
+        else:
+            typer.echo("")
+            typer.secho("  ✗ Not logged in.", fg="red")
+            typer.echo("")
+            typer.echo("    Run `forge login` to capture a key, or export")
+            typer.echo(f"    {API_KEY_ENV}=fk_live_…")
+            typer.echo(f"    Credentials path: {CREDENTIALS_FILE}")
+        raise typer.Exit(code=1)
+
+    # We have a key. Mask it for display (show first 11 chars of fk_live_xxx).
+    masked = api_key[:11] + ("…" if len(api_key) > 11 else "")
+
+    email = ""
+    plan = ""
+    verify_ok = False
+    verify_reason = "(verification skipped via --no-verify)"
+
+    if not no_verify:
+        client = ForgeAuthClient()
+        try:
+            verify = client.verify(api_key)
+            verify_ok = bool(verify.get("ok"))
+            email = str(verify.get("email", "") or "")
+            plan = str(verify.get("plan", "") or "")
+            verify_reason = str(verify.get("reason", "") or "")
+        except Exception as exc:  # noqa: BLE001 — show offline status to the user
+            verify_reason = f"verify endpoint unreachable: {exc!r}"
+
+    result = {
+        "ok": verify_ok or no_verify,
+        "source": source,
+        "key_prefix": masked,
+        "email": email,
+        "plan": plan,
+        "verify_ok": verify_ok,
+        "verify_reason": verify_reason,
+        "credentials_path": str(CREDENTIALS_FILE),
+        "env_var": API_KEY_ENV,
+    }
+
+    if json_out:
+        typer.echo(_json.dumps(result, indent=2))
+        if not result["ok"]:
+            raise typer.Exit(code=1)
+        return
+
+    typer.echo("")
+    if result["ok"]:
+        typer.secho(
+            f"  ✓ Logged in as {email or '(unknown email)'}"
+            f"{f' · plan: {plan}' if plan else ''}",
+            fg="green",
+        )
+    else:
+        typer.secho(f"  ✗ Auth failed: {verify_reason}", fg="red")
+
+    typer.echo(f"    key:    {masked}")
+    typer.echo(f"    source: {source}")
+    if source == "credentials_file":
+        typer.echo(f"    file:   {CREDENTIALS_FILE}")
+    elif source == "env":
+        typer.echo(f"    env:    {API_KEY_ENV}")
+    typer.echo("")
+
+    if not result["ok"]:
+        raise typer.Exit(code=1)

{atomadic_forge-0.3.3 → atomadic_forge-0.3.5}/src/atomadic_forge.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: atomadic-forge
-Version: 0.3.3
+Version: 0.3.5
 Summary: Atomadic Forge — absorb, enforce, emerge. Polyglot (Python + JavaScript/TypeScript) architecture guardian for AI-generated code.
 Author: Atomadic
 License-Expression: BUSL-1.1

{atomadic_forge-0.3.3 → atomadic_forge-0.3.5}/src/atomadic_forge.egg-info/SOURCES.txt

@@ -185,7 +185,9 @@ src/atomadic_forge/a3_og_features/demo_packages/mixed_py_js/tests/conftest.py
 src/atomadic_forge/a3_og_features/demo_packages/mixed_py_js/tests/test_mixed.py
 src/atomadic_forge/a4_sy_orchestration/__init__.py
 src/atomadic_forge/a4_sy_orchestration/cli.py
+src/atomadic_forge/a4_sy_orchestration/copilots_cmd.py
 src/atomadic_forge/a4_sy_orchestration/login_cmd.py
+src/atomadic_forge/a4_sy_orchestration/whoami_cmd.py
 src/atomadic_forge/commands/__init__.py
 src/atomadic_forge/commands/_registry.py
 src/atomadic_forge/commands/audit.py
@@ -263,5 +265,6 @@ tests/test_synergy.py
 tests/test_test_runner.py
 tests/test_tier_init_rebuild.py
 tests/test_vscode_extension_manifest.py
+tests/test_whoami_cmd.py
 tests/test_wire_certify.py
 tests/test_wire_suggest_repairs.py