agentpack-cli 0.1.7__tar.gz → 0.1.8__tar.gz

{agentpack_cli-0.1.7 → agentpack_cli-0.1.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentpack-cli
-Version: 0.1.7
+Version: 0.1.8
 Summary: Token-aware context packing for AI coding agents — Claude, Cursor, Windsurf, and Codex
 License: MIT
 License-File: LICENSE
@@ -24,6 +24,7 @@ Requires-Dist: tomli>=2.0.0; python_version < '3.11'
 Requires-Dist: typer>=0.12.0
 Provides-Extra: all
 Requires-Dist: anthropic>=0.39.0; extra == 'all'
+Requires-Dist: mcp>=1.0.0; extra == 'all'
 Requires-Dist: openai>=1.0.0; extra == 'all'
 Requires-Dist: watchdog>=4.0.0; extra == 'all'
 Provides-Extra: dev
@@ -34,6 +35,8 @@ Requires-Dist: tomli>=2.0.0; (python_version < '3.11') and extra == 'dev'
 Provides-Extra: llm
 Requires-Dist: anthropic>=0.39.0; extra == 'llm'
 Requires-Dist: openai>=1.0.0; extra == 'llm'
+Provides-Extra: mcp
+Requires-Dist: mcp>=1.0.0; extra == 'mcp'
 Provides-Extra: watch
 Requires-Dist: watchdog>=4.0.0; extra == 'watch'
 Description-Content-Type: text/markdown
@@ -81,12 +84,13 @@ The result: your agent starts every session with a focused, accurate picture of
 ```bash
 pip install agentpack-cli
 
-# Session mode: start once, then work normally
+# One-time setup per project
 cd your-project
-agentpack init
-agentpack install          # auto-detects your IDE
-agentpack session start
-agentpack watch   # in another terminal — keeps context fresh automatically
+agentpack init             # creates config, session, task.md — nothing else needed
+agentpack install          # auto-detects your IDE (optional but recommended)
+
+# Every terminal session
+agentpack watch            # keeps context fresh automatically — that's it
 ```
 
 Then open Claude Code / Cursor / Windsurf / Codex / Antigravity and write your task normally. AgentPack keeps `.agentpack/context.md` current.
@@ -221,17 +225,20 @@ Requires Python 3.10+.
 
 ## Start Once, Then Work Normally
 
-The recommended workflow for repeated development sessions:
+The full workflow:
 
 ```bash
-agentpack install          # configure your agent (once per project)
-agentpack session start    # create session state + generate initial context
-agentpack watch            # in another terminal — refreshes context on file/task changes
+# One-time project setup
+agentpack init             # creates config, session, task.md
+agentpack install          # configure your agent (optional but recommended)
+
+# Every terminal session — just one command
+agentpack watch            # auto-resumes session, refreshes context on file/task changes
 ```
 
 Then open Claude Code / Cursor / Codex and write your coding task normally.
 
-- AgentPack keeps `.agentpack/context.md` fresh while `watch` is running.
+- AgentPack keeps `.agentpack/context.md` and `.agentpack/context.claude.md` fresh while `watch` is running.
 - To change the task: `agentpack session refresh --task "new task"` — or just tell Claude and it updates `task.md` itself.
 - Check session state: `agentpack session status`
 - Force a refresh: `agentpack session refresh`
@@ -242,11 +249,11 @@ Then open Claude Code / Cursor / Codex and write your coding task normally.
 | Agent | Automation level | Method |
 |---|---|---|
 | Claude Code (hook) | Highest | `UserPromptSubmit` hook auto-injects context |
-| Claude Code (session) | High | `session start` + `watch` + read `context.md` |
-| Codex | Medium | `AGENTS.md` + `session start` + `watch` |
-| Cursor | Medium | `.cursor/rules/agentpack.mdc` + `session start` + `watch` |
-| Windsurf | Medium | `.windsurfrules` + `session start` + `watch` |
-| Antigravity | Medium | `.agent/skills/agentpack/SKILL.md` + `GEMINI.md` + `session start` + `watch` |
+| Claude Code (session) | High | `init` + `watch` + read `context.md` |
+| Codex | Medium | `AGENTS.md` + `init` + `watch` |
+| Cursor | Medium | `.cursor/rules/agentpack.mdc` + `init` + `watch` |
+| Windsurf | Medium | `.windsurfrules` + `init` + `watch` |
+| Antigravity | Medium | `.agent/skills/agentpack/SKILL.md` + `GEMINI.md` + `init` + `watch` |
 | Generic | Basic | `watch` mode + read `context.md` |
 
 ### Honest limitations
@@ -263,10 +270,9 @@ Then open Claude Code / Cursor / Codex and write your coding task normally.
 ```bash
 pip install agentpack-cli
 cd your-project
-agentpack init
+agentpack init             # one-time setup: config + session + task.md
 agentpack install          # auto-detects your IDE (Claude Code, Cursor, Windsurf, Codex, Antigravity)
-agentpack session start    # generate initial context
-agentpack watch            # in another terminal — keeps context fresh
+agentpack watch            # in another terminal — keeps context fresh automatically
 ```
 
 Then open your agent and write your task normally.
@@ -642,22 +648,23 @@ Options:
 
 ### `agentpack session`
 
-Manage AgentPack sessions — the "start once, work normally" workflow.
+Optional session management. `agentpack init` bootstraps the session automatically — `session start` is only needed to change agent/mode after init or force a fresh pack.
 
 ```bash
-agentpack session start                      # create session, generate initial context
+agentpack session start                      # re-run to change agent/mode or force refresh
 agentpack session start --agent claude       # set agent (claude|cursor|codex|generic)
-agentpack session start --task "fix bug"     # set initial task
+agentpack session start --task "fix bug"     # change task + refresh context
 agentpack session status                     # show session state + context size
 agentpack session refresh                    # regenerate context now
 agentpack session refresh --task "new task"  # change task + refresh
 agentpack session stop                       # mark session inactive
 ```
 
-`session start` creates:
+`agentpack init` creates (idempotently):
 - `.agentpack/session.json` — session state
-- `.agentpack/task.md` — current task (written by Claude or `session refresh --task`)
-- `.agentpack/context.md` — readable context pack
+- `.agentpack/task.md` — current task (edit directly or use `session refresh --task`)
+- `.agentpack/context.md` — readable context pack (updated by `watch`)
+- `.agentpack/context.claude.md` — Claude Code format (always written alongside context.md)
 - `.agentpack/context.compact.md` — compact protocol format
 
 ---
@@ -688,7 +695,7 @@ Launch Claude CLI with an up-to-date context.
 agentpack claude
 ```
 
-Requires an active session (`agentpack session start`). Refreshes context, prints the context path, then launches `claude` if found. Transparent about what it does — no fake prompt injection.
+Requires an initialized project (`agentpack init`). Refreshes context, prints the context path, then launches `claude` if found. Transparent about what it does — no fake prompt injection.
 
 ---
 
@@ -1240,13 +1247,14 @@ Add to `.github/workflows/agentpack-context.yml` — see the full example in [CI
 ### Session mode: keep context fresh while you work
 
 ```bash
-# Terminal 1: start a session and watch for changes
-agentpack session start --task "refactor auth"
-agentpack watch   # in a second terminal — refreshes context on every save
+# One-time project setup
+agentpack init --task "refactor auth"   # or edit .agentpack/task.md directly
+
+# Every terminal session — just one command
+agentpack watch   # auto-resumes session, refreshes context on every save
 
-# Terminal 2: your editor / agent
-# Save a file → context.md regenerates automatically
-# Change task: agentpack session refresh --task "new task"
+# Change task mid-session
+agentpack session refresh --task "new task"
 ```
 
 ---
@@ -1316,8 +1324,8 @@ agentpack pack --task "fix bug" --budget 40000   # explicit token cap
 ### Watch mode for active sessions
 
 ```bash
-agentpack session start --task "refactor auth"
-agentpack watch   # in another terminal
+agentpack init                  # one-time setup (creates session + task.md)
+agentpack watch                 # in another terminal — auto-resumes each time
 ```
 
 Refreshes `.agentpack/context.md` every time you save a file. Change the task with `agentpack session refresh --task "..."` — or tell Claude and it writes `task.md` itself.
@@ -1360,7 +1368,7 @@ config_file     = 60   # was 25 — configs always matter here
 - **Local-first**: `init`, `scan`, `diff`, `pack`, `stats`, `summarize` make zero API calls by default
 - **Non-destructive**: never overwrites user files; config patching only touches agentpack-managed blocks
 - **Agent-neutral**: architecture is generic; Claude Code is the primary target (deepest integration); Cursor, Windsurf, Codex, and Antigravity are supported but less battle-tested
-- **No daemons**: file watching is opt-in via `agentpack watch`; session management is opt-in via `agentpack session start`; git hooks run in the background and are opt-in via `install`
+- **No daemons**: file watching is opt-in via `agentpack watch`; git hooks run in the background and are opt-in via `install`
 - **Honest**: packed token count reflects real content, not raw repo size
 
 ---

{agentpack_cli-0.1.7 → agentpack_cli-0.1.8}/README.md

@@ -41,12 +41,13 @@ The result: your agent starts every session with a focused, accurate picture of
 ```bash
 pip install agentpack-cli
 
-# Session mode: start once, then work normally
+# One-time setup per project
 cd your-project
-agentpack init
-agentpack install          # auto-detects your IDE
-agentpack session start
-agentpack watch   # in another terminal — keeps context fresh automatically
+agentpack init             # creates config, session, task.md — nothing else needed
+agentpack install          # auto-detects your IDE (optional but recommended)
+
+# Every terminal session
+agentpack watch            # keeps context fresh automatically — that's it
 ```
 
 Then open Claude Code / Cursor / Windsurf / Codex / Antigravity and write your task normally. AgentPack keeps `.agentpack/context.md` current.
@@ -181,17 +182,20 @@ Requires Python 3.10+.
 
 ## Start Once, Then Work Normally
 
-The recommended workflow for repeated development sessions:
+The full workflow:
 
 ```bash
-agentpack install          # configure your agent (once per project)
-agentpack session start    # create session state + generate initial context
-agentpack watch            # in another terminal — refreshes context on file/task changes
+# One-time project setup
+agentpack init             # creates config, session, task.md
+agentpack install          # configure your agent (optional but recommended)
+
+# Every terminal session — just one command
+agentpack watch            # auto-resumes session, refreshes context on file/task changes
 ```
 
 Then open Claude Code / Cursor / Codex and write your coding task normally.
 
-- AgentPack keeps `.agentpack/context.md` fresh while `watch` is running.
+- AgentPack keeps `.agentpack/context.md` and `.agentpack/context.claude.md` fresh while `watch` is running.
 - To change the task: `agentpack session refresh --task "new task"` — or just tell Claude and it updates `task.md` itself.
 - Check session state: `agentpack session status`
 - Force a refresh: `agentpack session refresh`
@@ -202,11 +206,11 @@ Then open Claude Code / Cursor / Codex and write your coding task normally.
 | Agent | Automation level | Method |
 |---|---|---|
 | Claude Code (hook) | Highest | `UserPromptSubmit` hook auto-injects context |
-| Claude Code (session) | High | `session start` + `watch` + read `context.md` |
-| Codex | Medium | `AGENTS.md` + `session start` + `watch` |
-| Cursor | Medium | `.cursor/rules/agentpack.mdc` + `session start` + `watch` |
-| Windsurf | Medium | `.windsurfrules` + `session start` + `watch` |
-| Antigravity | Medium | `.agent/skills/agentpack/SKILL.md` + `GEMINI.md` + `session start` + `watch` |
+| Claude Code (session) | High | `init` + `watch` + read `context.md` |
+| Codex | Medium | `AGENTS.md` + `init` + `watch` |
+| Cursor | Medium | `.cursor/rules/agentpack.mdc` + `init` + `watch` |
+| Windsurf | Medium | `.windsurfrules` + `init` + `watch` |
+| Antigravity | Medium | `.agent/skills/agentpack/SKILL.md` + `GEMINI.md` + `init` + `watch` |
 | Generic | Basic | `watch` mode + read `context.md` |
 
 ### Honest limitations
@@ -223,10 +227,9 @@ Then open Claude Code / Cursor / Codex and write your coding task normally.
 ```bash
 pip install agentpack-cli
 cd your-project
-agentpack init
+agentpack init             # one-time setup: config + session + task.md
 agentpack install          # auto-detects your IDE (Claude Code, Cursor, Windsurf, Codex, Antigravity)
-agentpack session start    # generate initial context
-agentpack watch            # in another terminal — keeps context fresh
+agentpack watch            # in another terminal — keeps context fresh automatically
 ```
 
 Then open your agent and write your task normally.
@@ -602,22 +605,23 @@ Options:
 
 ### `agentpack session`
 
-Manage AgentPack sessions — the "start once, work normally" workflow.
+Optional session management. `agentpack init` bootstraps the session automatically — `session start` is only needed to change agent/mode after init or force a fresh pack.
 
 ```bash
-agentpack session start                      # create session, generate initial context
+agentpack session start                      # re-run to change agent/mode or force refresh
 agentpack session start --agent claude       # set agent (claude|cursor|codex|generic)
-agentpack session start --task "fix bug"     # set initial task
+agentpack session start --task "fix bug"     # change task + refresh context
 agentpack session status                     # show session state + context size
 agentpack session refresh                    # regenerate context now
 agentpack session refresh --task "new task"  # change task + refresh
 agentpack session stop                       # mark session inactive
 ```
 
-`session start` creates:
+`agentpack init` creates (idempotently):
 - `.agentpack/session.json` — session state
-- `.agentpack/task.md` — current task (written by Claude or `session refresh --task`)
-- `.agentpack/context.md` — readable context pack
+- `.agentpack/task.md` — current task (edit directly or use `session refresh --task`)
+- `.agentpack/context.md` — readable context pack (updated by `watch`)
+- `.agentpack/context.claude.md` — Claude Code format (always written alongside context.md)
 - `.agentpack/context.compact.md` — compact protocol format
 
 ---
@@ -648,7 +652,7 @@ Launch Claude CLI with an up-to-date context.
 agentpack claude
 ```
 
-Requires an active session (`agentpack session start`). Refreshes context, prints the context path, then launches `claude` if found. Transparent about what it does — no fake prompt injection.
+Requires an initialized project (`agentpack init`). Refreshes context, prints the context path, then launches `claude` if found. Transparent about what it does — no fake prompt injection.
 
 ---
 
@@ -1200,13 +1204,14 @@ Add to `.github/workflows/agentpack-context.yml` — see the full example in [CI
 ### Session mode: keep context fresh while you work
 
 ```bash
-# Terminal 1: start a session and watch for changes
-agentpack session start --task "refactor auth"
-agentpack watch   # in a second terminal — refreshes context on every save
+# One-time project setup
+agentpack init --task "refactor auth"   # or edit .agentpack/task.md directly
+
+# Every terminal session — just one command
+agentpack watch   # auto-resumes session, refreshes context on every save
 
-# Terminal 2: your editor / agent
-# Save a file → context.md regenerates automatically
-# Change task: agentpack session refresh --task "new task"
+# Change task mid-session
+agentpack session refresh --task "new task"
 ```
 
 ---
@@ -1276,8 +1281,8 @@ agentpack pack --task "fix bug" --budget 40000   # explicit token cap
 ### Watch mode for active sessions
 
 ```bash
-agentpack session start --task "refactor auth"
-agentpack watch   # in another terminal
+agentpack init                  # one-time setup (creates session + task.md)
+agentpack watch                 # in another terminal — auto-resumes each time
 ```
 
 Refreshes `.agentpack/context.md` every time you save a file. Change the task with `agentpack session refresh --task "..."` — or tell Claude and it writes `task.md` itself.
@@ -1320,7 +1325,7 @@ config_file     = 60   # was 25 — configs always matter here
 - **Local-first**: `init`, `scan`, `diff`, `pack`, `stats`, `summarize` make zero API calls by default
 - **Non-destructive**: never overwrites user files; config patching only touches agentpack-managed blocks
 - **Agent-neutral**: architecture is generic; Claude Code is the primary target (deepest integration); Cursor, Windsurf, Codex, and Antigravity are supported but less battle-tested
-- **No daemons**: file watching is opt-in via `agentpack watch`; session management is opt-in via `agentpack session start`; git hooks run in the background and are opt-in via `install`
+- **No daemons**: file watching is opt-in via `agentpack watch`; git hooks run in the background and are opt-in via `install`
 - **Honest**: packed token count reflects real content, not raw repo size
 
 ---

{agentpack_cli-0.1.7 → agentpack_cli-0.1.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agentpack-cli"
-version = "0.1.7"
+version = "0.1.8"
 description = "Token-aware context packing for AI coding agents — Claude, Cursor, Windsurf, and Codex"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -40,10 +40,15 @@ watch = [
   "watchdog>=4.0.0"
 ]
 
+mcp = [
+  "mcp>=1.0.0"
+]
+
 all = [
   "anthropic>=0.39.0",
   "openai>=1.0.0",
-  "watchdog>=4.0.0"
+  "watchdog>=4.0.0",
+  "mcp>=1.0.0"
 ]
 
 dev = [

{agentpack_cli-0.1.7 → agentpack_cli-0.1.8}/src/agentpack/cli.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import typer
-from agentpack.commands import init, scan, diff, status, stats, summarize, pack, install, monitor, explain, doctor, session, watch, claude_cmd, benchmark
+from agentpack.commands import init, scan, diff, status, stats, summarize, pack, install, monitor, explain, doctor, session, watch, claude_cmd, benchmark, mcp_cmd
 from agentpack import __version__
 
 
@@ -21,7 +21,7 @@ def _main(
     pass
 
 
-for mod in [init, scan, diff, status, stats, summarize, pack, install, monitor, explain, doctor, session, watch, claude_cmd, benchmark]:
+for mod in [init, scan, diff, status, stats, summarize, pack, install, monitor, explain, doctor, session, watch, claude_cmd, benchmark, mcp_cmd]:
     mod.register(app)
 
 

{agentpack_cli-0.1.7 → agentpack_cli-0.1.8}/src/agentpack/commands/init.py

@@ -8,6 +8,7 @@ import typer
 from agentpack.core.config import DEFAULT_CONFIG, CONFIG_TEMPLATE, save_config
 from agentpack.core.ignore import DEFAULT_AGENTIGNORE
 from agentpack.commands._shared import console, _root
+from agentpack.session.state import load_session, create_session, save_session, SESSION_FILE, TASK_FILE
 
 
 def register(app: typer.Typer) -> None:
@@ -19,8 +20,12 @@ def register(app: typer.Typer) -> None:
         yes: bool = typer.Option(False, "--yes", "-y", help="Skip interactive prompts, use defaults."),
         silent: bool = typer.Option(False, "--silent", help="Suppress all output (for use in hooks/scripts)."),
         share_cache: bool = typer.Option(False, "--share-cache", help="Commit summary cache to git (recommended for teams)."),
+        agent: str = typer.Option("auto", "--agent", help="Target agent (auto|claude|cursor|windsurf|codex|antigravity|generic)."),
     ) -> None:
-        """Initialize AgentPack in the current directory."""
+        """Initialize AgentPack in the current directory.
+
+        One-time setup. After this, just run `agentpack watch` — no other commands needed.
+        """
         if silent:
             yes = True
             console.quiet = True
@@ -85,5 +90,18 @@ def register(app: typer.Typer) -> None:
         else:
             console.print("[dim]Skipped[/] .agentignore (exists)")
 
+        # Bootstrap session so `agentpack watch` works immediately — no separate `session start` needed
+        from agentpack.core.config import load_config
+        resolved_mode = load_config(root).context.default_mode
+        existing_session = load_session(root)
+        if existing_session is None or force:
+            from agentpack.adapters.detect import detect_agent
+            resolved_agent = agent if agent != "auto" else detect_agent(root)
+            session_state = create_session(root, agent=resolved_agent, mode=resolved_mode)
+            console.print(f"[green]Created[/] {SESSION_FILE}  [dim]agent={resolved_agent} mode={resolved_mode}[/]")
+            console.print(f"[green]Created[/] {TASK_FILE}  [dim]edit to set your task[/]")
+        else:
+            console.print(f"[dim]Skipped[/] {SESSION_FILE} (exists)")
+
         console.print("\n[bold green]AgentPack initialized.[/]")
-        console.print("Run [bold]agentpack scan[/] to explore your repo.")
+        console.print("Run [bold]agentpack watch[/] to start auto-refreshing context.")

agentpack_cli-0.1.8/src/agentpack/commands/mcp_cmd.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+import typer
+
+from agentpack.commands._shared import console
+
+
+def register(app: typer.Typer) -> None:
+    @app.command("mcp")
+    def mcp_server() -> None:
+        """Start the AgentPack MCP server (tools: pack_context, get_context, refresh)."""
+        from agentpack.mcp_server import serve
+        serve()

{agentpack_cli-0.1.7 → agentpack_cli-0.1.8}/src/agentpack/commands/session.py

@@ -28,41 +28,46 @@ def register(app: typer.Typer) -> None:
         budget: int = typer.Option(0, "--budget", help="Token budget (0 = config default)."),
         silent: bool = typer.Option(False, "--silent", help="Suppress all output (for use in hooks/scripts)."),
     ) -> None:
-        """Start a session: create state files and generate initial context."""
+        """Refresh session and generate context. Optional — `agentpack init` already bootstraps the session.
+
+        Use this to change agent/mode after init, or to force a fresh context pack.
+        Idempotent: resumes existing session rather than recreating it.
+        """
         root = _root()
         if silent:
             console.quiet = True
-        state = create_session(root, agent=agent, mode=mode)
+
+        existing = load_session(root)
+        if existing is not None:
+            # Resume: update agent/mode only if explicitly passed, then refresh
+            if agent != "auto":
+                existing.agent = agent
+            if mode != "balanced" or existing.agent == "generic":
+                # only override mode if user explicitly chose non-default
+                if mode != "balanced":
+                    existing.mode = mode
+            existing.active = True
+            save_session(root, existing)
+            state = existing
+            console.print("[dim]Session resumed.[/]")
+        else:
+            state = create_session(root, agent=agent, mode=mode)
+            console.print()
+            console.print("[bold green]AgentPack session initialized.[/]")
+            console.print()
+            console.print(f"  [green]✓[/] {SESSION_FILE}  [dim]session state[/]")
+            console.print(f"  [green]✓[/] {TASK_FILE}  [dim]edit to set your task[/]")
 
         if task:
             (root / TASK_FILE).write_text(f"# Current Task\n\n{task}\n", encoding="utf-8")
 
-        console.print()
-        console.print("[bold green]AgentPack session started.[/]")
-        console.print()
-
-        created: list[tuple[str, str]] = [
-            (SESSION_FILE, "session state"),
-            (TASK_FILE, "edit to set your task"),
-        ]
-
         result = _run_refresh(root, state.agent, state.mode, budget)
         if result:
-            created += [
-                (CONTEXT_FILE, f"{result['files']} files, {result['tokens']:,} tokens"),
-                (COMPACT_FILE, "compact protocol format"),
-            ]
-            log_activity(root, f"session started — {result['files']} files, {result['tokens']:,} tokens")
+            console.print(f"  [green]✓[/] {CONTEXT_FILE}  [dim]{result['files']} files, {result['tokens']:,} tokens[/]")
+            log_activity(root, f"session start — {result['files']} files, {result['tokens']:,} tokens")
         else:
-            created += [
-                (CONTEXT_FILE, "will generate on first refresh"),
-                (COMPACT_FILE, "will generate on first refresh"),
-            ]
-            log_activity(root, "session started (context generation deferred)")
-
-        console.print("[bold]Created:[/]")
-        for path, note in created:
-            console.print(f"  [green]✓[/] {path}  [dim]{note}[/]")
+            console.print(f"  [dim]✗ context generation failed — run agentpack session refresh[/]")
+            log_activity(root, "session start (context generation failed)")
 
         console.print()
         console.print("[bold]Next:[/]")
@@ -176,11 +181,14 @@ def _run_refresh(
         ))
 
         # Write context files atomically — avoids partial reads if interrupted mid-write
-        from agentpack.renderers.markdown import render_generic
-        context_text = render_generic(result.pack)
+        from agentpack.renderers.markdown import render_generic, render_claude
         context_path = root / CONTEXT_FILE
         context_path.parent.mkdir(parents=True, exist_ok=True)
-        _atomic_write(context_path, context_text)
+        _atomic_write(context_path, render_generic(result.pack))
+
+        # Always write the claude-specific format too — the Claude Code hook reads this
+        # regardless of which agent the session was started with.
+        _atomic_write(root / ".agentpack/context.claude.md", render_claude(result.pack))
 
         compact_text = render_compact(result.pack)
         compact_path = root / COMPACT_FILE

{agentpack_cli-0.1.7 → agentpack_cli-0.1.8}/src/agentpack/commands/watch.py

@@ -34,13 +34,18 @@ def register(app: typer.Typer) -> None:
         root = _root()
         state = load_session(root)
 
+        # Auto-resume: if session exists but inactive, reactivate without requiring `session start`
+        if state is not None and not state.active:
+            state.active = True
+            save_session(root, state)
+            console.print("[dim]Resumed session.[/]")
+        elif state is None:
+            console.print("[yellow]No session found — watching in stateless mode.[/]")
+            console.print("[dim]Run 'agentpack session start' to persist agent/mode preferences.[/]")
+
         effective_agent = agent or (state.agent if state else "generic")
         effective_mode = mode or (state.mode if state else "balanced")
 
-        if state is None:
-            console.print("[yellow]No session found — watching in stateless mode.[/]")
-            console.print("[dim]Run 'agentpack session start' for full session support.[/]")
-
         console.print()
         console.print("[bold]AgentPack watch active.[/]")
         console.print("Press Ctrl+C to stop.")

{agentpack_cli-0.1.7 → agentpack_cli-0.1.8}/src/agentpack/installers/claude.py

@@ -72,9 +72,12 @@ class ClaudeInstaller:
 
         # SessionStart: delete sentinel + kick off background repack so first prompt
         # gets fresh context without blocking the session.
+        # Use session refresh if session exists (respects task.md), else fall back to pack.
         sentinel_cmd = (
             "rm -f .agentpack/.context_injected"
-            " && agentpack pack --task auto --mode balanced >/dev/null 2>&1 &"
+            " && ([ -f .agentpack/session.json ]"
+            " && agentpack session refresh >/dev/null 2>&1"
+            " || agentpack pack --task auto --mode balanced >/dev/null 2>&1) &"
         )
         session_start = hooks.setdefault("SessionStart", [])
         # Replace any stale agentpack session hooks (old cmd only deleted sentinel).

agentpack_cli-0.1.8/src/agentpack/mcp_server.py

@@ -0,0 +1,119 @@
+"""AgentPack MCP server — exposes context packing as MCP tools.
+
+Start with:
+    agentpack mcp
+
+Or register in Claude Code settings:
+    {
+      "mcpServers": {
+        "agentpack": {
+          "command": "agentpack",
+          "args": ["mcp"]
+        }
+      }
+    }
+
+Tools exposed:
+    pack_context   — generate/refresh a context pack for a task
+    get_context    — read the latest context pack (no repack)
+    refresh        — refresh using the current task.md
+"""
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+
+def _repo_root() -> Path:
+    """Walk up from cwd until .agentpack/ found; fall back to cwd."""
+    cwd = Path.cwd()
+    for parent in [cwd, *cwd.parents]:
+        if (parent / ".agentpack").exists():
+            return parent
+    return cwd
+
+
+def serve() -> None:
+    try:
+        from mcp.server.fastmcp import FastMCP
+    except ImportError:
+        print(
+            "mcp package required for MCP server. "
+            "Install: pip install 'agentpack-cli[mcp]'",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+
+    mcp = FastMCP("agentpack")
+
+    @mcp.tool()
+    def pack_context(task: str, mode: str = "balanced", budget: int = 0) -> str:
+        """Generate a ranked context pack for the given task.
+
+        Args:
+            task: Describe what you're working on (e.g. "fix auth token refresh").
+            mode: minimal | balanced (default) | deep
+            budget: Token budget, 0 = config default (usually 25000).
+
+        Returns the packed context as a markdown string.
+        """
+        from agentpack.application.pack_service import PackService, PackRequest
+        from agentpack.adapters.detect import detect_agent
+        from agentpack.renderers.markdown import render_claude
+
+        root = _repo_root()
+        agent = detect_agent(root)
+        result = PackService().run(PackRequest(
+            root=root,
+            agent=agent,
+            task=task,
+            mode=mode,
+            budget=budget,
+            since=None,
+            refresh=False,
+            summary_provider="offline",
+        ))
+        return render_claude(result.pack)
+
+    @mcp.tool()
+    def get_context() -> str:
+        """Return the latest pre-built context pack without repacking.
+
+        Fast — just reads the cached file. Use pack_context() to regenerate.
+        Returns empty string if no pack exists yet.
+        """
+        root = _repo_root()
+        for candidate in (
+            root / ".agentpack" / "context.claude.md",
+            root / ".agentpack" / "context.md",
+        ):
+            if candidate.exists():
+                return candidate.read_text(encoding="utf-8")
+        return ""
+
+    @mcp.tool()
+    def refresh() -> str:
+        """Refresh context using the current task.md (or git-inferred task).
+
+        Equivalent to running `agentpack session refresh`.
+        Returns summary of what was packed.
+        """
+        from agentpack.commands.session import _run_refresh
+        from agentpack.session.state import load_session
+        from agentpack.adapters.detect import detect_agent
+
+        root = _repo_root()
+        state = load_session(root)
+        agent = state.agent if state else detect_agent(root)
+        mode = state.mode if state else "balanced"
+
+        result = _run_refresh(root, agent, mode, 0)
+        if result is None:
+            return "Refresh failed."
+        return (
+            f"Refreshed: {result['files']} files, "
+            f"{result['tokens']:,} tokens, "
+            f"{result['saving']:.1f}% saving"
+        )
+
+    mcp.run()