tamfis-code 0.6.13__tar.gz → 0.6.14__tar.gz

{tamfis_code-0.6.13/tamfis_code.egg-info → tamfis_code-0.6.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tamfis-code
-Version: 0.6.13
+Version: 0.6.14
 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.6.13 → tamfis_code-0.6.14}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tamfis-code"
-version = "0.6.13"
+version = "0.6.14"
 description = "TamfisGPT Code -- portable subscription-backed terminal coding agent with local tools, PTY, plans, queues, and approvals"
 readme = "README.md"
 requires-python = ">=3.10"

{tamfis_code-0.6.13 → tamfis_code-0.6.14}/tamfis_code/__init__.py

@@ -17,7 +17,7 @@ See docs/REMOTE_AGENT_MASTER_SPEC.md, Phase 21, for the original --remote
 architecture's spec.
 """
 
-__version__ = "0.6.13"
+__version__ = "0.6.14"
 
 # Bumped whenever a CLI release requires a minimum backend Remote API
 # contract version. Only meaningful for --remote; the standalone path has no

{tamfis_code-0.6.13 → tamfis_code-0.6.14}/tamfis_code/agents.py

@@ -128,6 +128,8 @@ class CodeAnalyzer(SubAgent):
         return issues
 
 class TestGenerator(SubAgent):
+    # Application component, not a pytest test container.
+    __test__ = False
     """Generates tests for code"""
     
     def __init__(self):

{tamfis_code-0.6.13 → tamfis_code-0.6.14}/tamfis_code/enforcer.py

@@ -20,6 +20,8 @@ except ImportError:
 
 
 class TestEnforcer:
+    # Application component, not a pytest test container.
+    __test__ = False
     """Detects and runs the current workspace's own test/build commands."""
 
     def __init__(self, workspace_root: Optional[Path] = None):

{tamfis_code-0.6.13 → tamfis_code-0.6.14}/tamfis_code/interactive.py

@@ -6,6 +6,7 @@ management.
 
 from __future__ import annotations
 
+import asyncio
 import re
 from pathlib import Path
 from typing import Optional
@@ -43,7 +44,13 @@ from .custom_commands import (
 from .doctor import run_doctor
 from .live_input import LiveInputListener
 from .render import StreamRenderer, print_banner, print_error, print_recent_thread, print_resume_plan_status, print_unified_diff
-from .runner import resolve_approval_decision_async, retry_task_and_stream, run_ai_task_and_stream, run_shell_command
+from .runner import (
+    TaskOutcome,
+    resolve_approval_decision_async,
+    retry_task_and_stream,
+    run_ai_task_and_stream,
+    run_shell_command,
+)
 from .runner_local import run_local_agent_turn, run_local_shell_command
 from .pty import LocalPtyBroker
 from .safety import revert_mutation as local_revert_mutation
@@ -61,6 +68,48 @@ from .workspace import (
 # those tools only collapse genuinely large pastes.
 PASTE_COLLAPSE_LINE_THRESHOLD = 3
 
+async def _run_cancellable_local_turn(
+    *,
+    session_id: int,
+    renderer: StreamRenderer,
+    config: Config,
+    turn_coro,
+) -> TaskOutcome:
+    """Run one standalone agent turn with immediate terminal cancellation."""
+
+    agent_task = asyncio.create_task(turn_coro)
+
+    def _interrupt(_classification: str) -> None:
+        if not agent_task.done():
+            agent_task.cancel()
+
+    live_input = LiveInputListener(
+        session_id=session_id,
+        renderer=renderer,
+        cli_config=config,
+        interrupt_callback=_interrupt,
+    )
+    live_input.start()
+
+    try:
+        return await agent_task
+    except asyncio.CancelledError:
+        classification = live_input.interrupt_classification or "cancel"
+
+        if classification == "exit":
+            return TaskOutcome(
+                status="exited",
+                error="Exit requested by user",
+            )
+
+        return TaskOutcome(
+            status="cancelled",
+            error="Task cancelled by user.",
+        )
+    finally:
+        live_input.stop()
+
+
 HELP_TEXT = """\
 Natural-language text submits a full coding-agent task (mode: coding).
 $ <command>            explicit shell command
@@ -469,19 +518,19 @@ async def run_interactive(
         model_state = local_state.get_session_state(workspace.session_id)
         plan_objective = local_state.plan_execution_objective(plan)
         if standalone:
-            live_input = LiveInputListener(session_id=workspace.session_id, renderer=renderer, cli_config=config)
-            live_input.start()
-            try:
-                outcome = await run_local_agent_turn(
+            outcome = await _run_cancellable_local_turn(
+                session_id=workspace.session_id,
+                renderer=renderer,
+                config=config,
+                turn_coro=run_local_agent_turn(
                     provider_manager, provider_type, model,
                     [*conversation_history, {"role": "user", "content": plan_objective}],
                     console, renderer,
                     workspace_root=workspace.workspace_root, session_id=workspace.session_id,
                     approval_policy=config.approval_policy, interactive=True, cli_config=config,
                     allow_swarm_tool=True,
-                )
-            finally:
-                live_input.stop()
+                ),
+            )
             _append_turn_to_history(
                 conversation_history, objective=plan_objective,
                 answer=outcome.summary if outcome.status == "completed" else None,
@@ -1294,10 +1343,11 @@ async def run_interactive(
                     print_error(console, "Existing uncommitted changes detected; retry is blocked to preserve user edits.")
                     continue
                 renderer = StreamRenderer(console, mode_label=mode_label_for_policy(config.approval_policy))
-                live_input = LiveInputListener(session_id=workspace.session_id, renderer=renderer, cli_config=config)
-                live_input.start()
-                try:
-                    outcome = await run_local_agent_turn(
+                outcome = await _run_cancellable_local_turn(
+                    session_id=workspace.session_id,
+                    renderer=renderer,
+                    config=config,
+                    turn_coro=run_local_agent_turn(
                         provider_manager, provider_type, model,
                         [*conversation_history, {"role": "user", "content": objective}],
                         console, renderer,
@@ -1305,9 +1355,8 @@ async def run_interactive(
                         approval_policy=config.approval_policy, interactive=True,
                         read_only=mode in {"chat", "audit", "plan"}, cli_config=config,
                         allow_swarm_tool=True,
-                    )
-                finally:
-                    live_input.stop()
+                    ),
+                )
                 renderer.finish()
                 _append_turn_to_history(
                     conversation_history, objective=objective,
@@ -1404,10 +1453,11 @@ async def run_interactive(
                     "payload": {"content": submitted_text},
                 })
                 if standalone:
-                    live_input = LiveInputListener(session_id=workspace.session_id, renderer=renderer, cli_config=config)
-                    live_input.start()
-                    try:
-                        outcome = await run_local_agent_turn(
+                    outcome = await _run_cancellable_local_turn(
+                        session_id=workspace.session_id,
+                        renderer=renderer,
+                        config=config,
+                        turn_coro=run_local_agent_turn(
                             provider_manager, provider_type, model,
                             [*conversation_history, {"role": "user", "content": intent.objective}],
                             console, renderer,
@@ -1415,15 +1465,18 @@ async def run_interactive(
                             approval_policy=config.approval_policy, interactive=True,
                             read_only=intent.mode in {"chat", "audit", "plan"}, cli_config=config,
                             allow_swarm_tool=True,
-                        )
-                    finally:
-                        live_input.stop()
+                        ),
+                    )
                     renderer.finish()
                     _append_turn_to_history(
                         conversation_history, objective=intent.objective,
                         answer=outcome.summary if outcome.status == "completed" else None,
                     )
                     last_turn = (intent.objective, intent.mode)
+                    if outcome.status == "exited":
+                        if local_pty is not None:
+                            local_pty.close()
+                        break
                     if intent.mode == "plan" and outcome.status == "completed" and outcome.summary:
                         saved = local_state.save_plan(workspace.session_id, objective=intent.objective, content=outcome.summary)
                         console.print(f"[green]Plan saved[/green] · {saved.id}")

{tamfis_code-0.6.13 → tamfis_code-0.6.14}/tamfis_code/live_input.py

@@ -12,7 +12,7 @@ from __future__ import annotations
 import asyncio
 import contextlib
 import sys
-from typing import Optional
+from typing import Callable, Optional
 
 from prompt_toolkit.formatted_text import HTML
 
@@ -30,10 +30,19 @@ _CTRL_Y = b"\x19"
 class LiveInputListener:
     """Run a persistent, asynchronous follow-up editor during a task."""
 
-    def __init__(self, *, session_id: int, renderer: StreamRenderer, cli_config: Config) -> None:
+    def __init__(
+        self,
+        *,
+        session_id: int,
+        renderer: StreamRenderer,
+        cli_config: Config,
+        interrupt_callback: Optional[Callable[[str], None]] = None,
+    ) -> None:
         self.session_id = session_id
         self.renderer = renderer
         self.cli_config = cli_config
+        self._interrupt_callback = interrupt_callback
+        self._interrupt_classification: Optional[str] = None
         self._is_tty = bool(getattr(sys.stdin, "isatty", lambda: False)())
         self._input_task: Optional[asyncio.Task] = None
         self._interject_task: Optional[asyncio.Task] = None
@@ -136,11 +145,15 @@ class LiveInputListener:
 
         @bindings.add("escape")
         def _cancel_running_turn(event) -> None:
-            # Match the interrupt affordance offered by other terminal agents:
-            # Escape cancels the active turn, while the prompt remains usable
-            # for subsequent work once the runner reaches a safe boundary.
-            self._enqueue_control("cancel")
-            event.app.exit(result="")
+            # Escape cancels the active turn immediately and returns control
+            # to the ordinary REPL without terminating Tamfis-Code.
+            if self._paused or not self._active:
+                return
+
+            self._request_interrupt("cancel")
+
+            if not event.app.is_done:
+                event.app.exit(result="")
 
         session = PromptSession(key_bindings=bindings)
         self._prompt_session = session
@@ -163,9 +176,44 @@ class LiveInputListener:
                 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
 
+    @property
+    def interrupt_classification(self) -> Optional[str]:
+        return self._interrupt_classification
+
+    def _request_interrupt(self, classification: str) -> None:
+        """Record and immediately propagate one terminal interrupt.
+
+        The durable queue item remains useful for history and recovery, but
+        immediate cancellation is delivered through interrupt_callback so a
+        blocked provider request or long-running tool does not need to reach
+        another orchestration boundary first.
+        """
+        if self._interrupt_classification is not None:
+            return
+
+        self._interrupt_classification = classification
+        self._paused = True
+        self._enqueue_control(classification)
+
+        if self._interrupt_callback is not None:
+            self._interrupt_callback(classification)
+
     def _enqueue_control(self, classification: str) -> None:
         item = local_state.enqueue_instruction(
             self.session_id, "", classification=classification,

{tamfis_code-0.6.13 → tamfis_code-0.6.14}/tamfis_code/orchestrator/engine.py

@@ -135,22 +135,27 @@ class AgentOrchestrator:
         self._advance_plan_step()
 
     def _advance_plan_step(self) -> None:
-        """Best-effort plan-step progress: each observed tool result is real,
-        concrete evidence that execution has moved forward, so use the
-        running tool-call count to advance a cursor through the plan's
-        steps -- reserving the final step (report/validate) so it is never
-        marked done before completion actually happens. This does not claim
-        precise step-to-action correspondence (see _sync_plan_progress)."""
+        """Expose execution progress without fabricating completion.
+
+        A tool result proves only that a tool call occurred. It does not prove
+        that a particular plan step completed, that a file changed, or that a
+        validation command passed. Therefore this method may mark one pending
+        step as in progress, but it must never mark a step completed.
+
+        Final completion is assigned only by complete() after validation.
+        """
         assert self.run is not None
         if self.run.plan is None or not self.run.plan.steps:
             return
-        steps = self.run.plan.steps
-        cursor = min(len(self.run.tool_records) - 1, max(len(steps) - 2, 0))
-        for step in steps[:cursor]:
-            if step.status not in {"completed", "failed"}:
-                step.status = "completed"
-        if steps[cursor].status not in {"completed", "failed"}:
-            steps[cursor].status = "in_progress"
+
+        # Keep at most one step active. Additional tool calls are evidence
+        # that work continues, not that later plan steps have started.
+        if not any(step.status == "in_progress" for step in self.run.plan.steps):
+            for step in self.run.plan.steps:
+                if step.status == "pending":
+                    step.status = "in_progress"
+                    break
+
         self._sync_plan_progress()
 
     def mark_repair(self, reason: str) -> None: