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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tamfis-code
-Version: 0.6.7
+Version: 0.6.13
 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/USAGE_INSTALL_RELEASE.md

@@ -0,0 +1,85 @@
+# Install and release TamfisGPT Code
+
+## Install on any server
+
+Use the isolated installer so the CLI does not depend on the host Python
+environment or a server-specific checkout:
+
+```bash
+./install.sh
+# Root installation: /usr/local/lib/tamfis-code + /usr/local/bin/tamfis-code
+# User installation: ~/.local/share/tamfis-code + ~/.local/bin/tamfis-code
+# Custom location:
+TAMFIS_CODE_PREFIX=/opt/tamfis-code TAMFIS_CODE_BIN_DIR=/usr/local/bin ./install.sh
+```
+
+The same package is portable to macOS and Windows. On Windows, create a
+virtual environment with `py -m venv`, install the project with `py -m pip
+install .`, and expose the virtualenv's `Scripts` directory on PATH. No
+machine-specific checkout path is compiled into the package.
+
+When managing several local projects, configure only the approved roots:
+
+```toml
+workspace_roots = ["/path/to/project-a", "/path/to/project-b"]
+```
+
+Place that in the user's `config.toml`, or use the portable environment
+variable `TAMFIS_CODE_WORKSPACE_ROOTS` (path-separated). The launch directory
+is always discovered automatically; other roots are allowed only when listed
+or explicitly approved with `tamfis-code workspace add <path>`.
+
+The runtime stores session state in the platform's user configuration
+directory. It does not require a TamfisGPT server process on the same host.
+
+## Configure the TamfisGPT subscription API
+
+Create an API key from the TamfisGPT account connected to the user's active
+iOS subscription, then set:
+
+```bash
+export TAMFIS_API_KEY='tamfis_sk_live_...'
+export TAMFIS_API_BASE='https://gpt.tamfitronics.com/api/v1/openai'
+tamfis-code doctor
+```
+
+The API key is the user's entitlement boundary. Admin credentials are not
+needed for ordinary subscribers. The API handles model access and billing;
+the installed CLI keeps workspace files, commands, PTYs, approvals, and the
+mutation ledger on the local machine.
+
+## Interactive follow-up input
+
+While a task is running, the `message>` editor remains available in the same
+terminal. Type normally and press Enter; the line is echoed with a durable
+queue ID, then applied at the next safe model-round boundary. Multiple queued
+updates are processed in order. A second terminal can enqueue the same session
+with:
+
+```bash
+tamfis-code queue "also inspect the authentication flow" --classification follow_up
+```
+
+`/queue` lists pending requests in the interactive REPL. `Ctrl+C` remains the
+interrupt/exit control. No special Ctrl+Y shortcut is required.
+
+## Build and publish a release
+
+Run the full checks, build a clean distribution, and inspect it before
+publishing:
+
+```bash
+python3 -m pytest -q
+python3 -m build
+python3 -m twine check dist/*
+```
+
+Publishing requires an account token configured in the release environment:
+
+```bash
+python3 -m twine upload dist/*
+```
+
+The GitHub repository should receive the same source revision and release
+notes as the PyPI upload. Never commit API keys, subscription tokens, local
+session state, or generated build artifacts.

{tamfis_code-0.6.7 → tamfis_code-0.6.13}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tamfis-code"
-version = "0.6.7"
+version = "0.6.13"
 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.7 → tamfis_code-0.6.13}/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.7"
+__version__ = "0.6.13"
 
 # 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.7 → tamfis_code-0.6.13}/tamfis_code/cli.py

@@ -2381,3 +2381,7 @@ from .enforcer import TestEnforcer, run_enforcer, add_enforcer_command
 # flags wired to _run_shell_checks/_run_type_checks, neither of which exist on
 # TestEnforcer -- using those flags raised AttributeError at runtime.
 add_enforcer_command(cli)
+
+# 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.6.7 → tamfis_code-0.6.13}/tamfis_code/config.py

@@ -146,6 +146,11 @@ class Config:
     # TamfisGPT tenant who wants that be the default, the same way Claude
     # Code/Codex/kimi-code default to their respective hosted accounts.
     default_backend: str = "standalone"
+    # Additional local roots that may be used by this installation. The
+    # launch directory is always included separately; these roots make a
+    # multi-project service practical without granting access to the whole
+    # filesystem.
+    workspace_roots: list[str] = field(default_factory=list)
     sources: dict[str, str] = field(default_factory=dict)  # field -> where it came from, for `doctor`/`config`
 
     def as_dict(self) -> dict[str, Any]:
@@ -158,6 +163,7 @@ class Config:
             "debug": self.debug,
             "enable_subagent_delegation": self.enable_subagent_delegation,
             "default_backend": self.default_backend,
+            "workspace_roots": self.workspace_roots,
         }
 
 
@@ -193,6 +199,14 @@ def load_config(project_root: Optional[Path] = None) -> Config:
         if data.get("default_backend") in ("standalone", "remote"):
             cfg.default_backend = str(data["default_backend"])
             cfg.sources["default_backend"] = source_name
+        configured_roots = data.get("workspace_roots")
+        if isinstance(configured_roots, list):
+            cfg.workspace_roots = [
+                str(Path(item).expanduser().resolve())
+                for item in configured_roots
+                if isinstance(item, str) and item.strip()
+            ]
+            cfg.sources["workspace_roots"] = source_name
 
     env_api_base = os.environ.get("TAMFIS_CODE_API_BASE")
     if env_api_base:
@@ -214,6 +228,15 @@ def load_config(project_root: Optional[Path] = None) -> Config:
         cfg.default_backend = env_backend
         cfg.sources["default_backend"] = "env TAMFIS_CODE_DEFAULT_BACKEND"
 
+    env_roots = os.environ.get("TAMFIS_CODE_WORKSPACE_ROOTS")
+    if env_roots:
+        cfg.workspace_roots = [
+            str(Path(item.strip()).expanduser().resolve())
+            for item in env_roots.split(os.pathsep)
+            if item.strip()
+        ]
+        cfg.sources["workspace_roots"] = "env TAMFIS_CODE_WORKSPACE_ROOTS"
+
     return cfg
 
 

tamfis_code-0.6.13/tamfis_code/github_commands.py

@@ -0,0 +1,65 @@
+"""GitHub CLI parity commands.
+
+Tamfis-Code exposes the familiar ``gh`` command surface without reimplementing
+GitHub authentication or API semantics. Each command delegates directly to the
+installed GitHub CLI, preserves the current working directory, streams PTY/TTY
+I/O unchanged, and returns the exact child exit code.
+"""
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+from typing import Iterable
+
+import click
+
+GITHUB_COMMANDS: tuple[str, ...] = (
+    "alias", "api", "auth", "browse", "cache", "co", "codespace",
+    "completion", "config", "extension", "gist", "gpg-key", "issue",
+    "label", "org", "pr", "project", "release", "repo", "ruleset",
+    "run", "search", "secret", "ssh-key", "status", "variable", "workflow",
+)
+
+
+def _gh_binary() -> str:
+    binary = shutil.which("gh")
+    if not binary:
+        raise click.ClickException(
+            "GitHub CLI (`gh`) is not installed or is not available in PATH."
+        )
+    return binary
+
+
+def run_gh(subcommand: str, args: Iterable[str]) -> None:
+    """Execute one gh subcommand with transparent terminal behaviour."""
+    command = [_gh_binary(), subcommand, *args]
+    completed = subprocess.run(command, cwd=os.getcwd(), check=False)
+    if completed.returncode:
+        raise click.exceptions.Exit(completed.returncode)
+
+
+def register_github_commands(root: click.Group) -> None:
+    """Register all requested gh-compatible top-level commands."""
+    existing = set(root.commands)
+    for command_name in GITHUB_COMMANDS:
+        # Tamfis-Code owns a richer native command with the same name.
+        # Keep that native implementation rather than shadowing it.
+        if command_name in existing:
+            continue
+
+        def callback(args: tuple[str, ...], _name: str = command_name) -> None:
+            run_gh(_name, args)
+
+        command = click.Command(
+            name=command_name,
+            callback=callback,
+            params=[click.Argument(["args"], nargs=-1, type=click.UNPROCESSED)],
+            context_settings={
+                "ignore_unknown_options": True,
+                "allow_extra_args": True,
+                "help_option_names": [],
+            },
+            help=f"Delegate to `gh {command_name}` with full PTY/TTY passthrough.",
+        )
+        root.add_command(command)

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

@@ -111,7 +111,7 @@ $ <command>            explicit shell command
 /mode <name>         switch mode: manual | accept-edits | auto | plan
 Shift+Tab            cycle mode without typing a command (shown in the prompt as [mode]);
                      also works while a task is already running, not just at this prompt
-Ctrl+T               while a task is running: open the "queue next" input editor
+message>             while a task is running: type a message and press Enter
 /model               show the active model route
 /model list [route]  list coding models (route: hf or openrouter)
 /model auto          restore Hugging Face -> OpenRouter automatic routing
@@ -372,10 +372,8 @@ async def run_interactive(
     )
     console.print(
         "[dim]Type /help for commands. Paste up to 1,000,000 characters; Alt+Enter adds a newline. "
-        "Shift+Tab cycles mode (manual/accept-edits/auto/plan) -- works while a task is running too, "
-        "not just at this prompt. Ctrl+T opens a visible `queue next>` editor while a task is running; "
-        "your submitted text is acknowledged with a queue id and applied at the next safe round boundary. "
-        "Ctrl+D or Ctrl+C exits.[/dim]\n"
+        "While a task runs, a normal message prompt remains available: type and press Enter; "
+        "your text is queued without a special shortcut. Shift+Tab cycles mode. Ctrl+D or Ctrl+C exits.[/dim]\n"
     )
 
     CONFIG_DIR.mkdir(parents=True, exist_ok=True)
@@ -990,7 +988,7 @@ async def run_interactive(
                     "/mode auto           auto-approves everything, never prompts (server safeguards still apply)\n"
                     "/mode plan           read-only: propose without executing\n"
                     "Shift+Tab            cycle manual -> accept-edits -> auto -> plan without typing a command\n"
-                    "                     (also works mid-task, not just here); Ctrl+T mid-task queues a follow-up\n"
+                    "                     (also works mid-task, not just here); type in the message prompt to queue work\n"
                     "Other raw policy values also work directly (--approval-only, no short alias): safe, workspace,\n"
                     "read-only, plan-only, suggest, full-auto, and 'never' -- note 'never' means DENY everything\n"
                     "(the opposite of what it sounds like; it is not a synonym for 'auto').[/dim]"
@@ -1319,6 +1317,10 @@ async def run_interactive(
                     last_response_text = outcome.summary
                 if outcome.status == "completed" and outcome.summary and not renderer.streamed_final_text:
                     console.print(Markdown(outcome.summary))
+                if outcome.status == "exited":
+                    if local_pty is not None:
+                        local_pty.close()
+                    break
                 if outcome.status != "completed":
                     print_error(console, outcome.error or f"task {outcome.status}")
                 console.print()
@@ -1343,6 +1345,10 @@ async def run_interactive(
                     last_response_text = outcome.summary
                 if outcome.status == "completed" and outcome.summary and not renderer.streamed_final_text:
                     console.print(Markdown(outcome.summary))
+                if outcome.status == "exited":
+                    if local_pty is not None:
+                        local_pty.close()
+                    break
                 if outcome.status != "completed":
                     print_error(console, outcome.error or f"task {outcome.status}")
             except (AuthRequiredError, RemoteAPIError) as e:
@@ -1363,6 +1369,7 @@ async def run_interactive(
                 or reply_state.turn_checkpoint or reply_state.conversation_history
             ),
         )
+        submitted_text = text
         intent = parse_intent(text, custom_commands=custom_commands)
         try:
             if intent.kind == "shell":
@@ -1392,6 +1399,10 @@ async def run_interactive(
                         continue
                 renderer = StreamRenderer(console, mode_label=mode_label_for_policy(config.approval_policy))
                 model_state = local_state.get_session_state(workspace.session_id)
+                renderer.handle_event({
+                    "event_type": "user_message",
+                    "payload": {"content": submitted_text},
+                })
                 if standalone:
                     live_input = LiveInputListener(session_id=workspace.session_id, renderer=renderer, cli_config=config)
                     live_input.start()

tamfis_code-0.6.13/tamfis_code/live_input.py

@@ -0,0 +1,216 @@
+"""Non-blocking follow-up input for a running standalone task.
+
+The old implementation put stdin into cbreak mode, discarded ordinary
+characters, and required Ctrl+Y to open a second editor. That made the
+terminal feel frozen and made mouse selection/scrolling fight Rich's live
+redraw. A running task now owns a normal prompt-toolkit line editor instead:
+the user can type at any time, press Enter to queue a follow-up, and keep
+typing the next one while the model continues streaming.
+"""
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import sys
+from typing import Optional
+
+from prompt_toolkit.formatted_text import HTML
+
+from . import state as local_state
+from .config import Config, mode_label_for_policy, next_mode_in_cycle
+from .render import StreamRenderer
+
+_SHIFT_TAB = b"\x1b[Z"
+# Retained only for backwards-compatible imports. Ctrl+Y is no longer read
+# specially by the live listener; it is ordinary editable prompt input.
+_CTRL_T = b"\x14"
+_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:
+        self.session_id = session_id
+        self.renderer = renderer
+        self.cli_config = cli_config
+        self._is_tty = bool(getattr(sys.stdin, "isatty", lambda: False)())
+        self._input_task: Optional[asyncio.Task] = None
+        self._interject_task: Optional[asyncio.Task] = None
+        self._prompt_session = None
+        self._paused = False
+        self._active = False
+
+    def start(self) -> None:
+        if not self._is_tty:
+            return
+        # Stop Rich's repainting while the prompt owns the terminal. Streamed
+        # assistant text is intentionally rendered as scrollback in this
+        # mode, so the input line and mouse scrolling never compete.
+        self.renderer.suspend_live()
+        self.renderer.live_input_listener = self
+        self._active = True
+        self._schedule_prompt()
+
+    def stop(self) -> None:
+        self._active = False
+        self._cancel_prompt()
+        if self.renderer.live_input_listener is self:
+            self.renderer.live_input_listener = None
+            self.renderer.resume_live()
+
+    def pause(self) -> None:
+        self._paused = True
+        self._cancel_prompt()
+
+    def resume(self) -> None:
+        self._paused = False
+        if self._active:
+            self._schedule_prompt()
+
+    def _dispatch(self) -> None:
+        """Compatibility hook for older embedders; start() no longer uses it."""
+        buf = bytes(getattr(self, "_buf", b""))
+        if _SHIFT_TAB in buf:
+            self._buf = bytearray()
+            self.cli_config.approval_policy = next_mode_in_cycle(self.cli_config.approval_policy)
+            self.renderer.handle_event({
+                "event_type": "diagnostics",
+                "payload": {"content": f"◆ Mode switched to {mode_label_for_policy(self.cli_config.approval_policy)}."},
+            })
+            if hasattr(self.renderer, "set_mode_label"):
+                self.renderer.set_mode_label(mode_label_for_policy(self.cli_config.approval_policy))
+        elif buf in {b"\x1b", b"\x1b["}:
+            return
+        elif _CTRL_Y in buf:
+            self._buf = bytearray()
+            if self._interject_task is None or self._interject_task.done():
+                self._interject_task = asyncio.create_task(self._interject())
+        elif buf:
+            self._buf = bytearray()
+
+    def _schedule_prompt(self) -> None:
+        if self._input_task is None or self._input_task.done():
+            self._input_task = asyncio.create_task(self._input_loop())
+
+    def _cancel_prompt(self) -> None:
+        task = self._input_task
+        self._input_task = None
+        if task is not None and not task.done():
+            task.cancel()
+
+    def invalidate(self) -> None:
+        """Refresh the prompt footer after a streamed phase/status update."""
+        app = getattr(self._prompt_session, "app", None)
+        if app is not None:
+            app.invalidate()
+
+    def _bottom_toolbar(self):
+        status = self.renderer.live_input_status()
+        mode = mode_label_for_policy(self.cli_config.approval_policy)
+        return HTML(
+            f"<b><ansicyan>◆</ansicyan></b> <b>{status}</b>  "
+            f"<ansigray>│ {mode} │ esc interrupt │ shift+tab mode</ansigray>"
+        )
+
+    async def _input_loop(self) -> None:
+        from prompt_toolkit import PromptSession
+        from prompt_toolkit.key_binding import KeyBindings
+        from prompt_toolkit.patch_stdout import patch_stdout
+
+        bindings = KeyBindings()
+
+        # Some SSH/terminal clients emit focus-in/focus-out as CSI sequences
+        # (ESC [ I / ESC [ O).  Because ``escape`` is also the intentional
+        # cancel binding below, prompt_toolkit can otherwise dispatch the
+        # first byte as a cancellation and leak the trailing ``I``/``O`` into
+        # the prompt.  Consume those complete sequences before the bare-Esc
+        # binding gets a chance to act.
+        @bindings.add("escape", "[", "I")
+        def _ignore_focus_in(event) -> None:
+            return
+
+        @bindings.add("escape", "[", "O")
+        def _ignore_focus_out(event) -> None:
+            return
+
+        @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="")
+
+        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
+            self._enqueue(text)
+        self._prompt_session = None
+
+    def _enqueue_control(self, classification: str) -> None:
+        item = local_state.enqueue_instruction(
+            self.session_id, "", classification=classification,
+        )
+        self.renderer.handle_event({
+            "event_type": "diagnostics",
+            "payload": {"content": f"◆ Queued {classification} for the running task ({item.id})."},
+        })
+
+    def _enqueue(self, text: str) -> None:
+        text = text.strip()
+        if not text:
+            if self._active and not self._paused:
+                self._schedule_prompt()
+            return
+        item = local_state.enqueue_instruction(
+            self.session_id, text, classification="follow_up",
+        )
+        self.renderer.handle_event({
+            "event_type": "user_message",
+            "payload": {"content": text},
+        })
+        self.renderer.handle_event({
+            "event_type": "diagnostics",
+            "payload": {
+                "content": (
+                    f"◆ Queued next instruction {item.id}: {text} "
+                    "-- applied at the next safe round boundary."
+                ),
+            },
+        })
+        if self._active and not self._paused:
+            self._schedule_prompt()
+
+    async def _interject(self) -> None:
+        """Compatibility helper for callers/tests that submit one line."""
+        from prompt_toolkit import PromptSession
+        from prompt_toolkit.patch_stdout import patch_stdout
+
+        try:
+            with patch_stdout(raw=True):
+                text = await PromptSession().prompt_async("message> ")
+        except KeyboardInterrupt:
+            self._enqueue_control("exit")
+            return
+        except EOFError:
+            text = ""
+        self._enqueue(text)

{tamfis_code-0.6.7 → tamfis_code-0.6.13}/tamfis_code/mcp.py

@@ -163,6 +163,7 @@ class MCPServer:
         console: Optional[Any] = None, renderer: Optional[Any] = None, interactive: bool = False,
         transaction_id: Optional[str] = None,
         attachment_paths: Optional[List[str]] = None,
+        allowed_workspace_roots: Optional[List[str]] = None,
     ):
         # workspace_root/session_id are optional so existing callers that
         # construct MCPServer() with no arguments (tests, the `tools`/
@@ -170,6 +171,13 @@ class MCPServer:
         # enforcement on write_file/edit_file, no mutation-ledger recording.
         # The standalone agent loop (runner_local.py) always supplies both.
         self.workspace_root = workspace_root
+        self.allowed_workspace_roots = {
+            Path(item).expanduser().resolve()
+            for item in (allowed_workspace_roots or [])
+            if item
+        }
+        if workspace_root:
+            self.allowed_workspace_roots.add(Path(workspace_root).expanduser().resolve())
         self.session_id = session_id
         # Explicit CLI attachments are readable inputs, not extra writable
         # workspaces. Only these exact files are admitted; their parent
@@ -664,9 +672,12 @@ class MCPServer:
             p = base / p
         resolved = p.resolve()
         if self.workspace_root:
-            root = base.resolve()
-            if resolved != root and root not in resolved.parents:
-                raise PermissionError(f"'{path}' resolves outside the workspace root ({root})")
+            roots = self.allowed_workspace_roots or {base.resolve()}
+            if not any(resolved == root or root in resolved.parents for root in roots):
+                rendered = ", ".join(str(root) for root in sorted(roots, key=str))
+                raise PermissionError(
+                    f"'{path}' resolves outside the workspace; approved roots: ({rendered})"
+                )
         return resolved
 
     async def _write_file(self, path: str, content: str) -> str:

{tamfis_code-0.6.7 → tamfis_code-0.6.13}/tamfis_code/model_registry.py

@@ -77,10 +77,47 @@ MODELS: dict[str, ModelRecord] = {
         ("repository_audit", "multi_file_edit", "debugging", "planning", "tool_heavy_execution"),
         "frontier", "medium",
     ),
-    "Qwen/Qwen2.5-7B-Instruct": ModelRecord(
-        "Qwen/Qwen2.5-7B-Instruct", "hf",
-        ModelCapabilities(long_context=False), 32768,
-        ("single_file_explanation", "repository_search"), "balanced", "low",
+    "deepseek-ai/deepseek-v4-pro": ModelRecord(
+        "deepseek-ai/deepseek-v4-pro", "nvidia",
+        ModelCapabilities(parallel_tool_calls=True, long_context=True), 1000000,
+        ("repository_audit", "multi_file_edit", "debugging", "planning", "tool_heavy_execution"),
+        "frontier", "high",
+    ),
+    "deepseek-ai/deepseek-v4-flash": ModelRecord(
+        "deepseek-ai/deepseek-v4-flash", "nvidia",
+        ModelCapabilities(parallel_tool_calls=True, long_context=True), 1000000,
+        ("repository_search", "multi_file_edit", "debugging", "tool_heavy_execution"),
+        "frontier", "medium",
+    ),
+    "Qwen/Qwen3.6-35B-A3B": ModelRecord(
+        "Qwen/Qwen3.6-35B-A3B", "hf",
+        ModelCapabilities(parallel_tool_calls=True, long_context=True), 262144,
+        ("repository_audit", "multi_file_edit", "debugging", "planning", "tool_heavy_execution"),
+        "frontier", "medium",
+    ),
+    "Qwen/Qwen3.6-27B": ModelRecord(
+        "Qwen/Qwen3.6-27B", "hf",
+        ModelCapabilities(parallel_tool_calls=True, long_context=True), 262144,
+        ("repository_search", "multi_file_edit", "debugging", "planning"),
+        "frontier", "medium",
+    ),
+    "Qwen/Qwen3-Coder-480B-A35B-Instruct": ModelRecord(
+        "Qwen/Qwen3-Coder-480B-A35B-Instruct", "hf",
+        ModelCapabilities(parallel_tool_calls=True, long_context=True), 262144,
+        ("repository_audit", "multi_file_edit", "debugging", "planning", "tool_heavy_execution"),
+        "frontier", "high",
+    ),
+    "deepseek-ai/DeepSeek-V4-Pro": ModelRecord(
+        "deepseek-ai/DeepSeek-V4-Pro", "hf",
+        ModelCapabilities(parallel_tool_calls=True, long_context=True), 1048576,
+        ("repository_audit", "multi_file_edit", "debugging", "planning", "tool_heavy_execution"),
+        "frontier", "high",
+    ),
+    "deepseek-ai/DeepSeek-V4-Flash": ModelRecord(
+        "deepseek-ai/DeepSeek-V4-Flash", "hf",
+        ModelCapabilities(parallel_tool_calls=True, long_context=True), 262144,
+        ("repository_search", "multi_file_edit", "debugging", "tool_heavy_execution"),
+        "frontier", "medium",
     ),
 }
 

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

@@ -25,6 +25,7 @@ class OrchestrationRun:
     validation: ValidationReport | None = None
     route: dict[str, Any] = field(default_factory=dict)
     repair_attempts: int = 0
+    reasoning_plan: bool = False
 
 
 class AgentOrchestrator:
@@ -165,6 +166,22 @@ class AgentOrchestrator:
             tool_records=[item.to_dict() for item in self.run.tool_records],
             any_mutation=any_mutation, final_text=final_text,
         )
+        if (
+            self.run.reasoning_plan
+            and self.run.profile.task_type.value == "audit"
+            and self.run.plan is not None
+        ):
+            pending = [
+                step.name for step in self.run.plan.steps
+                if step.status in {"pending", "in_progress"}
+            ]
+            if pending:
+                report.passed = False
+                report.unresolved.append(
+                    "Execution plan incomplete; pending steps: " + "; ".join(pending)
+                )
+                if report.severity == "pass":
+                    report.severity = "warning"
         self.run.validation = report
         state = local_state.get_session_state(self.session_id)
         local_state.save_session_state(