tamfis-code 0.7.0__tar.gz → 1.3.0__tar.gz

{tamfis_code-0.7.0 → tamfis_code-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tamfis-code
-Version: 0.7.0
+Version: 1.3.0
 Summary: TamfisGPT Code -- portable subscription-backed terminal coding agent with local tools, PTY, plans, queues, and approvals
 Project-URL: Homepage, https://github.com/tamfitronics/tamfis-code
 Project-URL: Repository, https://github.com/tamfitronics/tamfis-code

{tamfis_code-0.7.0 → tamfis_code-1.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tamfis-code"
-version = "0.7.0"
+version = "1.3.0"
 description = "TamfisGPT Code -- portable subscription-backed terminal coding agent with local tools, PTY, plans, queues, and approvals"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -10,7 +10,7 @@ dependencies = [
     "rich>=13.0",
     "prompt_toolkit>=3.0",
     # Provider calls (providers.py) go through the openai SDK's client against
-    # each vendor's OpenAI-compatible endpoint (HF, NVIDIA NIM, OpenRouter)
+    # each provider's OpenAI-compatible endpoint (Ollama Cloud, NVIDIA NIM, HF, OpenRouter)
     # -- this was imported but never declared, only working because a
     # copy happened to already be installed system-wide.
     "openai>=1.30",

tamfis_code-1.3.0/setup.py

@@ -0,0 +1,2 @@
+from setuptools import setup
+setup()

{tamfis_code-0.7.0 → tamfis_code-1.3.0}/tamfis_code/__init__.py

@@ -9,7 +9,7 @@ from __future__ import annotations
 from importlib import import_module
 from typing import Any
 
-__version__ = "0.7.0"
+__version__ = "1.3.0"
 MIN_COMPATIBLE_API_VERSION = "remote-ai-v2"
 
 _LAZY_EXPORTS: dict[str, tuple[str, str]] = {

{tamfis_code-0.7.0 → tamfis_code-1.3.0}/tamfis_code/cli.py

@@ -36,6 +36,8 @@ from .api_client import (
 )
 from .config import APPROVAL_MODES, CONFIG_DIR, Config, Credentials, load_config
 from .doctor import run_doctor
+from .runtime.memory import MemoryRecord, MemoryType, get_memory_store
+from .runtime.worktree import WorktreeError, create_worktree, list_worktrees, remove_worktree
 from .render import StreamRenderer, print_banner, print_error, print_recent_thread, print_resume_plan_status, print_unified_diff
 from .runner import (
     ACTIVE_TASK_STATUSES,
@@ -53,7 +55,7 @@ from .local_chat import _PROVIDER_ALIASES
 # validation and then failed with "Unknown local provider" inside
 # resolve_provider_type every time.
 _PROVIDER_CHOICES = sorted(_PROVIDER_ALIASES.keys())
-_PROVIDER_HELP = "tamfis/tamfisgpt (subscription API), hf, nvidia, openrouter, or auto (default)."
+_PROVIDER_HELP = "tamfis/tamfisgpt (subscription API), ollama_cloud, nvidia, hf, openrouter, or auto (default)."
 
 EXIT_OK = 0
 EXIT_TASK_FAILED = 1
@@ -100,7 +102,7 @@ def async_command(fn):
 @click.option("--approval", "approval_policy", type=click.Choice(APPROVAL_MODES), default=None, help="Override the configured approval policy for this invocation. Note: 'never' means deny everything outright -- the opposite of 'auto'/'full-auto' (which mean never PROMPT, i.e. auto-approve). It is not a synonym for auto-approve.")
 @click.option("--api-base", "api_base", default=None, help="Override the configured Remote API base URL.")
 @click.option("--cwd", "cwd_override", type=click.Path(exists=True, file_okay=False), default=None, help="Treat this directory as the workspace instead of the current directory.")
-@click.option("--provider", default="auto", help="hf, nvidia, openrouter, or auto (default) -- which provider the bare (no-subcommand) interactive REPL calls directly.")
+@click.option("--provider", default="auto", help="ollama_cloud, nvidia, hf, openrouter, or auto (default) -- which provider the bare (no-subcommand) interactive REPL calls directly.")
 @click.option("--model", default=None, help="Provider-specific model id for the bare interactive REPL; defaults to that provider's default model.")
 @click.option("--remote", is_flag=True, default=False, help="Use the legacy TamfisGPT Remote Workspace backend for the bare interactive REPL instead of calling a provider directly.")
 @click.version_option(__version__, prog_name="tamfis-code")
@@ -343,6 +345,125 @@ def workspace_remove(ctx: click.Context, path: Path):
     console.print(f"[green]Workspace removed:[/green] {target}")
 
 
+@cli.group(name="memory")
+def memory_group():
+    """Manage durable, cross-session memory records."""
+
+
+@memory_group.command(name="list")
+@click.option("--type", "memory_type", type=click.Choice([t.value for t in MemoryType]), default=None)
+def memory_list(memory_type: Optional[str]):
+    console = Console()
+    store = get_memory_store()
+    records = store.list(MemoryType(memory_type) if memory_type else None)
+    if not records:
+        console.print("[dim]No memory records.[/dim]")
+        return
+    table = Table(show_header=True, header_style="bold")
+    table.add_column("name")
+    table.add_column("type")
+    table.add_column("description")
+    for record in records:
+        table.add_row(record.name, record.type.value, record.description)
+    console.print(table)
+
+
+@memory_group.command(name="show")
+@click.argument("name")
+def memory_show(name: str):
+    console = Console()
+    record = get_memory_store().load(name)
+    if record is None:
+        print_error(console, f"No memory record named {name!r}.")
+        raise SystemExit(EXIT_TASK_FAILED)
+    console.print(f"[bold]{record.name}[/bold] ({record.type.value})")
+    console.print(record.description)
+    console.print()
+    console.print(record.content)
+
+
+@memory_group.command(name="add")
+@click.argument("name")
+@click.option("--type", "memory_type", type=click.Choice([t.value for t in MemoryType]), required=True)
+@click.option("--description", required=True)
+@click.option("--content", required=True)
+def memory_add(name: str, memory_type: str, description: str, content: str):
+    console = Console()
+    record = get_memory_store().save(
+        MemoryRecord(name=name, type=MemoryType(memory_type), description=description, content=content)
+    )
+    console.print(f"[green]Saved memory record:[/green] {record.name}")
+
+
+@memory_group.command(name="forget")
+@click.argument("name")
+def memory_forget(name: str):
+    console = Console()
+    if get_memory_store().delete(name):
+        console.print(f"[green]Forgot memory record:[/green] {name}")
+    else:
+        print_error(console, f"No memory record named {name!r}.")
+        raise SystemExit(EXIT_TASK_FAILED)
+
+
+@cli.group(name="worktree")
+def worktree_group():
+    """Manage isolated git worktrees for background/parallel execution."""
+
+
+@worktree_group.command(name="list")
+@click.pass_context
+def worktree_list_cmd(ctx: click.Context):
+    console = Console(no_color=not ctx.obj["config"].colour)
+    try:
+        handles = list_worktrees(ctx.obj["workspace_root"])
+    except WorktreeError as exc:
+        print_error(console, str(exc))
+        raise SystemExit(EXIT_TASK_FAILED)
+    if not handles:
+        console.print("[dim]No worktrees.[/dim]")
+        return
+    table = Table(show_header=True, header_style="bold")
+    table.add_column("branch")
+    table.add_column("path")
+    for handle in handles:
+        table.add_row(handle.branch, str(handle.path))
+    console.print(table)
+
+
+@worktree_group.command(name="create")
+@click.argument("branch")
+@click.option("--base", default="HEAD", help="Ref the new worktree branch is created from.")
+@click.pass_context
+def worktree_create_cmd(ctx: click.Context, branch: str, base: str):
+    console = Console(no_color=not ctx.obj["config"].colour)
+    try:
+        handle = create_worktree(ctx.obj["workspace_root"], branch=branch, base=base)
+    except WorktreeError as exc:
+        print_error(console, str(exc))
+        raise SystemExit(EXIT_TASK_FAILED)
+    console.print(f"[green]Worktree created:[/green] {handle.path} (branch {handle.branch})")
+
+
+@worktree_group.command(name="remove")
+@click.argument("branch")
+@click.option("--force", is_flag=True, default=False, help="Remove even if the worktree has uncommitted changes.")
+@click.pass_context
+def worktree_remove_cmd(ctx: click.Context, branch: str, force: bool):
+    console = Console(no_color=not ctx.obj["config"].colour)
+    try:
+        handles = {h.branch: h for h in list_worktrees(ctx.obj["workspace_root"])}
+        handle = handles.get(branch)
+        if handle is None:
+            print_error(console, f"No worktree found for branch {branch!r}.")
+            raise SystemExit(EXIT_TASK_FAILED)
+        remove_worktree(handle, force=force)
+    except WorktreeError as exc:
+        print_error(console, str(exc))
+        raise SystemExit(EXIT_TASK_FAILED)
+    console.print(f"[green]Worktree removed:[/green] {branch}")
+
+
 @cli.command(name="cwd")
 @click.argument("path", required=False, type=click.Path(exists=True, file_okay=False, path_type=Path))
 @click.option("--remote", is_flag=True, default=False, help="Update the working directory on the legacy TamfisGPT Remote Workspace backend instead of the local session.")
@@ -422,7 +543,7 @@ async def init(ctx: click.Context, remote: bool):
 
 
 @cli.command()
-@click.option("--provider", default="auto", help="hf, nvidia, openrouter, or auto (default).")
+@click.option("--provider", default="auto", help="ollama_cloud, nvidia, hf, openrouter, or auto (default).")
 @click.option("--remote", is_flag=True, default=False, help="Check the legacy TamfisGPT Remote Workspace backend instead of local provider connectivity.")
 @click.pass_context
 @async_command
@@ -1359,7 +1480,7 @@ async def run(ctx: click.Context, command: str, background: bool, remote: bool):
 
 @cli.command()
 @click.argument("session_id", type=int, required=False, default=None)
-@click.option("--provider", default="auto", help="hf, nvidia, openrouter, or auto (default).")
+@click.option("--provider", default="auto", help="ollama_cloud, nvidia, hf, openrouter, or auto (default).")
 @click.option("--model", default=None, help="Provider-specific model id; defaults to that provider's default model.")
 @click.option("--remote", is_flag=True, default=False, help="Resume a session on the legacy TamfisGPT Remote Workspace backend instead of a local one.")
 @click.pass_context
@@ -1426,7 +1547,7 @@ async def resume(ctx: click.Context, session_id: Optional[int], provider: str, m
 
 @cli.command()
 @click.argument("task_id", required=False, default=None)
-@click.option("--provider", default="auto", help="hf, nvidia, openrouter, or auto (default).")
+@click.option("--provider", default="auto", help="ollama_cloud, nvidia, hf, openrouter, or auto (default).")
 @click.option("--model", default=None, help="Provider-specific model id; defaults to that provider's default model.")
 @click.option("--remote", is_flag=True, default=False, help="Retry a task on the legacy TamfisGPT Remote Workspace backend instead of resending locally.")
 @click.pass_context
@@ -1948,7 +2069,7 @@ def completion_cmd(shell: str):
 @click.option('--task', '-t', 'tasks', multiple=True, help='Task description (repeatable for delegate)')
 @click.option('--file', '-f', help='File to operate on')
 @click.option('--max-concurrency', default=1, show_default=True, help='Max concurrent delegated sub-tasks')
-@click.option('--provider', default="auto", help="hf, nvidia, openrouter, or auto (default).")
+@click.option('--provider', default="auto", help="ollama_cloud, nvidia, hf, openrouter, or auto (default).")
 @click.option('--model', default=None, help="Provider-specific model id; defaults to that provider's default model.")
 @click.pass_context
 def agent_cmd(ctx: click.Context, action: str, tasks: tuple[str, ...], file: str, max_concurrency: int, provider: str, model: Optional[str]):
@@ -2189,7 +2310,7 @@ def providers_command(ctx: click.Context):
 
 @cli.command('local')
 @click.argument('objective', required=False)
-@click.option('--provider', default="auto", help="hf, nvidia, openrouter, or auto (default).")
+@click.option('--provider', default="auto", help="ollama_cloud, nvidia, hf, openrouter, or auto (default).")
 @click.option('--model', default=None, help="Provider-specific model id; defaults to that provider's default model.")
 @click.option('--no-tools', 'no_tools', is_flag=True, default=False, help="Disable read-only repo tools (read_file/list_directory/search_code/get_git_info) for this turn.")
 @click.option('--agent', 'full_agent', is_flag=True, default=False, help="Full read/write/execute tool access (write_file/edit_file/execute_command) via the local risk/approval/mutation-ledger layer, instead of read-only Q&A. Standalone -- no TamfisGPT backend involved.")
@@ -2382,6 +2503,34 @@ from .enforcer import TestEnforcer, run_enforcer, add_enforcer_command
 # TestEnforcer -- using those flags raised AttributeError at runtime.
 add_enforcer_command(cli)
 
+@cli.command("verify-release")
+@click.option("--artifact", "artifacts", multiple=True, type=click.Path(exists=True, dir_okay=False, path_type=Path), help="Built wheel, source archive, checksum, or manifest to verify.")
+@click.option("--output-dir", type=click.Path(file_okay=False, path_type=Path), default=None, help="Directory for JSON and Markdown verification reports.")
+@click.pass_context
+def verify_release_command(ctx: click.Context, artifacts: tuple[Path, ...], output_dir: Optional[Path]):
+    """Run the Phase 4 release gate without contacting any AI provider."""
+    from .release_verification import run_release_verification
+
+    root: Path = ctx.obj["workspace_root"]
+    report = run_release_verification(root, artifacts)
+    console = Console(no_color=not ctx.obj["config"].colour)
+    table = Table(show_header=True, header_style="bold")
+    table.add_column("Category")
+    table.add_column("Check")
+    table.add_column("Result")
+    table.add_column("Detail")
+    for check in report.checks:
+        table.add_row(check.category, check.name, "PASS" if check.passed else "FAIL", check.detail)
+    console.print(table)
+
+    destination = output_dir or (root / "dist")
+    json_path = report.write_json(destination / f"tamfis_code-{report.version}-verification-report.json")
+    md_path = report.write_markdown(destination / f"tamfis_code-{report.version}-verification-report.md")
+    console.print(f"Verification reports: {json_path}  {md_path}")
+    if not report.passed:
+        raise SystemExit(EXIT_TASK_FAILED)
+
+
 # Familiar GitHub CLI command surface, delegated to the installed `gh` binary.
 from .github_commands import register_github_commands
 register_github_commands(cli)

{tamfis_code-0.7.0 → tamfis_code-1.3.0}/tamfis_code/doctor.py

@@ -21,6 +21,7 @@ from .api_client import AuthRequiredError, RemoteAPIClient, RemoteAPIError
 from .config import Config, load_credentials
 from .providers import get_provider_status
 from .workspace import resolve_local_workspace
+from .runtime.journal import JOURNAL_PATH, recent_failures
 
 
 @dataclass
@@ -190,6 +191,20 @@ def _diagnose_local_session(workspace_root: Path) -> list[CheckResult]:
         summary = ", ".join(f"{count} {name}" for name, count in sorted(by_status.items())) or "no steps"
         results.append(CheckResult("Active plan step progress", "PASS", summary))
 
+    failures = recent_failures(5)
+    if failures:
+        latest = failures[0]
+        detail = (
+            f"{len(failures)} recent failed/cancelled execution(s); latest "
+            f"{latest.get('mode', 'unknown')} at {latest.get('timestamp', 'unknown')}: "
+            f"{latest.get('error') or latest.get('status') or 'unknown failure'}"
+        )
+        results.append(CheckResult("Unified runtime recent failures", "WARNING", detail))
+    elif JOURNAL_PATH.exists():
+        results.append(CheckResult("Unified runtime recent failures", "PASS", "none in the recent execution journal"))
+    else:
+        results.append(CheckResult("Unified runtime execution journal", "WARNING", "no unified runtime executions recorded yet"))
+
     return results
 
 

{tamfis_code-0.7.0 → tamfis_code-1.3.0}/tamfis_code/interactive.py

@@ -107,7 +107,7 @@ async def _run_cancellable_local_turn(
             error="Task cancelled by user.",
         )
     finally:
-        live_input.stop()
+        await live_input.stop()
 
 
 HELP_TEXT = """\
@@ -589,8 +589,41 @@ async def run_interactive(
                 break
             except EOFError:
                 break
+            resolved_paste_count = 0
+            resolved_paste_chars = 0
+            resolved_paste_lines = 0
+
             for placeholder, real_text in pending_pastes.items():
+                if placeholder not in text:
+                    continue
+
                 text = text.replace(placeholder, real_text)
+                resolved_paste_count += 1
+                resolved_paste_chars += len(real_text)
+                resolved_paste_lines += real_text.count("\n") + (
+                    0 if real_text.endswith("\n") else 1
+                )
+
+            unresolved_pastes = re.findall(
+                r"\[Pasted text #\d+ \+\d+ lines\]",
+                text,
+            )
+            if unresolved_pastes:
+                print_error(
+                    console,
+                    "Pasted-text resolution failed. The underlying paste was "
+                    "not available, so no task was submitted. Unresolved: "
+                    + ", ".join(unresolved_pastes),
+                )
+                continue
+
+            if resolved_paste_count:
+                console.print(
+                    "[dim]diagnostics: Resolved "
+                    f"{resolved_paste_count} pasted-text block(s), "
+                    f"{resolved_paste_lines:,} line(s), "
+                    f"{resolved_paste_chars:,} character(s).[/dim]"
+                )
 
         text = text.strip()
         if not text:

{tamfis_code-0.7.0 → tamfis_code-1.3.0}/tamfis_code/live_input.py

@@ -61,21 +61,29 @@ class LiveInputListener:
         self._active = True
         self._schedule_prompt()
 
-    def stop(self) -> None:
+    async def stop(self) -> None:
+        """Stop input ownership and wait until prompt-toolkit releases stdin."""
         self._active = False
-        self._cancel_prompt()
+        await self._shutdown_prompt()
         if self.renderer.live_input_listener is self:
             self.renderer.live_input_listener = None
-            self.renderer.resume_live()
+        self.renderer.resume_live()
 
     def pause(self) -> None:
+        """Synchronously request prompt shutdown before another UI reads stdin."""
         self._paused = True
+        self._request_prompt_exit()
         self._cancel_prompt()
 
     def resume(self) -> None:
         self._paused = False
-        if self._active:
-            self._schedule_prompt()
+        if not self._active:
+            return
+        task = self._input_task
+        if task is not None and not task.done():
+            task.add_done_callback(lambda _task: self._schedule_prompt() if self._active and not self._paused else None)
+            return
+        self._schedule_prompt()
 
     def _dispatch(self) -> None:
         """Compatibility hook for older embedders; start() no longer uses it."""
@@ -102,11 +110,28 @@ class LiveInputListener:
         if self._input_task is None or self._input_task.done():
             self._input_task = asyncio.create_task(self._input_loop())
 
+    def _request_prompt_exit(self) -> None:
+        session = self._prompt_session
+        app = getattr(session, "app", None)
+        if app is not None and not getattr(app, "is_done", False):
+            with contextlib.suppress(Exception):
+                app.exit(result="")
+
     def _cancel_prompt(self) -> None:
+        task = self._input_task
+        if task is not None and not task.done():
+            task.cancel()
+
+    async def _shutdown_prompt(self) -> None:
+        self._request_prompt_exit()
         task = self._input_task
         self._input_task = None
         if task is not None and not task.done():
             task.cancel()
+        if task is not None:
+            with contextlib.suppress(asyncio.CancelledError, Exception):
+                await task
+        self._prompt_session = None
 
     def invalidate(self) -> None:
         """Refresh the prompt footer after a streamed phase/status update."""
@@ -157,40 +182,32 @@ class LiveInputListener:
 
         session = PromptSession(key_bindings=bindings)
         self._prompt_session = session
-        while self._active and not self._paused:
-            try:
-                # patch_stdout keeps concurrent tool/assistant output above
-                # the current line and redraws the line beneath it.
-                with patch_stdout(raw=True):
-                    text = await session.prompt_async(
-                        "message> ", bottom_toolbar=self._bottom_toolbar,
-                    )
-            except asyncio.CancelledError:
-                return
-            except KeyboardInterrupt:
-                # Ctrl+C is the process/REPL exit affordance. The active
-                # runner's signal path remains reserved for true process
-                # interrupts; queue an explicit exit so the local runner
-                # can finish its current safe boundary and the REPL exits.
-                self._enqueue_control("exit")
-                return
-            except EOFError:
-                return
-
-            # Escape sets _paused before exiting the prompt, so its empty
-            # result must not be queued or cause another editor to start.
-            if self._paused:
-                break
-
-            # A genuine line already returned by prompt_async remains valid
-            # even when the listener was deactivated during that prompt.
-            # Queue it first, then let the loop terminate cleanly.
-            self._enqueue(text)
-
-            if not self._active:
-                break
-
-        self._prompt_session = None
+        try:
+            while self._active and not self._paused:
+                try:
+                    with patch_stdout(raw=True):
+                        text = await session.prompt_async(
+                            "message> ", bottom_toolbar=self._bottom_toolbar,
+                        )
+                except asyncio.CancelledError:
+                    raise
+                except KeyboardInterrupt:
+                    self._request_interrupt("cancel")
+                    return
+                except EOFError:
+                    return
+
+                if self._paused:
+                    break
+                self._enqueue(text)
+                if not self._active:
+                    break
+        finally:
+            if self._prompt_session is session:
+                self._prompt_session = None
+            current = asyncio.current_task()
+            if self._input_task is current:
+                self._input_task = None
 
     @property
     def interrupt_classification(self) -> Optional[str]:

{tamfis_code-0.7.0 → tamfis_code-1.3.0}/tamfis_code/local_chat.py

@@ -38,7 +38,7 @@ def resolve_provider_type(name: Optional[str]) -> ProviderType:
     return _PROVIDER_ALIASES[key]
 
 
-async def run_local_turn(
+async def _run_local_turn_impl(
     manager: ProviderManager,
     provider: ProviderType,
     messages: List[Dict[str, Any]],
@@ -108,7 +108,7 @@ async def run_local_turn(
     return "(Stopped after exhausting the local tool-call round limit -- try a narrower question.)"
 
 
-async def stream_local_turn(
+async def _stream_local_turn_impl(
     manager: ProviderManager,
     provider: ProviderType,
     messages: List[Dict[str, Any]],
@@ -119,3 +119,34 @@ async def stream_local_turn(
     common single-shot/no-tools case still gets real token streaming)."""
     async for chunk in manager.chat_completion(provider, messages, model=model, stream=True):
         yield chunk
+
+
+async def run_local_turn(
+    manager: ProviderManager,
+    provider: ProviderType,
+    messages: List[Dict[str, Any]],
+    model: Optional[str],
+    console: Console,
+    *,
+    use_tools: bool = True,
+) -> str:
+    """Compatibility adapter routed through the unified runtime."""
+    from .runtime.unified import get_unified_runtime
+    return await get_unified_runtime().execute_local_chat(
+        manager=manager, provider=provider, messages=messages, model=model,
+        console=console, use_tools=use_tools,
+    )
+
+
+async def stream_local_turn(
+    manager: ProviderManager,
+    provider: ProviderType,
+    messages: List[Dict[str, Any]],
+    model: Optional[str],
+) -> AsyncIterator[str]:
+    """Compatibility streaming adapter routed through the unified runtime."""
+    from .runtime.unified import get_unified_runtime
+    async for chunk in get_unified_runtime().stream_local_chat(
+        manager=manager, provider=provider, messages=messages, model=model,
+    ):
+        yield chunk

{tamfis_code-0.7.0 → tamfis_code-1.3.0}/tamfis_code/mcp.py

@@ -9,6 +9,8 @@ import re
 import subprocess
 import fnmatch
 import asyncio
+import os
+import tempfile
 import sys
 import shutil
 import tarfile
@@ -680,13 +682,31 @@ class MCPServer:
                 )
         return resolved
 
-    async def _write_file(self, path: str, content: str) -> str:
+    def _atomic_write_text(self, target: Path, content: str) -> None:
+        target.parent.mkdir(parents=True, exist_ok=True)
+        fd, temp_name = tempfile.mkstemp(prefix=f".{target.name}.", suffix=".tmp", dir=str(target.parent))
+        try:
+            with os.fdopen(fd, "w", encoding="utf-8", newline="") as handle:
+                handle.write(content)
+                handle.flush()
+                os.fsync(handle.fileno())
+            os.replace(temp_name, target)
+        except BaseException:
+            with contextlib.suppress(OSError):
+                os.unlink(temp_name)
+            raise
+
+    async def _write_file(self, path: str, content: str | None = None, **aliases: Any) -> str:
+        content = content if content is not None else aliases.pop("text", None)
+        content = content if content is not None else aliases.pop("new_content", None)
+        content = content if content is not None else aliases.pop("file_content", None)
+        if content is None:
+            return "❌ Error: write_file requires content"
         p = self._resolve_in_workspace(path)
         original_content = p.read_text(encoding="utf-8", errors="ignore") if p.is_file() else None
-        p.parent.mkdir(parents=True, exist_ok=True)
-        p.write_text(content, encoding='utf-8')
-        if not p.exists():
-            return f"❌ Failed to write to '{path}'"
+        self._atomic_write_text(p, content)
+        if p.read_text(encoding="utf-8", errors="strict") != content:
+            return f"❌ Failed to verify write to '{path}'"
         if self.session_id is not None:
             from .safety import record_mutation
             record_mutation(
@@ -696,7 +716,18 @@ class MCPServer:
             )
         return f"✅ Successfully wrote {len(content)} bytes to '{path}'"
 
-    async def _edit_file(self, path: str, old_string: str, new_string: str) -> str:
+    async def _edit_file(
+        self, path: str, old_string: str | None = None, new_string: str | None = None, **aliases: Any
+    ) -> str:
+        old_string = old_string if old_string is not None else aliases.pop("old_text", None)
+        new_string = new_string if new_string is not None else aliases.pop("new_text", None)
+        new_string = new_string if new_string is not None else aliases.pop("replacement", None)
+        full_content = aliases.pop("content", None)
+        full_content = full_content if full_content is not None else aliases.pop("new_content", None)
+        if full_content is not None and old_string is None:
+            return await self._write_file(path, content=full_content)
+        if old_string is None or new_string is None:
+            return "❌ Error: edit_file requires old_string and new_string, or content for full replacement"
         p = self._resolve_in_workspace(path)
         if not p.is_file():
             return f"❌ Error: File '{path}' not found"
@@ -710,7 +741,9 @@ class MCPServer:
                 "Include more surrounding context to disambiguate."
             )
         new_content = original_content.replace(old_string, new_string, 1)
-        p.write_text(new_content, encoding="utf-8")
+        self._atomic_write_text(p, new_content)
+        if p.read_text(encoding="utf-8", errors="strict") != new_content:
+            return f"❌ Failed to verify edit to '{path}'"
         if self.session_id is not None:
             from .safety import record_mutation
             record_mutation(

{tamfis_code-0.7.0 → tamfis_code-1.3.0}/tamfis_code/openhands/agent.py

@@ -61,7 +61,7 @@ class TamfisAgent:
     ) -> AgentRunResult:
         from rich.console import Console
         from tamfis_code.providers import ProviderManager, ProviderType
-        from tamfis_code.runner_local import run_local_agent_turn
+        from tamfis_code.runtime.unified import get_unified_runtime
 
         if self.conversation.state == ConversationState.RUNNING:
             raise RuntimeError("conversation is already running")
@@ -74,7 +74,7 @@ class TamfisAgent:
         except ValueError as exc:
             raise ValueError(f"unsupported provider: {provider}") from exc
         try:
-            outcome = await run_local_agent_turn(
+            outcome = await get_unified_runtime().execute_local(
                 manager,
                 selected,
                 model,

{tamfis_code-0.7.0 → tamfis_code-1.3.0}/tamfis_code/orchestrator/__init__.py

@@ -1,4 +1,5 @@
 """Tamfis-Code orchestration runtime."""
+from .approvals import ApprovalAction, ApprovalBatch, describe_batch
 from .engine import AgentOrchestrator, OrchestrationRun
 from .planner import ExecutionPlan, build_reasoning_plan_prompt, parse_reasoning_plan, should_plan
 from .protocols import AgentPhase, CanonicalEvent, EventType, ToolEnvelope
@@ -6,4 +7,5 @@ from .protocols import AgentPhase, CanonicalEvent, EventType, ToolEnvelope
 __all__ = [
     "AgentOrchestrator", "OrchestrationRun", "AgentPhase", "CanonicalEvent", "EventType", "ToolEnvelope",
     "ExecutionPlan", "build_reasoning_plan_prompt", "parse_reasoning_plan", "should_plan",
+    "ApprovalAction", "ApprovalBatch", "describe_batch",
 ]