agentpack-cli 0.3.25__tar.gz → 0.3.26__tar.gz

{agentpack_cli-0.3.25 → agentpack_cli-0.3.26}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentpack-cli
-Version: 0.3.25
+Version: 0.3.26
 Summary: Local context engine for AI coding agents that ranks relevant repo files and builds compact task-focused context packs for Claude Code, Codex, Cursor, Windsurf, MCP, and CI workflows.
 Project-URL: Homepage, https://github.com/vishal2612200/agentpack
 Project-URL: Documentation, https://vishal2612200.github.io/agentpack/

{agentpack_cli-0.3.25 → agentpack_cli-0.3.26}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agentpack-cli"
-version = "0.3.25"
+version = "0.3.26"
 description = "Local context engine for AI coding agents that ranks relevant repo files and builds compact task-focused context packs for Claude Code, Codex, Cursor, Windsurf, MCP, and CI workflows."
 readme = "README.md"
 requires-python = ">=3.10"

{agentpack_cli-0.3.25 → agentpack_cli-0.3.26}/src/agentpack/__init__.py

@@ -1,3 +1,3 @@
 """AgentPack — task-aware context packing for AI coding agents."""
 
-__version__ = "0.3.25"
+__version__ = "0.3.26"

{agentpack_cli-0.3.25 → agentpack_cli-0.3.26}/src/agentpack/application/pack_service.py

@@ -9,6 +9,7 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any
 
+from agentpack import __version__
 from agentpack.core.config import load_config
 from agentpack.core.changed_paths import clear_changed_paths, read_changed_paths
 from agentpack.core.ignore import DEFAULT_AGENTIGNORE, load_spec
@@ -16,6 +17,7 @@ from agentpack.core.scanner import scan, scan_incremental
 from agentpack.core.snapshot import build_snapshot, save_snapshot, load_snapshot
 from agentpack.core.diff import diff_snapshots
 from agentpack.core import git
+from agentpack.core.command_surface import refresh_commands
 from agentpack.core.context_pack import enrich_call_site_scores, select_files, save_pack_metadata, load_pack_metadata
 from agentpack.core.execution_state import build_execution_state, compact_execution_state
 from agentpack.core.models import (
@@ -1575,7 +1577,12 @@ def _build_freshness_metadata(
 ) -> dict[str, Any]:
     dirty = git.dirty_files(root) if git.is_git_repo(root) else set()
     metadata: dict[str, Any] = {
+        "agentpack_version": __version__,
         "generated_at": datetime.now(timezone.utc).isoformat(),
+        "cwd": str(Path.cwd()),
+        "git_root": str(root),
+        "worktree_path": str(root),
+        "source_command": refresh_commands(request.agent).primary,
         "task_source": request.task_source,
         "changed_files_source": plan.changed_files_source,
         "snapshot_root_hash": snapshot_root_hash,

{agentpack_cli-0.3.25 → agentpack_cli-0.3.26}/src/agentpack/commands/benchmark.py

@@ -166,6 +166,7 @@ class E2EResult:
     expected_files_touched: list[str]
     missing_expected_edits: list[str]
     unexpected_files_touched: list[str]
+    agentpack_noise: list[str]
     agent_log_path: str
     test_log_path: str
     workdir: str
@@ -3226,6 +3227,7 @@ def _e2e_strategy_metrics(records: list[dict[str, Any]], strategy: str) -> dict[
     return {
         "runs": float(len(subset)),
         "success_rate": sum(1 for row in subset if row.get("passed")) / len(subset),
+        "noise_rate": sum(1 for row in subset if row.get("agentpack_noise")) / len(subset),
         "expected_touch_rate": expected_touch_rate,
         "avg_input_tokens": avg("input_tokens"),
         "avg_output_tokens": avg("agent_output_tokens"),
@@ -3285,6 +3287,7 @@ def _print_e2e_ab_table(
     table.add_row("runs", f"{base['runs']:.0f}", f"{treat['runs']:.0f}", "-")
     table.add_row("task success", f"{base['success_rate']:.0%}", f"{treat['success_rate']:.0%}", f"{deltas['success_rate_pp']:+.1f} pp")
     table.add_row("expected file touched", f"{base['expected_touch_rate']:.0%}", f"{treat['expected_touch_rate']:.0%}", "-")
+    table.add_row("AgentPack noise cases", f"{base['noise_rate']:.0%}", f"{treat['noise_rate']:.0%}", "-")
     table.add_row("tool calls", f"{base['avg_tool_calls']:.1f}", f"{treat['avg_tool_calls']:.1f}", f"{deltas['tool_calls_saved']:+.1f}")
     table.add_row("tokens", f"{base['avg_total_tokens']:,.0f}", f"{treat['avg_total_tokens']:,.0f}", f"{deltas['tokens_saved']:+,.0f}")
     table.add_row("cost", f"${base['avg_total_cost_usd']:.4f}", f"${treat['avg_total_cost_usd']:.4f}", _fmt_signed_usd(deltas["token_cost_saved_usd"]))
@@ -3317,6 +3320,7 @@ def _e2e_ab_markdown(
         f"| runs | {base['runs']:.0f} | {treat['runs']:.0f} | - |",
         f"| task success | {base['success_rate']:.0%} | {treat['success_rate']:.0%} | {deltas['success_rate_pp']:+.1f} pp |",
         f"| expected file touched | {base['expected_touch_rate']:.0%} | {treat['expected_touch_rate']:.0%} | - |",
+        f"| AgentPack noise cases | {base['noise_rate']:.0%} | {treat['noise_rate']:.0%} | - |",
         f"| tool calls | {base['avg_tool_calls']:.1f} | {treat['avg_tool_calls']:.1f} | {deltas['tool_calls_saved']:+.1f} |",
         f"| tokens | {base['avg_total_tokens']:,.0f} | {treat['avg_total_tokens']:,.0f} | {deltas['tokens_saved']:+,.0f} |",
         f"| token cost | ${base['avg_total_cost_usd']:.4f} | ${treat['avg_total_cost_usd']:.4f} | {_fmt_signed_usd(deltas['token_cost_saved_usd'])} |",
@@ -3410,6 +3414,7 @@ def _run_e2e_case(
     expected_touched = _expected_files_touched(public_changed, case.expected_edit_paths)
     missing_expected = sorted(set(case.expected_edit_paths) - set(expected_touched))
     unexpected_touched = _unexpected_files_touched(public_changed, case.expected_edit_paths)
+    agentpack_noise = _agentpack_noise(strategy, unexpected_touched, missing_expected, public_changed)
     time_to_first_expected_file = _time_to_first_expected_file(repo, expected_touched, agent_start_epoch)
     tool_calls = _estimate_agent_tool_calls(agent)
     duration = time.perf_counter() - start
@@ -3442,6 +3447,7 @@ def _run_e2e_case(
         expected_files_touched=expected_touched,
         missing_expected_edits=missing_expected,
         unexpected_files_touched=unexpected_touched,
+        agentpack_noise=agentpack_noise,
         agent_log_path=str(agent_log_path),
         test_log_path=str(test_log_path),
         workdir=str(work_root),
@@ -3495,6 +3501,20 @@ def _unexpected_files_touched(changed: list[str], expected_edit_paths: list[str]
     return sorted(path for path in changed if path not in expected)
 
 
+def _agentpack_noise(strategy: str, unexpected: list[str], missing_expected: list[str], changed: list[str]) -> list[str]:
+    if "agentpack" not in strategy:
+        return []
+    noise: list[str] = []
+    if unexpected:
+        noise.append(f"unexpected edits: {', '.join(unexpected[:5])}")
+    if missing_expected:
+        noise.append(f"missed expected files: {', '.join(missing_expected[:5])}")
+    generated = [path for path in changed if _is_generated_e2e_path(path)]
+    if generated:
+        noise.append(f"generated AgentPack files changed: {', '.join(generated[:5])}")
+    return noise
+
+
 def _process_output_tokens(result: subprocess.CompletedProcess[str]) -> int:
     return estimate_tokens("\n".join(part for part in (result.stdout, result.stderr) if part))
 

{agentpack_cli-0.3.25 → agentpack_cli-0.3.26}/src/agentpack/commands/doctor.py

@@ -17,6 +17,7 @@ from agentpack.integrations.global_install import (
     _detect_rc_file,
 )
 from agentpack.commands._shared import console, _root
+from agentpack.core.command_surface import available_cli_commands, installed_cli_status, refresh_commands
 from agentpack.core.context_pack import load_pack_metadata
 from agentpack.core.ignore import agentignore_sync_status, format_import_summary
 from agentpack.core.task_freshness import task_freshness
@@ -45,7 +46,12 @@ def register(app: typer.Typer) -> None:
 
         # --- CLI binary ---
         console.print("[bold]CLI[/]")
-        binary = shutil.which("agentpack")
+        cli_status = installed_cli_status()
+        binary = cli_status.get("binary") or shutil.which("agentpack")
+        console.print(f"  [green]✓[/] importable AgentPack version: {cli_status.get('agentpack_version')}")
+        importable = cli_status.get("importable_commands") or []
+        if importable:
+            console.print(f"  [green]✓[/] importable commands: {', '.join(str(cmd) for cmd in importable)}")
         if binary:
             try:
                 result = subprocess.run(["agentpack", "--version"], capture_output=True, text=True)
@@ -56,6 +62,15 @@ def register(app: typer.Typer) -> None:
         else:
             console.print("  [red]✗[/] agentpack not on PATH — run: pipx install agentpack-cli")
             ok = False
+        help_commands = cli_status.get("help_commands") or []
+        if help_commands:
+            console.print(f"  [green]✓[/] installed CLI commands: {', '.join(str(cmd) for cmd in help_commands)}")
+        if binary and "guard" not in set(str(cmd) for cmd in help_commands) and "guard" in set(available_cli_commands()):
+            console.print(
+                "  [yellow]![/] installed CLI command surface may be stale; "
+                f"exact repair: {cli_status.get('repair_command')}"
+            )
+            ok = False
 
         try:
             root = _root()
@@ -147,8 +162,19 @@ def register(app: typer.Typer) -> None:
                         "MCP get_context auto-refreshes this, or run: agentpack pack --task auto"
                     )
                     ok = False
+                meta = load_pack_metadata(root) or {}
+                freshness = meta.get("freshness") or {}
+                if freshness:
+                    console.print(
+                        "  [green]✓[/] context provenance: "
+                        f"task_source={freshness.get('task_source', 'unknown')}, "
+                        f"git_root={freshness.get('git_root', root)}, "
+                        f"worktree={freshness.get('worktree_path', root)}, "
+                        f"branch={freshness.get('git_branch', 'unknown')}, "
+                        f"generated={freshness.get('generated_at', 'unknown')}"
+                    )
             else:
-                console.print("  [yellow]![/] No context pack yet — write .agentpack/task.md, then run: agentpack pack --task auto")
+                console.print(f"  [yellow]![/] No context pack yet — write .agentpack/task.md, then run: {refresh_commands(agent).context_missing}")
 
         # --- Agent-specific config ---
         console.print("\n[bold]Agent config[/]")
@@ -249,6 +275,14 @@ def register(app: typer.Typer) -> None:
                 pass
         if not _local_has_mcp and not _global_has_mcp:
             console.print("  [yellow]![/] MCP server not registered — mcp__agentpack__* tools unavailable")
+            console.print("  [yellow]![/] exact repair: agentpack install --agent claude")
+            ok = False
+        else:
+            console.print(
+                "  [green]✓[/] expected MCP tools: "
+                "readiness, route_task, pack_context, get_context, refresh, get_stats"
+            )
+            console.print("  [green]✓[/] live exposure proof: call MCP tool `readiness` from the agent host")
 
         # --- Agent integration matrix ---
         console.print("\n[bold]Agent integration audit[/]")
@@ -268,8 +302,7 @@ def register(app: typer.Typer) -> None:
                 ok = False
             if not selected_ok:
                 console.print(
-                    f"    [yellow]![/] executable guard repair: "
-                    f"agentpack guard --agent {selected} --repair-stale --refresh-context"
+                    f"    [yellow]![/] exact repair: {refresh_commands(selected).repair}"
                 )
 
         # --- Concurrent threads ---

{agentpack_cli-0.3.25 → agentpack_cli-0.3.26}/src/agentpack/commands/next_cmd.py

@@ -7,6 +7,7 @@ import typer
 from agentpack.commands._shared import console, _root, run_refresh
 from agentpack.commands.diagnose_selection import build_selection_diagnosis, _markdown_report
 from agentpack.commands.guard import _context_is_fresh
+from agentpack.core.command_surface import refresh_commands
 from agentpack.core.config import load_config
 from agentpack.core.context_pack import load_pack_metadata
 from agentpack.core.loop_protocol import load_loop_state
@@ -34,7 +35,7 @@ def register(app: typer.Typer) -> None:
             stats = run_refresh(root, "auto", "balanced", 0)
             if stats:
                 recommendations = [{"kind": "fixed", "command": "agentpack next", "reason": "refreshed stale context"}]
-                fixes.append({"kind": "stale_context", "command": "agentpack guard --agent auto --repair-stale --refresh-context", "returncode": 0})
+                fixes.append({"kind": "stale_context", "command": refresh_commands("auto").repair, "returncode": 0})
         payload = {"recommendations": recommendations, "fixes": fixes, "ok": not recommendations}
         if json_output:
             typer.echo(json.dumps(payload, indent=2, sort_keys=True))
@@ -58,7 +59,7 @@ def _recommendations(root) -> list[dict[str, str]]:
         items.append({"kind": "missing_task", "command": 'agentpack start "describe the task"', "reason": "no concrete task is set"})
     fresh, reason = _context_is_fresh(root)
     if not fresh:
-        items.append({"kind": "stale_context", "command": "agentpack guard --agent auto --repair-stale --refresh-context", "reason": reason})
+        items.append({"kind": "stale_context", "command": refresh_commands("auto").repair, "reason": reason})
     if _has_thread_conflicts(root):
         items.append({"kind": "thread_conflict", "command": "agentpack threads --conflicts", "reason": "active threads overlap on this branch/worktree"})
     if _pack_looks_noisy(root):
@@ -138,7 +139,7 @@ def _fix_all_safe(root, recommendations: list[dict[str, str]]) -> tuple[list[dic
         stats = run_refresh(root, "auto", "balanced", 0)
         fixes.append({
             "kind": "stale_context",
-            "command": "agentpack guard --agent auto --repair-stale --refresh-context",
+            "command": refresh_commands("auto").repair,
             "returncode": 0 if stats else 1,
         })
         recommendations = _recommendations(root)

{agentpack_cli-0.3.25 → agentpack_cli-0.3.26}/src/agentpack/commands/pack.py

@@ -17,6 +17,7 @@ from agentpack.analysis.ranking import suggest_task_rewrite
 from agentpack.application.pack_service import PackRequest, PackService, PackResult
 from agentpack.commands._shared import console, _root, _file_hash, _now_iso
 from agentpack.core.changed_paths import record_changed_paths
+from agentpack.core.command_surface import refresh_commands
 from agentpack.core.modes import MODE_HELP, invalid_mode_message, is_requested_mode
 from agentpack.integrations.agents import check_agent_integration, install_agent_integration
 from agentpack.session.state import TASK_FILE, load_session, save_session, log_activity
@@ -314,7 +315,7 @@ def _agent_integration_warnings(result: PackResult) -> list[str]:
     if not failing:
         return []
     return [
-        f"Agent integration needs repair ({agent}); run `agentpack guard --agent {agent} --repair-stale --refresh-context`."
+        f"Agent integration needs repair ({agent}); run `{refresh_commands(agent).repair}`."
     ]
 
 
@@ -337,7 +338,7 @@ def _auto_repair_stale_agent_rules(agent: str) -> None:
     except Exception as exc:
         console.print(
             f"[yellow]Stale AgentPack integration detected for {agent}; "
-            f"run `agentpack guard --agent {agent} --repair-stale --refresh-context`. ({exc})[/]"
+            f"run `{refresh_commands(agent).repair}`. ({exc})[/]"
         )
 
 

{agentpack_cli-0.3.25 → agentpack_cli-0.3.26}/src/agentpack/commands/start_cmd.py

@@ -6,6 +6,7 @@ from pathlib import Path
 import typer
 
 from agentpack.commands._shared import console, _root
+from agentpack.core.command_surface import refresh_command_args
 from agentpack.core.context_pack import load_pack_metadata
 from agentpack.core.thread_context import resolve_thread_option, thread_paths
 from agentpack.integrations.platform import cli_module_argv
@@ -42,9 +43,7 @@ def register(app: typer.Typer) -> None:
             if workspace:
                 argv.extend(["--workspace", workspace])
         else:
-            argv = cli_module_argv("guard", "--agent", agent, "--repair-stale", "--refresh-context", "--mode", mode)
-            if budget:
-                argv.extend(["--budget", str(budget)])
+            argv = cli_module_argv(*refresh_command_args(agent, mode, budget))
         if thread_id:
             argv.extend(["--thread", thread_id])
         result = subprocess.run(argv, cwd=root)

{agentpack_cli-0.3.25 → agentpack_cli-0.3.26}/src/agentpack/commands/status.py

@@ -4,6 +4,7 @@ import typer
 import shutil
 
 from agentpack.core.config import load_config
+from agentpack.core.command_surface import refresh_commands
 from agentpack.core.ignore import load_spec
 from agentpack.core.scanner import scan
 from agentpack.core.snapshot import build_snapshot
@@ -98,4 +99,4 @@ def _print_deep_health(root, meta: dict | None) -> None:
         if not check.ok:
             failing.append(check)
     if failing:
-        console.print(f"  [yellow]![/] Guard repair: agentpack guard --agent {agent} --repair-stale --refresh-context")
+        console.print(f"  [yellow]![/] Repair: {refresh_commands(agent).repair}")

{agentpack_cli-0.3.25 → agentpack_cli-0.3.26}/src/agentpack/commands/task_cmd.py

@@ -7,6 +7,7 @@ from pathlib import Path
 import typer
 
 from agentpack.commands._shared import console, _root
+from agentpack.core.command_surface import refresh_command_args
 from agentpack.core.thread_context import resolve_thread_option, thread_paths
 from agentpack.integrations.platform import cli_module_argv
 from agentpack.session.state import TASK_FILE
@@ -47,7 +48,7 @@ def set_task(
     task_text: str = typer.Argument(..., help="Task text to write."),
     thread: str = typer.Option("", "--thread", help="Use thread-scoped task state."),
     pack: bool = typer.Option(False, "--pack", help="Run agentpack pack after writing the task."),
-    guard: bool = typer.Option(False, "--guard", help="Run agentpack guard --repair-stale --refresh-context after writing."),
+    guard: bool = typer.Option(False, "--guard", help="Run the installed refresh/repair command after writing."),
     agent: str = typer.Option("auto", "--agent", help="Agent to pass to pack/guard."),
     mode: str = typer.Option("balanced", "--mode", help="Pack/guard mode."),
 ) -> None:
@@ -63,7 +64,7 @@ def set_task(
 
     thread_id = _thread_id(root, thread)
     if guard:
-        _run_cli(["guard", "--agent", agent, "--repair-stale", "--refresh-context", "--mode", mode], thread_id=thread_id)
+        _run_cli(refresh_command_args(agent, mode), thread_id=thread_id)
     elif pack:
         _run_cli(["pack", "--agent", agent, "--task", "auto", "--mode", mode], thread_id=thread_id)
 

{agentpack_cli-0.3.25 → agentpack_cli-0.3.26}/src/agentpack/commands/workflow_cmd.py

@@ -10,6 +10,7 @@ import typer
 
 from agentpack.commands._shared import console, _root, run_refresh
 from agentpack.commands.guard import _context_is_fresh
+from agentpack.core.command_surface import refresh_commands
 from agentpack.core.config import load_config
 from agentpack.core.loop_protocol import (
     LoopCommandResult,
@@ -317,7 +318,7 @@ def _loop_finish_blockers(
             {
                 "kind": "stale_context",
                 "message": f"Context is stale: {reason}",
-                "command": "agentpack guard --agent auto --repair-stale --refresh-context",
+                "command": refresh_commands("auto").repair,
             }
         )
     return blockers
@@ -434,6 +435,7 @@ def _read_task(root: Path, thread: str) -> str:
 
 def _refresh_loop_context(root: Path, agent: str, mode: str, budget: int, thread_id: str | None) -> LoopCommandResult:
     stats = run_refresh(root, agent, mode, budget, thread_id=thread_id)
+    command = refresh_commands(agent).primary
     if stats is None:
-        return LoopCommandResult(command="agentpack guard --repair-stale --refresh-context", returncode=1, output_excerpt="context refresh failed")
-    return LoopCommandResult(command="agentpack guard --repair-stale --refresh-context", returncode=0, output_excerpt=json.dumps(stats, sort_keys=True))
+        return LoopCommandResult(command=command, returncode=1, output_excerpt="context refresh failed")
+    return LoopCommandResult(command=command, returncode=0, output_excerpt=json.dumps(stats, sort_keys=True))

agentpack_cli-0.3.26/src/agentpack/core/command_surface.py

@@ -0,0 +1,127 @@
+from __future__ import annotations
+
+import shutil
+import subprocess
+from dataclasses import dataclass
+from typing import Iterable
+
+from agentpack import __version__
+
+
+@dataclass(frozen=True)
+class RefreshCommands:
+    primary: str
+    context_missing: str
+    thread_auto: str | None
+    repair: str
+    used_guard: bool
+
+
+def available_cli_commands() -> tuple[str, ...]:
+    """Return command names registered by the importable AgentPack CLI."""
+    try:
+        import typer.main
+
+        from agentpack.cli import app
+
+        click_cmd = typer.main.get_command(app)
+        return tuple(sorted(click_cmd.commands))
+    except Exception:
+        return ()
+
+
+def has_cli_command(command: str) -> bool:
+    return command in available_cli_commands()
+
+
+def refresh_commands(agent: str = "auto") -> RefreshCommands:
+    if has_cli_command("guard"):
+        base = f"agentpack guard --agent {agent} --repair-stale --refresh-context"
+        return RefreshCommands(
+            primary=base,
+            context_missing=base,
+            thread_auto=f"AGENTPACK_THREAD_ID=<stable-id> {base} --thread auto",
+            repair=base,
+            used_guard=True,
+        )
+    pack = f"agentpack pack --agent {agent} --task auto"
+    return RefreshCommands(
+        primary=pack,
+        context_missing='printf "%s\\n" "<task>" > .agentpack/task.md && ' + pack,
+        thread_auto=None,
+        repair="agentpack repair --agent " + agent if has_cli_command("repair") else pack,
+        used_guard=False,
+    )
+
+
+def refresh_command_args(agent: str = "auto", mode: str = "balanced", budget: int = 0) -> list[str]:
+    """Return CLI argv parts for refreshing context with the current command surface."""
+    if has_cli_command("guard"):
+        args = ["guard", "--agent", agent, "--repair-stale", "--refresh-context", "--mode", mode]
+    else:
+        args = ["pack", "--agent", agent, "--task", "auto", "--mode", mode]
+    if budget:
+        args.extend(["--budget", str(budget)])
+    return args
+
+
+def fallback_agent_guidance() -> str:
+    return (
+        "If AgentPack tools are unavailable or context looks stale/wrong-worktree, "
+        "do not trust old pack output. Use direct `rg`, PR diff inspection, and target-file reads, "
+        "then run focused validation."
+    )
+
+
+def installed_cli_status() -> dict[str, object]:
+    binary = shutil.which("agentpack")
+    status: dict[str, object] = {
+        "agentpack_version": __version__,
+        "binary": binary,
+        "importable_commands": list(available_cli_commands()),
+    }
+    if not binary:
+        status["available"] = False
+        status["repair_command"] = "pipx install agentpack-cli"
+        return status
+    try:
+        version = subprocess.run(
+            [binary, "--version"],
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        help_result = subprocess.run(
+            [binary, "--help"],
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+    except (OSError, subprocess.TimeoutExpired) as exc:
+        status["available"] = False
+        status["error"] = str(exc)
+        status["repair_command"] = "pipx upgrade agentpack-cli"
+        return status
+    status["available"] = version.returncode == 0
+    status["installed_version"] = (version.stdout.strip() or version.stderr.strip())
+    status["help_commands"] = _commands_from_help(help_result.stdout + "\n" + help_result.stderr)
+    status["repair_command"] = "pipx upgrade agentpack-cli"
+    return status
+
+
+def _commands_from_help(text: str) -> list[str]:
+    commands: set[str] = set()
+    known = set(available_cli_commands())
+    for line in text.splitlines():
+        stripped = line.strip()
+        if not stripped:
+            continue
+        first = stripped.split()[0].strip("`")
+        if first in known:
+            commands.add(first)
+    return sorted(commands)
+
+
+def missing_commands(commands: Iterable[str]) -> list[str]:
+    available = set(available_cli_commands())
+    return sorted({cmd for cmd in commands if cmd and cmd not in available})

{agentpack_cli-0.3.25 → agentpack_cli-0.3.26}/src/agentpack/core/context_pack.py

@@ -91,7 +91,18 @@ def save_pack_metadata(
         "concurrent_context": concurrent_context or {},
     }
     if freshness:
-        for key in ("git_sha", "git_branch", "task_source", "changed_files_source", "task_class"):
+        for key in (
+            "agentpack_version",
+            "source_command",
+            "cwd",
+            "git_root",
+            "worktree_path",
+            "git_sha",
+            "git_branch",
+            "task_source",
+            "changed_files_source",
+            "task_class",
+        ):
             if key in freshness:
                 meta[key] = freshness[key]
     path = metadata_path or _metadata_path(root)

agentpack_cli-0.3.26/src/agentpack/core/e2e_benchmark.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Literal
+
+
+Variant = Literal["baseline", "agentpack"]
+
+
+@dataclass(frozen=True)
+class E2ERunMetrics:
+    case_id: str
+    variant: Variant
+    task_success: bool | None = None
+    validation_passed: bool | None = None
+    token_usage: int | None = None
+    estimated_cost_usd: float | None = None
+    turns: int | None = None
+    tool_calls: int | None = None
+    time_to_first_correct_file_seconds: float | None = None
+    wall_time_seconds: float | None = None
+    final_edited_files: list[str] = field(default_factory=list)
+    expected_files: list[str] = field(default_factory=list)
+    agentpack_noise: list[str] = field(default_factory=list)
+
+    def to_record(self) -> dict[str, Any]:
+        return {
+            "case_id": self.case_id,
+            "variant": self.variant,
+            "task_success": self.task_success,
+            "validation_passed": self.validation_passed,
+            "token_usage": self.token_usage,
+            "estimated_cost_usd": self.estimated_cost_usd,
+            "turns": self.turns,
+            "tool_calls": self.tool_calls,
+            "time_to_first_correct_file_seconds": self.time_to_first_correct_file_seconds,
+            "wall_time_seconds": self.wall_time_seconds,
+            "final_edited_files": self.final_edited_files,
+            "expected_files": self.expected_files,
+            "edited_expected_overlap": sorted(set(self.final_edited_files) & set(self.expected_files)),
+            "unexpected_edited_files": sorted(set(self.final_edited_files) - set(self.expected_files)),
+            "missing_expected_files": sorted(set(self.expected_files) - set(self.final_edited_files)),
+            "agentpack_noise": self.agentpack_noise,
+        }
+
+
+def append_e2e_result(path: Path, metrics: E2ERunMetrics) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("a", encoding="utf-8") as handle:
+        handle.write(json.dumps(metrics.to_record(), sort_keys=True) + "\n")
+
+
+def e2e_scaffold_markdown() -> str:
+    return """# AgentPack E2E Benchmark Scaffold
+
+Compare the same real task in two variants:
+
+- baseline: agent runs without AgentPack context/routing.
+- agentpack: agent starts with AgentPack route/context guidance.
+
+Required metrics:
+
+- task success
+- tests or validation pass
+- token usage and estimated cost
+- turns and tool calls
+- time-to-first-correct-file
+- wall time
+- final edited files vs expected files
+- AgentPack noise or slowdown cases
+
+Keep file-selection benchmarks as scoped ranking evidence. Do not claim cost, turn, or task-success gains until this E2E data exists.
+"""

{agentpack_cli-0.3.25 → agentpack_cli-0.3.26}/src/agentpack/data/agentpack.md

@@ -33,7 +33,7 @@ Pack repo context and immediately start working on the task.
 If a session is already running (`.agentpack/session.json` exists and `"active": true`):
 
 1. If the user gives a new coding task, write a one-line summary to `.agentpack/task.md`.
-2. Run `agentpack guard --agent claude --repair-stale --refresh-context` unless watch mode already refreshed after the task write.
+2. Run `agentpack pack --agent claude --task auto` unless watch mode already refreshed after the task write.
 3. Read `.agentpack/context.md` — context now matches the current task.
 4. Proceed with the task using the context you just read.
 
@@ -72,21 +72,21 @@ Then use normal prompts — context stays current while `watch` is running.
 
 ```bash
 printf '%s\n' "<task>" > .agentpack/task.md
-agentpack guard --agent claude --repair-stale --refresh-context --mode balanced
+agentpack pack --agent claude --task auto --mode balanced
 ```
 
 Then read `.agentpack/context.claude.md` in full.
 
 ## Thread Mode (explicit opt-in)
 
-Plain `agentpack pack`, `agentpack status`, and `agentpack guard` use the legacy global files:
+Plain `agentpack pack` and `agentpack status` use the legacy global files:
 `.agentpack/task.md`, `.agentpack/context.md`, and `.agentpack/pack_metadata.json`.
 
 When multiple agents work in the same repo, opt into scoped state:
 
 ```bash
 export AGENTPACK_THREAD_ID=codex-local
-agentpack guard --agent claude --repair-stale --refresh-context --thread auto
+agentpack pack --agent claude --task auto --thread auto
 ```
 
 Thread mode writes `.agentpack/threads/<id>/task.md`, `context.md`, `context.claude.md`,
@@ -122,12 +122,12 @@ test -f .agentpack/config.toml || "$AGENTPACK_BIN" init --yes
 
 **Session active** (`.agentpack/session.json` exists, `"active": true`):
 - Update `.agentpack/task.md` if task changed
-- Run `"$AGENTPACK_BIN" guard --agent claude --repair-stale --refresh-context` unless watch already refreshed it
+- Run `"$AGENTPACK_BIN" pack --agent claude --task auto` unless watch already refreshed it
 - Read `.agentpack/context.md`
 - Proceed immediately
 
 **No session**:
-- Run `"$AGENTPACK_BIN" session start` or `"$AGENTPACK_BIN" guard --agent claude --repair-stale --refresh-context`
+- Run `"$AGENTPACK_BIN" session start` or `"$AGENTPACK_BIN" pack --agent claude --task auto`
 - Read the context file
 - Proceed
 
@@ -145,7 +145,7 @@ Do not say "context pack ready" and stop. Do not tell the user to run more comma
 
 If `"$AGENTPACK_BIN" status` exits non-zero or context seems unrelated to the task:
 - Run `"$AGENTPACK_BIN" session refresh` (if session active)
-- Or run `"$AGENTPACK_BIN" guard --agent claude --repair-stale --refresh-context` (manual mode)
+- Or run `"$AGENTPACK_BIN" pack --agent claude --task auto` (manual mode)
 - Re-read the context, then proceed
 
 Do not ask the user — just refresh and proceed.

{agentpack_cli-0.3.25 → agentpack_cli-0.3.26}/src/agentpack/data/codex_plugin/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "agentpack",
-  "version": "0.3.25",
+  "version": "0.3.26",
   "description": "Thin Codex plugin for AgentPack ranked repo context.",
   "author": {
     "name": "AgentPack",