thwip-cli 1.6.2__tar.gz → 1.8.0__tar.gz

{thwip_cli-1.6.2 → thwip_cli-1.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: thwip-cli
-Version: 1.6.2
+Version: 1.8.0
 Summary: Universal coding agent multiplexer: detect, switch, and route between AI coding agents seamlessly
 Project-URL: Homepage, https://github.com/tanmayhutt/thwip-cli
 Project-URL: Repository, https://github.com/tanmayhutt/thwip-cli
@@ -55,6 +55,7 @@ Description-Content-Type: text/markdown
 - **Tool Layer**: Shared file editing, code execution (Python, Node, Shell), and Git integration across connected models.
 - **Session Persistence**: Save and resume sessions across projects with `/session save` and `/session load`.
 - **Familiar Flow**: The same everyday commands as Codex, Claude Code, and Antigravity (`/model`, `/new`, `/resume`, `/compact`, `/diff`, `/copy`, `!cmd`, `@file`), plus autocompletion, Ctrl+S / Ctrl+T shortcuts, and streaming Markdown.
+- **Project Memory and Second Brain**: One `context.md` per project that every agent reads and maintains, filed into your Obsidian vault with cross-project links by stack, area, and tag.
 - **Live Model Lists**: Model catalogs come from the connected CLI or the provider's list-models endpoint, never from a hardcoded list.
 
 ---
@@ -85,6 +86,8 @@ Start the interactive terminal in your current project directory:
 thwip
 thwip --project ~/code/my-app   # open a specific project
 thwip --version
+thwip man                       # read the manual page
+thwip install-man               # then `man thwip` works
 ```
 
 ---
@@ -142,6 +145,16 @@ not in the catalog is passed to the CLI for validation instead of being rejected
 a bundled list. A model available in a desktop app may still be absent from the
 installed CLI's catalog or account access.
 
+Each provider keeps a warm native session. The first message to a provider sends the
+portable conversation once; after that only new messages are sent. Codex keeps one
+`app-server` process running and resumes its thread; Claude Code uses `--session-id`
+and `--resume`; Antigravity uses `--conversation`. When you come back to a provider after
+chatting with another one, it receives a short catch-up block containing only what it
+missed. The native session IDs are stored in the thwip session file next to the
+transcript, validated on load, shown by `/status`, and cleared by `/new`, `/clear`,
+`/compact`, and a project change. If a CLI can no longer continue a session, thwip says
+so and resends the full conversation to a fresh one.
+
 Native connections are read-only by default. Codex starts with a read-only sandbox
 and asks before operations outside it; approval requests appear in Thwip with the
 command or file list and default to denial. Claude Code and the Antigravity CLI run
@@ -163,6 +176,35 @@ replaces Thwip with the Codex CLI itself in the selected project. Conversation
 history is not transferred by the launcher; use `/session load` after restarting
 Thwip to resume.
 
+## Project memory and your second brain
+
+Every project gets one canonical memory file, `context.md` in the project root, that
+every agent you use through thwip reads and helps maintain. It records the snapshot,
+current work (Now, Blocked, Next), architecture notes, decisions, known issues, and
+dated recent changes. Whichever provider you switch to receives it as instructions, so
+the project's state survives agent switches and sessions, not just the conversation.
+
+On first run thwip offers to connect a second-brain vault: it detects vaults registered
+with the Obsidian desktop app, or creates a new Markdown folder. In the vault each
+project gets a stable index card under `Projects/`, hub notes under `Stack/`, `Areas/`,
+and `Tags/`, and a `Projects.md` dashboard. Projects that share a stack, area, or tag
+link to each other through those hubs and a "Related projects" list on every card.
+thwip only writes notes it created itself (marked `generated_by: thwip`); hand-written
+notes are never touched.
+
+| Command | Action |
+|:---|:---|
+| `/memory` | Show this project's memory file |
+| `/memory init [area]` | Create it from the template with detected stack and entry points |
+| `/memory update` | Ask the current model to revise it from the conversation; a diff is shown and written only after you confirm |
+| `/memory edit` | Open it in `$EDITOR` |
+| `/memory sync` | File the project into the vault and refresh hubs and the dashboard |
+| `/memory vault <path>` | Connect or change the vault |
+| `/memory link` | Add a pointer to `AGENTS.md` and `CLAUDE.md` so the CLIs read it outside thwip too |
+
+When you `/quit` after a real conversation, thwip offers the update once. Settings live under
+`[memory]` in `~/.thwip/config.toml`: `enabled`, `file`, `vault`, `offer_update_on_quit`.
+
 ## Live model lists
 
 Model lists are not hardcoded. Each connected source supplies its own list:

{thwip_cli-1.6.2 → thwip_cli-1.8.0}/README.md

@@ -18,6 +18,7 @@
 - **Tool Layer**: Shared file editing, code execution (Python, Node, Shell), and Git integration across connected models.
 - **Session Persistence**: Save and resume sessions across projects with `/session save` and `/session load`.
 - **Familiar Flow**: The same everyday commands as Codex, Claude Code, and Antigravity (`/model`, `/new`, `/resume`, `/compact`, `/diff`, `/copy`, `!cmd`, `@file`), plus autocompletion, Ctrl+S / Ctrl+T shortcuts, and streaming Markdown.
+- **Project Memory and Second Brain**: One `context.md` per project that every agent reads and maintains, filed into your Obsidian vault with cross-project links by stack, area, and tag.
 - **Live Model Lists**: Model catalogs come from the connected CLI or the provider's list-models endpoint, never from a hardcoded list.
 
 ---
@@ -48,6 +49,8 @@ Start the interactive terminal in your current project directory:
 thwip
 thwip --project ~/code/my-app   # open a specific project
 thwip --version
+thwip man                       # read the manual page
+thwip install-man               # then `man thwip` works
 ```
 
 ---
@@ -105,6 +108,16 @@ not in the catalog is passed to the CLI for validation instead of being rejected
 a bundled list. A model available in a desktop app may still be absent from the
 installed CLI's catalog or account access.
 
+Each provider keeps a warm native session. The first message to a provider sends the
+portable conversation once; after that only new messages are sent. Codex keeps one
+`app-server` process running and resumes its thread; Claude Code uses `--session-id`
+and `--resume`; Antigravity uses `--conversation`. When you come back to a provider after
+chatting with another one, it receives a short catch-up block containing only what it
+missed. The native session IDs are stored in the thwip session file next to the
+transcript, validated on load, shown by `/status`, and cleared by `/new`, `/clear`,
+`/compact`, and a project change. If a CLI can no longer continue a session, thwip says
+so and resends the full conversation to a fresh one.
+
 Native connections are read-only by default. Codex starts with a read-only sandbox
 and asks before operations outside it; approval requests appear in Thwip with the
 command or file list and default to denial. Claude Code and the Antigravity CLI run
@@ -126,6 +139,35 @@ replaces Thwip with the Codex CLI itself in the selected project. Conversation
 history is not transferred by the launcher; use `/session load` after restarting
 Thwip to resume.
 
+## Project memory and your second brain
+
+Every project gets one canonical memory file, `context.md` in the project root, that
+every agent you use through thwip reads and helps maintain. It records the snapshot,
+current work (Now, Blocked, Next), architecture notes, decisions, known issues, and
+dated recent changes. Whichever provider you switch to receives it as instructions, so
+the project's state survives agent switches and sessions, not just the conversation.
+
+On first run thwip offers to connect a second-brain vault: it detects vaults registered
+with the Obsidian desktop app, or creates a new Markdown folder. In the vault each
+project gets a stable index card under `Projects/`, hub notes under `Stack/`, `Areas/`,
+and `Tags/`, and a `Projects.md` dashboard. Projects that share a stack, area, or tag
+link to each other through those hubs and a "Related projects" list on every card.
+thwip only writes notes it created itself (marked `generated_by: thwip`); hand-written
+notes are never touched.
+
+| Command | Action |
+|:---|:---|
+| `/memory` | Show this project's memory file |
+| `/memory init [area]` | Create it from the template with detected stack and entry points |
+| `/memory update` | Ask the current model to revise it from the conversation; a diff is shown and written only after you confirm |
+| `/memory edit` | Open it in `$EDITOR` |
+| `/memory sync` | File the project into the vault and refresh hubs and the dashboard |
+| `/memory vault <path>` | Connect or change the vault |
+| `/memory link` | Add a pointer to `AGENTS.md` and `CLAUDE.md` so the CLIs read it outside thwip too |
+
+When you `/quit` after a real conversation, thwip offers the update once. Settings live under
+`[memory]` in `~/.thwip/config.toml`: `enabled`, `file`, `vault`, `offer_update_on_quit`.
+
 ## Live model lists
 
 Model lists are not hardcoded. Each connected source supplies its own list:

{thwip_cli-1.6.2 → thwip_cli-1.8.0}/docs/verification.md

@@ -1,7 +1,7 @@
 # Verification status
 
-Verified locally on 2026-09-24 for v1.6.2. The Python suite
-passes 265 offline tests on Python 3.11, 3.12, and 3.13. Exhaustive behavior across every provider and
+Verified locally on 2026-09-24 for v1.8.0. The Python suite
+passes 282 offline tests on Python 3.11, 3.12, and 3.13. Exhaustive behavior across every provider and
 configuration has not been established.
 
 ## Native CLI connections (2026-09-24)
@@ -19,6 +19,9 @@ each using its existing sign-in. No API keys were configured.
 | Ctrl+C during a response | Turn cancelled, child process terminated, REPL continued, unanswered message removed |
 | Ctrl+C at a Codex permission prompt | Turn cancelled, no file created, no leftover process, REPL continued |
 | Usage-limit failover | With a test-only shim making Codex report "You've hit your usage limit", the real REPL showed the alternatives, switched to Claude Code on `1`, retried the message, and answered; history held one clean pair |
+| Project memory and vault (v1.8.0) | Live in a temp project with a temp config and vault: first-run onboarding listed the real Obsidian vault and accepted a typed path; `/memory init` detected the stack and filed card, hub, and dashboard notes; a Codex turn received the memory as instructions; `/memory update` produced a diff written only after `y`; `/status` and the quit-time offer behaved. Offline: frontmatter, template init, injection bounds, Obsidian registry detection, vault sync with related links and hand-written-note protection, update flow, invalid model output rejection, onboarding choices |
+| Warm native sessions (v1.7.0) | Live: Claude Code recalled a code word on its second turn through `--resume`; Codex received the full transcript on first switch and answered from it; returning to Claude delivered a catch-up block; a second Codex turn reused the running app-server; `/status` showed each CLI session ID and synced count; `/new` cleared them; no leftover processes. Offline: resume, catch-up, and fallback paths for Codex, Claude Code, and Antigravity; session record validation and persistence |
+| Manual page (v1.7.0) | `thwip install-man` then `man -w thwip` and `man thwip` resolve from `~/.local/share/man` |
 | Terminal hygiene (v1.6.2) | Cursor-position queries disabled, keyboard echo off during turns, stray input flushed before each prompt; fixes `^[`/`^R` noise and phantom empty prompts seen in a real Ghostty session during a slow Antigravity reply. Permission prompt and chat re-verified live afterwards |
 | Ollama adapter (v1.6.1) | End to end against the fake Ollama routes: model list, streamed text with usage, tool call, HTTP 500 and unreachable server now raise clear errors instead of ending the turn silently |
 | Dependency audits (v1.6.1) | pip-audit reports no known vulnerabilities; npm audit reports zero |

{thwip_cli-1.6.2 → thwip_cli-1.8.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "thwip-cli"
-version = "1.6.2"
+version = "1.8.0"
 description = "Universal coding agent multiplexer: detect, switch, and route between AI coding agents seamlessly"
 readme = "README.md"
 license = "MIT"

thwip_cli-1.8.0/tests/test_memory.py

@@ -0,0 +1,210 @@
+"""Project memory file, vault filing with cross-project links, onboarding, and model-driven updates."""
+
+import json
+
+import pytest
+
+from thwip.agents.base import AgentDone, TextDelta
+from thwip.cli import ThwipCLI
+from thwip.config import ThwipConfig
+from thwip.memory import ProjectMemory, Vault, detect_obsidian_vaults, parse_frontmatter, render_frontmatter
+from thwip.session import Session
+from thwip.tools import ToolManager
+
+
+def test_frontmatter_round_trip():
+    data, body = parse_frontmatter("---\nproject: Demo\nstack: [Python, Docker]\nupdated: 2026-09-24\n---\n\n# Demo\n")
+    assert data == {"project": "Demo", "stack": ["Python", "Docker"], "updated": "2026-09-24"} and body.startswith("# Demo")
+    assert render_frontmatter({"a": "x", "b": ["1", "2"], "c": ""}) == "---\na: x\nb: [1, 2]\n---"
+    assert parse_frontmatter("no frontmatter") == ({}, "no frontmatter")
+
+
+def test_init_detects_stack_and_never_overwrites(tmp_path):
+    (tmp_path / "pyproject.toml").write_text("[project]\nname='demo'\n")
+    (tmp_path / "package.json").write_text("{}")
+    memory = ProjectMemory(str(tmp_path))
+    text = memory.init(area="Developer Tools", tags=["cli"])
+    data, body = parse_frontmatter(text)
+    assert data["project"] == tmp_path.name and data["stack"] == ["Python", "JavaScript"] and data["area"] == "Developer Tools"
+    assert data["type"] == "cli-tool" and data["tags"] == ["cli"] and "## Current Work" in body
+    memory.write("---\nproject: Custom\n---\n\n# Custom\n")
+    assert memory.init() .startswith("---\nproject: Custom"), "init never replaces an existing file"
+    assert "Project memory (context.md)" in memory.injection() and "# Custom" in memory.injection()
+    memory.write("---\nproject: Big\n---\n" + "x" * 20000)
+    assert memory.injection().endswith("[Project memory truncated; read the full file with /memory]")
+    assert memory.touch_updated("---\nupdated: 2000-01-01\nproject: Big\n---\n\nbody").split("\n")[1] != "updated: 2000-01-01"
+
+
+def test_detect_obsidian_vaults_reads_registry(tmp_path, monkeypatch):
+    registry = tmp_path / "Library" / "Application Support" / "obsidian" / "obsidian.json"
+    registry.parent.mkdir(parents=True)
+    vault = tmp_path / "MyVault"
+    vault.mkdir()
+    registry.write_text(json.dumps({"vaults": {"a": {"path": str(vault)}, "b": {"path": str(tmp_path / "missing")}}}))
+    monkeypatch.setattr("thwip.memory.Path.home", lambda: tmp_path)
+    assert detect_obsidian_vaults() == [str(vault)]
+
+
+def test_vault_sync_files_cards_hubs_and_related_links(tmp_path):
+    vault = Vault(str(tmp_path / "brain"))
+    vault.create()
+    alpha = tmp_path / "alpha"
+    beta = tmp_path / "beta"
+    for folder, extra in ((alpha, "Rust"), (beta, "Go")):
+        folder.mkdir()
+        ProjectMemory(str(folder)).write(
+            f"---\nproject: {folder.name}\npurpose: {folder.name} tool\narea: Developer Tools\nstatus: active\n"
+            f"updated: 2026-09-24\nstack: [Python, {extra}]\ntags: [cli]\n---\n\n# {folder.name} Context\n")
+    report = vault.sync(ProjectMemory(str(alpha)))
+    assert any(path.endswith("Projects/alpha.md") for path in report["written"])
+    card = (vault.root / "Projects" / "alpha.md").read_text()
+    assert "generated_by: thwip" in card and "None yet" in card
+    report = vault.sync(ProjectMemory(str(beta)))
+    beta_card = (vault.root / "Projects" / "beta.md").read_text()
+    assert "[[Projects/alpha|alpha]]: shares area Developer Tools, stack Python, tag cli" in beta_card
+    hub = (vault.root / "Stack" / "Python.md").read_text()
+    assert "[[Projects/alpha|alpha]]" in hub and "[[Projects/beta|beta]]" in hub
+    assert (vault.root / "Areas" / "Developer Tools.md").is_file() and (vault.root / "Tags" / "cli.md").is_file()
+    dashboard = (vault.root / "Projects.md").read_text()
+    assert "| [[Projects/alpha|alpha]] | Developer Tools | active | Python, Rust | 2026-09-24 |" in dashboard
+    # Re-filing alpha now links back to beta.
+    vault.sync(ProjectMemory(str(alpha)))
+    assert "[[Projects/beta|beta]]" in (vault.root / "Projects" / "alpha.md").read_text()
+    # A hand-written note is never overwritten.
+    (vault.root / "Projects" / "gamma.md").write_text("# my own note\n")
+    gamma = tmp_path / "gamma"
+    gamma.mkdir()
+    ProjectMemory(str(gamma)).write("---\nproject: gamma\n---\n\n# gamma\n")
+    report = vault.sync(ProjectMemory(str(gamma)))
+    assert report["skipped"] == [str(vault.root / "Projects" / "gamma.md")]
+    assert (vault.root / "Projects" / "gamma.md").read_text() == "# my own note\n"
+
+
+class FakeAgent:
+    name = "openai"
+    display_name = "Fake"
+    company = "OpenAI"
+    native_tools = False
+
+    def __init__(self, reply):
+        self.reply = reply
+        self.prompts = []
+
+    def is_configured(self):
+        return True
+
+    async def chat(self, **kwargs):
+        self.prompts.append(kwargs)
+        yield TextDelta(content=self.reply)
+        yield AgentDone()
+
+
+@pytest.fixture
+def cli(tmp_path, monkeypatch):
+    monkeypatch.setenv("THWIP_CONFIG_DIR", str(tmp_path / "config"))
+    cli = ThwipCLI.__new__(ThwipCLI)
+    cli.config = ThwipConfig(project=str(tmp_path / "proj"), auto_save=False)
+    (tmp_path / "proj").mkdir()
+    cli.config.memory.vault = str(tmp_path / "brain")
+    cli.config.memory.onboarded = True
+    cli.tool_manager = ToolManager(str(tmp_path / "proj"))
+    cli.session = Session(project_path=str(tmp_path / "proj"), current_agent="openai", current_model="m")
+    cli.session.add_user_message("we decided to use sqlite")
+    cli.session.add_assistant_message("noted", agent_name="openai", model="m")
+    return cli
+
+
+@pytest.mark.asyncio
+async def test_memory_update_writes_after_confirmation_and_files_in_vault(cli, monkeypatch):
+    memory = cli._memory()
+    memory.init(area="Data")
+    proposed = memory.read().replace("- Now:", "- Now: use sqlite for storage").replace("## Decisions\n", "## Decisions\n\n- SQLite chosen for zero-setup storage.\n")
+    cli.current_agent = FakeAgent("```markdown\n" + proposed + "\n```")
+    answers = iter(["n", "y"])
+
+    async def ask(question):
+        return next(answers)
+    monkeypatch.setattr(cli, "_ask_text", ask)
+    assert await cli._memory_update() is False and "sqlite" not in memory.read()
+    assert await cli._memory_update() is True
+    text = memory.read()
+    assert "- Now: use sqlite for storage" in text and "SQLite chosen" in text
+    assert "we decided to use sqlite" in cli.current_agent.prompts[0]["messages"][0]["content"]
+    assert (tmp_path_card := cli._vault().root / "Projects" / (memory.name() + ".md")).is_file(), tmp_path_card
+    # Instructions sent to agents include the memory file.
+    assert "Project memory (context.md)" in cli._system_prompt_with_memory() and "SQLite chosen" in cli._system_prompt_with_memory()
+
+
+@pytest.mark.asyncio
+async def test_memory_update_rejects_invalid_model_output(cli, monkeypatch):
+    cli._memory().init()
+    before = cli._memory().read()
+    cli.current_agent = FakeAgent("Sure! Here is a summary instead of a file.")
+    assert await cli._memory_update() is False and cli._memory().read() == before
+
+
+@pytest.mark.asyncio
+async def test_memory_commands_show_init_vault_link(cli, monkeypatch, tmp_path):
+    await cli.cmd_memory("show")
+    await cli.cmd_memory("init", "Developer Tools")
+    assert cli._memory().frontmatter()["area"] == "Developer Tools"
+    await cli.cmd_memory("vault", str(tmp_path / "other-brain"))
+    assert cli.config.memory.vault == str((tmp_path / "other-brain").resolve())
+    assert (tmp_path / "other-brain" / "Projects.md").is_file()
+    cli._memory_link()
+    assert "context.md" in (tmp_path / "proj" / "AGENTS.md").read_text() and "context.md" in (tmp_path / "proj" / "CLAUDE.md").read_text()
+    cli._memory_link()  # idempotent
+    assert (tmp_path / "proj" / "AGENTS.md").read_text().count("context.md") == 1
+
+
+@pytest.mark.asyncio
+async def test_onboarding_offers_detected_vault_and_saves_choice(cli, monkeypatch, tmp_path):
+    cli.config.memory.onboarded = False
+    cli.config.memory.vault = ""
+    existing = tmp_path / "ObsidianVault"
+    existing.mkdir()
+    monkeypatch.setattr("thwip.cli.detect_obsidian_vaults", lambda: [str(existing)])
+    monkeypatch.setattr("thwip.cli.sys.stdin.isatty", lambda: True)
+    from pathlib import Path
+    monkeypatch.setattr(Path, "home", classmethod(lambda cls: tmp_path / "home"))
+
+    async def choose_first(question):
+        return "1"
+    monkeypatch.setattr(cli, "_ask_text", choose_first)
+    await cli._memory_onboarding()
+    assert cli.config.memory.vault == str(existing) and cli.config.memory.onboarded
+    # Second start: no question asked again.
+    async def boom(question):
+        raise AssertionError("should not ask again")
+    monkeypatch.setattr(cli, "_ask_text", boom)
+    await cli._memory_onboarding()
+    # Skip choice leaves memory enabled but no vault.
+    cli.config.memory.onboarded = False
+    async def skip(question):
+        return "3"
+    monkeypatch.setattr(cli, "_ask_text", skip)
+    await cli._memory_onboarding()
+    assert cli.config.memory.vault == "" and cli.config.memory.onboarded
+    # Creating the default new vault lands under the (patched) home directory.
+    cli.config.memory.onboarded = False
+    async def create(question):
+        return "2"
+    monkeypatch.setattr(cli, "_ask_text", create)
+    await cli._memory_onboarding()
+    assert cli.config.memory.vault == str(tmp_path / "home" / "thwip-brain") and (tmp_path / "home" / "thwip-brain" / "Projects").is_dir()
+
+
+@pytest.mark.asyncio
+async def test_quit_offer_only_with_real_conversation(cli, monkeypatch):
+    asked = []
+    async def ask(question):
+        asked.append(question)
+        return "n"
+    monkeypatch.setattr(cli, "_ask_text", ask)
+    monkeypatch.setattr("thwip.cli.sys.stdin.isatty", lambda: True)
+    cli.current_agent = FakeAgent("x")
+    await cli._offer_memory_update("quitting")
+    assert len(asked) == 1 and "before quitting" in asked[0]
+    cli.session.clear_context()
+    await cli._offer_memory_update("quitting")
+    assert len(asked) == 1

{thwip_cli-1.6.2 → thwip_cli-1.8.0}/tests/test_native_agents.py

@@ -1,6 +1,7 @@
 """Native protocol behavior without credentials or model requests."""
 
 import asyncio
+from types import SimpleNamespace
 
 import pytest
 
@@ -16,6 +17,8 @@ class FakeRPC:
         self.closed = False
         self.provider = provider
         self.failure = failure
+        self.process = SimpleNamespace(returncode=None)  # looks alive, like a running app-server
+        self.resume_fails = False
 
     async def request(self, method, params, **kwargs):
         self.requests.append((method, params))
@@ -28,6 +31,10 @@ class FakeRPC:
                     'availableModels': [{'modelId': 'future-model', 'name': 'Future'}]}}
         if method == 'thread/start':
             return {'thread': {'id': 't'}}
+        if method == 'thread/resume':
+            if self.resume_fails:
+                raise RuntimeError('Native CLI rejected thread/resume (code -32600): unknown thread')
+            return {'thread': {'id': params['threadId']}}
         if method == 'turn/start':
             await self.events.put({'id': 99, 'method': 'item/commandExecution/requestApproval',
                                    'params': {'command': 'touch example'}})
@@ -52,6 +59,7 @@ class FakeRPC:
 
     async def close(self):
         self.closed = True
+        self.process = SimpleNamespace(returncode=0)
 
 
 @pytest.mark.asyncio
@@ -88,9 +96,11 @@ async def test_native_permission_response_and_completion(provider, approve, monk
         if isinstance(event, NativePermission):
             event.approved = approve
     assert any(isinstance(event, TextDelta) and event.content == 'done' for event in events)
-    assert isinstance(events[-1], AgentDone)
+    assert isinstance(events[-1], AgentDone) and events[-1].native_session == {'id': 't'}
     response = rpc.sent[0]['result']
     assert response['decision'] == ('accept' if approve else 'decline')
+    assert not rpc.closed, 'the app-server stays alive between turns'
+    await agent.close()
     assert rpc.closed
 
 
@@ -150,6 +160,7 @@ async def test_codex_usage_limit_failure_becomes_limit_hit(monkeypatch):
     monkeypatch.setattr(agent, '_connect', connect)
     events = [event async for event in agent.chat([{'role': 'user', 'content': 'hi'}], model='future-model')]
     assert isinstance(events[-1], LimitHit) and events[-1].error_type == LimitStatus.QUOTA_EXHAUSTED
+    await agent.close()
     assert rpc.closed
 
 
@@ -198,3 +209,64 @@ async def test_codex_rate_limit_notification_is_recorded(monkeypatch):
     assert agent.limit_windows == [
         {'label': '5h', 'used_percent': 2, 'resets_at': 1790212672},
         {'label': '7d', 'used_percent': 23, 'resets_at': None}]
+
+
+def _turn_prompt(rpc):
+    return next(params for method, params in rpc.requests if method == 'turn/start')['input'][0]['text']
+
+
+@pytest.mark.asyncio
+async def test_codex_resumes_thread_and_sends_only_new_messages(monkeypatch):
+    agent = NativeAgent('openai', '.')
+    rpc = FakeRPC('openai')
+    async def connect():
+        return rpc
+    monkeypatch.setattr(agent, '_connect', connect)
+    history = [{'role': 'user', 'content': 'first'}, {'role': 'assistant', 'content': 'one'},
+               {'role': 'user', 'content': 'second'}]
+    events = [e async for e in agent.chat(history, model='future-model', resume={'id': 'thread-9', 'synced': 2})]
+    assert isinstance(events[-1], AgentDone) and events[-1].native_session == {'id': 'thread-9'}
+    methods = [m for m, _ in rpc.requests]
+    assert 'thread/resume' in methods and 'thread/start' not in methods
+    assert _turn_prompt(rpc) == 'second', 'only the new message is sent to a resumed thread'
+    # Same process, same thread: no second resume request.
+    rpc.requests.clear()
+    history += [{'role': 'assistant', 'content': 'two'}, {'role': 'user', 'content': 'third'}]
+    [e async for e in agent.chat(history, model='future-model', resume={'id': 'thread-9', 'synced': 4})]
+    assert 'thread/resume' not in [m for m, _ in rpc.requests] and _turn_prompt(rpc) == 'third'
+
+
+@pytest.mark.asyncio
+async def test_codex_catch_up_block_after_other_providers_answered(monkeypatch):
+    agent = NativeAgent('openai', '.')
+    rpc = FakeRPC('openai')
+    async def connect():
+        return rpc
+    monkeypatch.setattr(agent, '_connect', connect)
+    history = [{'role': 'user', 'content': 'a'}, {'role': 'assistant', 'content': 'b'},
+               {'role': 'user', 'content': 'c'}, {'role': 'assistant', 'content': 'd by claude'},
+               {'role': 'user', 'content': 'e'}]
+    [e async for e in agent.chat(history, model='future-model', resume={'id': 'thread-9', 'synced': 2})]
+    prompt = _turn_prompt(rpc)
+    assert 'Missed conversation' in prompt and 'd by claude' in prompt and prompt.endswith('Final user message:\ne')
+    assert '[User]\na' not in prompt, 'messages the thread already saw are not resent'
+
+
+@pytest.mark.asyncio
+async def test_codex_falls_back_to_new_thread_when_resume_fails(monkeypatch):
+    from thwip.agents.base import NativeActivity
+
+    agent = NativeAgent('openai', '.')
+    rpc = FakeRPC('openai')
+    rpc.resume_fails = True
+    async def connect():
+        return rpc
+    monkeypatch.setattr(agent, '_connect', connect)
+    history = [{'role': 'user', 'content': 'first'}, {'role': 'assistant', 'content': 'one'},
+               {'role': 'user', 'content': 'second'}]
+    events = [e async for e in agent.chat(history, model='future-model', resume={'id': 'gone', 'synced': 2})]
+    assert any(isinstance(e, NativeActivity) and 'unavailable' in e.description for e in events)
+    start = next(params for method, params in rpc.requests if method == 'thread/start')
+    assert start['ephemeral'] is False
+    assert '[User]\nfirst' in _turn_prompt(rpc), 'full transcript goes to the new thread'
+    assert events[-1].native_session == {'id': 't'}

{thwip_cli-1.6.2 → thwip_cli-1.8.0}/tests/test_native_print.py

@@ -233,3 +233,53 @@ async def test_antigravity_network_reset_gets_a_network_hint(monkeypatch):
         "API error (attempt 1): request failed: Post \"https://example.googleapis.com\": read tcp 10.0.0.2:5->1.2.3.4:443: read: connection reset by peer"}}])
     with pytest.raises(RuntimeError, match="connection reset by peer.*network or a firewall"):
         await collect(agent, model="gemini-3.8-flash-high")
+
+
+@pytest.mark.asyncio
+async def test_claude_new_session_id_then_resume_flag(monkeypatch):
+    agent = PrintAgent("claude", ".")
+    calls = install_fake(monkeypatch, agent, [{"type": "system", "subtype": "init", "session_id": "abc-123"},
+                                              {"type": "result", "subtype": "success", "result": "hi", "usage": {}}])
+    events = await collect(agent)
+    assert events[-1].native_session == {"id": "abc-123"}
+    command, stdin_text = calls[0]
+    assert "--session-id" in command and "--resume" not in command and "--append-system-prompt" in command
+    assert stdin_text == "hello"
+    # Resume: only the new message, no system prompt re-sent, --resume flag used.
+    calls.clear()
+    history = [{"role": "user", "content": "hello"}, {"role": "assistant", "content": "hi"}, {"role": "user", "content": "next"}]
+    events = [e async for e in agent.chat(history, model="fable", system_prompt="Be brief.", resume={"id": "abc-123", "synced": 2})]
+    command, stdin_text = calls[0]
+    assert command[command.index("--resume") + 1] == "abc-123" and "--append-system-prompt" not in command
+    assert stdin_text == "next" and events[-1].native_session == {"id": "abc-123"}
+
+
+@pytest.mark.asyncio
+async def test_antigravity_conversation_resume_and_fallback(monkeypatch):
+    agent = PrintAgent("google", ".")
+    ok = [{"event": "init", "conversation_id": "conv-1", "init": {}},
+          {"event": "result", "result": {"status": "SUCCESS", "response": "hi", "usage": {}}}]
+    calls = install_fake(monkeypatch, agent, ok)
+    events = await collect(agent, model="gemini-3.8-flash-high")
+    assert events[-1].native_session == {"id": "conv-1"} and "--conversation" not in calls[0][0]
+
+    # Resumed turn passes --conversation and only the new text.
+    calls.clear()
+    history = [{"role": "user", "content": "hello"}, {"role": "assistant", "content": "hi"}, {"role": "user", "content": "next"}]
+    events = [e async for e in agent.chat(history, model="gemini-3.8-flash-high", resume={"id": "conv-1", "synced": 2})]
+    command = calls[0][0]
+    assert command[command.index("--conversation") + 1] == "conv-1" and command[command.index("--print") + 1] == "next"
+
+    # If the resumed process fails, a fresh conversation gets the full transcript.
+    attempts = []
+    async def start(command, stdin_text=None):
+        attempts.append(command)
+        if "--conversation" in command:
+            return FakeProcess([{"event": "result", "result": {"status": "ERROR", "error": "conversation not found"}}])
+        return FakeProcess(ok)
+    monkeypatch.setattr(agent, "_start_process", start)
+    events = [e async for e in agent.chat(history, model="gemini-3.8-flash-high", resume={"id": "conv-1", "synced": 2})]
+    assert len(attempts) == 2 and "--conversation" not in attempts[1]
+    assert "[User]\nhello" in attempts[1][attempts[1].index("--print") + 1]
+    assert any(isinstance(e, NativeActivity) and "unavailable" in e.description for e in events)
+    assert events[-1].native_session == {"id": "conv-1"}

{thwip_cli-1.6.2 → thwip_cli-1.8.0}/tests/test_parity_commands.py

@@ -171,3 +171,30 @@ def test_mentions_attach_project_files_only(cli, tmp_path):
     assert "secret plan" in expanded and "[Attached file: notes.md]" in expanded
     assert "missing.txt]" not in expanded and "passwd]" not in expanded
     assert cli._expand_mentions("email me at user@example.com") == "email me at user@example.com"
+
+
+def test_incremental_prompt_builder():
+    from thwip.agents.native_common import build_incremental_prompt
+
+    history = [{"role": "user", "content": "a"}, {"role": "assistant", "content": "b"}, {"role": "user", "content": "c"}]
+    full, is_full = build_incremental_prompt(history, "sys", 0)
+    assert is_full and "[User]\na" in full and full.endswith("c")
+    only_new, is_full = build_incremental_prompt(history, "sys", 2)
+    assert (only_new, is_full) == ("c", False)
+    _bad, is_full = build_incremental_prompt(history, None, 7)
+    assert is_full, "a synced count beyond the history falls back to the full transcript"
+
+
+def test_man_page_commands(tmp_path, monkeypatch, capsys):
+    from thwip import cli as cli_module
+
+    monkeypatch.setenv("THWIP_MAN_DIR", str(tmp_path / "man1"))
+    assert cli_module.MAN_PAGE.is_file() and cli_module.MAN_PAGE.read_text().startswith(".TH THWIP 1")
+    assert cli_module.run_man_command("install-man") == 0
+    assert (tmp_path / "man1" / "thwip.1").read_text() == cli_module.MAN_PAGE.read_text()
+    monkeypatch.setattr("thwip.cli.shutil.which", lambda name: None)
+    assert cli_module.run_man_command("man") == 0
+    assert "universal coding agent multiplexer" in capsys.readouterr().out
+    with pytest.raises(SystemExit) as info:
+        cli_module.main(["install-man"])
+    assert info.value.code == 0

{thwip_cli-1.6.2 → thwip_cli-1.8.0}/tests/test_session.py

@@ -128,3 +128,24 @@ def test_config_file_permissions_and_source_are_preserved(tmp_path, monkeypatch)
 
     assert loaded.key_sources["openai"] == "config.toml"
     assert get_config_path().stat().st_mode & 0o777 == 0o600
+
+
+def test_native_sessions_are_tracked_validated_and_persisted(tmp_path, monkeypatch):
+    from thwip.session import Session
+
+    monkeypatch.setenv("THWIP_CONFIG_DIR", str(tmp_path))
+    session = Session(project_path=str(tmp_path), current_agent="openai", current_model="m")
+    assert session.native_session("openai") is None
+    session.add_user_message("q")
+    session.add_assistant_message("a", agent_name="openai", model="m")
+    session.set_native_session("openai", "thread-1", "m")
+    assert session.native_session("openai") == {"id": "thread-1", "synced": 2, "model": "m"}
+    session.native_sessions["claude"] = {"id": "x", "synced": 99}
+    assert session.native_session("claude") is None, "a record that claims more messages than exist is ignored"
+    path = session.save("native-track")
+    loaded = Session.load("native-track")
+    assert loaded.native_session("openai") == {"id": "thread-1", "synced": 2, "model": "m"}
+    loaded.clear_context()
+    assert loaded.native_sessions == {}
+    path.write_text(path.read_text().replace('"synced": 2', '"synced": "2"'))
+    assert Session.load("native-track") is None, "malformed native session records reject the file"

{thwip_cli-1.6.2 → thwip_cli-1.8.0}/thwip/__init__.py

@@ -1,4 +1,4 @@
 """thwip: Universal Coding Agent Multiplexer."""
 
-__version__ = "1.6.2"
+__version__ = "1.8.0"
 __app_name__ = "thwip"

{thwip_cli-1.6.2 → thwip_cli-1.8.0}/thwip/agents/base.py

@@ -144,6 +144,8 @@ class AgentDone:
     usage: TokenUsage = field(default_factory=TokenUsage)
     stop_reason: str = "end_turn"
     native_state: dict[str, Any] = field(default_factory=dict)
+    # Identifier of the native CLI session that produced this turn, so it can be resumed next time.
+    native_session: dict[str, Any] = field(default_factory=dict)
 
 
 @dataclass