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

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "tamfis-code"
-version = "0.6.14"
+version = "0.7.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"

tamfis_code-0.7.0/tamfis_code/__init__.py

@@ -0,0 +1,49 @@
+"""Tamfis-Code, a standalone terminal coding agent.
+
+The package keeps import-time side effects deliberately minimal. Public
+components are loaded lazily so a missing optional module cannot prevent the
+CLI or deterministic runtime from starting.
+"""
+from __future__ import annotations
+
+from importlib import import_module
+from typing import Any
+
+__version__ = "0.7.0"
+MIN_COMPATIBLE_API_VERSION = "remote-ai-v2"
+
+_LAZY_EXPORTS: dict[str, tuple[str, str]] = {
+    "ShellCompleter": (".completion", "ShellCompleter"),
+    "MetricsTracker": (".metrics", "MetricsTracker"),
+    "StreamMetrics": (".metrics", "StreamMetrics"),
+    "AgentManager": (".agents", "AgentManager"),
+    "SubAgent": (".agents", "SubAgent"),
+    "CodeAnalyzer": (".agents", "CodeAnalyzer"),
+    "TestGenerator": (".agents", "TestGenerator"),
+    "DocGenerator": (".agents", "DocGenerator"),
+    "MCPServer": (".mcp", "MCPServer"),
+    "ToolDefinition": (".mcp", "ToolDefinition"),
+    "call_tool": (".mcp", "call_tool"),
+    "CodeIndexer": (".indexer", "CodeIndexer"),
+    "CodeSymbol": (".indexer", "CodeSymbol"),
+    "CodeFile": (".indexer", "CodeFile"),
+}
+
+__all__ = ["__version__", "MIN_COMPATIBLE_API_VERSION", *_LAZY_EXPORTS]
+
+
+def __getattr__(name: str) -> Any:
+    target = _LAZY_EXPORTS.get(name)
+    if target is None:
+        raise AttributeError(name)
+    module_name, attribute = target
+    try:
+        module = import_module(module_name, __name__)
+    except ModuleNotFoundError as exc:
+        raise AttributeError(
+            f"Optional Tamfis-Code component {name!r} is unavailable because "
+            f"module {module_name!r} is not installed."
+        ) from exc
+    value = getattr(module, attribute)
+    globals()[name] = value
+    return value

tamfis_code-0.7.0/tamfis_code/indexer.py

@@ -0,0 +1,37 @@
+"""Small dependency-free code index used by optional public exports."""
+from __future__ import annotations
+from dataclasses import dataclass, field
+from pathlib import Path
+import re
+
+@dataclass(frozen=True)
+class CodeSymbol:
+    name: str
+    kind: str
+    line: int
+
+@dataclass
+class CodeFile:
+    path: str
+    language: str
+    symbols: list[CodeSymbol] = field(default_factory=list)
+
+class CodeIndexer:
+    def __init__(self, root: str | Path): self.root=Path(root).resolve()
+    def index_file(self, path: str | Path) -> CodeFile:
+        p=Path(path).resolve(); text=p.read_text(encoding='utf-8',errors='replace')
+        suffix=p.suffix.lower(); language={'.py':'python','.ts':'typescript','.tsx':'typescript','.js':'javascript','.jsx':'javascript'}.get(suffix,'text')
+        symbols=[]
+        patterns=[('class',re.compile(r'^\s*class\s+([A-Za-z_]\w*)')),('function',re.compile(r'^\s*(?:async\s+)?def\s+([A-Za-z_]\w*)')),('function',re.compile(r'^\s*(?:export\s+)?(?:async\s+)?function\s+([A-Za-z_$][\w$]*)'))]
+        for n,line in enumerate(text.splitlines(),1):
+            for kind,pat in patterns:
+                m=pat.search(line)
+                if m: symbols.append(CodeSymbol(m.group(1),kind,n)); break
+        return CodeFile(str(p),language,symbols)
+    def index(self) -> list[CodeFile]:
+        result=[]
+        for p in self.root.rglob('*'):
+            if p.is_file() and p.suffix.lower() in {'.py','.ts','.tsx','.js','.jsx'} and not any(part.startswith('.') for part in p.relative_to(self.root).parts):
+                try: result.append(self.index_file(p))
+                except OSError: pass
+        return result

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

@@ -10,6 +10,7 @@ from .context import ContextBundle, build_context_bundle
 from .planner import ExecutionPlan, create_plan
 from .protocols import AgentPhase, ToolEnvelope
 from .validator import ValidationReport, validate_completion
+from ..runtime import ExecutionController, GuardDecision, ObservationDecision
 
 
 @dataclass
@@ -26,6 +27,7 @@ class OrchestrationRun:
     route: dict[str, Any] = field(default_factory=dict)
     repair_attempts: int = 0
     reasoning_plan: bool = False
+    runtime: ExecutionController = field(default_factory=ExecutionController)
 
 
 class AgentOrchestrator:
@@ -60,6 +62,7 @@ class AgentOrchestrator:
         if profile.requires_repository_context:
             self.transition(AgentPhase.INSPECT, action="Load or refresh repository context")
         self.run.plan = create_plan(objective, profile)
+        self.run.runtime.start_planning()
         plan_dict = self.run.plan.to_dict() if self.run.plan else None
         self.run.context = build_context_bundle(
             session_id=self.session_id, workspace_root=self.workspace_root,
@@ -85,6 +88,9 @@ class AgentOrchestrator:
         for the "here is the new plan" banner; this only handles state.
         """
         assert self.run is not None
+        if not self.run.runtime.record_plan_revision():
+            self.fail(self.run.runtime.snapshot.failure_reason)
+            return
         saved = local_state.save_plan(
             self.session_id, objective=self.run.objective,
             content="\n".join(f"{s.index}. {s.name}" for s in plan.steps),
@@ -120,51 +126,79 @@ class AgentOrchestrator:
         local_state.save_session_state(self.session_id, selected_provider=provider, selected_model=model)
 
     def start_execution(self) -> None:
+        assert self.run is not None
+        self.run.runtime.start_execution()
         self.transition(AgentPhase.EXECUTE, action="Execute the model/tool loop")
 
+    def guard_tool_call(self, tool_name: str, arguments: dict[str, Any]) -> GuardDecision:
+        assert self.run is not None
+        decision = self.run.runtime.guard_action(tool_name, arguments)
+        if not decision.allowed:
+            self.emit({"event_type": "diagnostics", "payload": {"content": decision.reason}})
+        return decision
+
     def waiting_for_approval(self, purpose: str) -> None:
         self.transition(AgentPhase.WAITING_FOR_APPROVAL, action=purpose)
 
-    def record_tool(self, envelope: ToolEnvelope) -> None:
+    def record_tool(self, envelope: ToolEnvelope) -> ObservationDecision:
         assert self.run is not None
         self.run.tool_records.append(envelope)
         self.transition(AgentPhase.OBSERVE, action=f"Observe {envelope.tool_name} result")
+        result = {
+            "success": bool(envelope.success),
+            "result": {
+                "stdout": envelope.stdout,
+                "stderr": envelope.stderr,
+                "exit_code": envelope.exit_code,
+                "files_changed": list(envelope.files_changed),
+                "path": envelope.arguments.get("path") or envelope.arguments.get("destination"),
+            },
+        }
+        decision = self.run.runtime.observe(envelope.tool_name, envelope.arguments, result)
         state = local_state.get_session_state(self.session_id)
         records = state.completed_actions + [{"type": "tool", **envelope.to_dict()}]
-        local_state.save_session_state(self.session_id, completed_actions=records[-250:])
-        self._advance_plan_step()
-
-    def _advance_plan_step(self) -> None:
-        """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.
+        local_state.save_session_state(
+            self.session_id, completed_actions=records[-250:],
+            running_action={
+                "purpose": decision.reason or f"Observed {envelope.tool_name}",
+                "phase": self.run.runtime.snapshot.phase.value,
+                "runtime": self.run.runtime.snapshot.to_dict(),
+            },
+        )
+        self._advance_plan_step(decision)
+        if decision.terminal:
+            self.fail(decision.reason)
+        return decision
 
-        Final completion is assigned only by complete() after validation.
-        """
+    def _advance_plan_step(self, decision: ObservationDecision) -> None:
+        """Advance only when a successful observation gained useful evidence."""
         assert self.run is not None
         if self.run.plan is None or not self.run.plan.steps:
             return
-
-        # 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
-
+        active = next((step for step in self.run.plan.steps if step.status == "in_progress"), None)
+        if active is None:
+            active = next((step for step in self.run.plan.steps if step.status == "pending"), None)
+            if active is not None:
+                active.status = "in_progress"
+        if active is not None and decision.useful:
+            active.status = "completed"
+            active.evidence.extend(item for item in decision.evidence if item not in active.evidence)
+            nxt = next((step for step in self.run.plan.steps if step.status == "pending"), None)
+            if nxt is not None:
+                nxt.status = "in_progress"
         self._sync_plan_progress()
 
     def mark_repair(self, reason: str) -> None:
         assert self.run is not None
         self.run.repair_attempts += 1
+        if not self.run.runtime.record_repair():
+            self.fail(self.run.runtime.snapshot.failure_reason)
+            return
         self.transition(AgentPhase.REPAIR, action=reason)
 
     def validate(self, *, final_text: str, any_mutation: bool) -> ValidationReport:
         assert self.run is not None
+        self.run.runtime.begin_validation()
         self.transition(AgentPhase.VALIDATE, action="Validate evidence and completion claims")
         report = validate_completion(
             profile=self.run.profile,
@@ -205,12 +239,17 @@ class AgentOrchestrator:
                 )
             self._sync_plan_progress()
         self.transition(AgentPhase.REPORT, action="Report only evidence-supported outcomes")
+        if report.severity == "error":
+            self.run.runtime.fail("Completion validation failed.")
+        else:
+            self.run.runtime.complete()
         self.transition(AgentPhase.FAILED if report.severity == "error" else AgentPhase.COMPLETED)
         local_state.checkpoint(self.session_id, reason="orchestrator_complete", summary=final_text[-1000:])
         return report
 
     def fail(self, error: str) -> None:
         if self.run is not None:
+            self.run.runtime.fail(error)
             if self.run.plan is not None:
                 for step in self.run.plan.steps:
                     if step.status == "in_progress":

tamfis_code-0.7.0/tamfis_code/routing.py

@@ -0,0 +1,55 @@
+"""Deterministic task classification used by the standalone runtime."""
+from __future__ import annotations
+from dataclasses import dataclass
+from enum import Enum
+
+
+class TaskType(str, Enum):
+    CONVERSATION="conversation"; QUESTION="question"; INSPECT="inspect"; AUDIT="audit"
+    PLAN="plan"; EDIT="edit"; DEBUG="debug"; TEST="test"; EXECUTE="execute"
+    GIT="git"; RESEARCH="research"; MIXED="mixed"
+
+
+@dataclass(frozen=True)
+class TaskProfile:
+    task_type: TaskType
+    complexity: str
+    requires_tools: bool
+    requires_repository_context: bool
+    requires_validation: bool
+    is_plain_conversation: bool = False
+
+
+def classify_task(text: str, *, read_only: bool = False) -> TaskProfile:
+    value=(text or "").casefold()
+    def has(*words: str) -> bool: return any(word in value for word in words)
+    if has("audit", "full stack", "entire stack", "review repository", "inspect repository"):
+        kind=TaskType.AUDIT
+    elif has("debug", "fix bug", "fix error", "traceback", "failing", "broken"):
+        kind=TaskType.DEBUG
+    elif has("edit", "change", "implement", "add ", "remove ", "rewrite", "refactor", "rebuild", "remodel"):
+        kind=TaskType.EDIT
+    elif has("test", "pytest", "vitest", "unit test"):
+        kind=TaskType.TEST
+    elif has("plan", "design", "architecture"):
+        kind=TaskType.PLAN
+    elif has("git ", "commit", "push", "pull request", "branch"):
+        kind=TaskType.GIT
+    elif has("research", "web search", "look up"):
+        kind=TaskType.RESEARCH
+    elif has("run ", "execute ", "restart", "build "):
+        kind=TaskType.EXECUTE
+    elif has("inspect", "read ", "show ", "find ", "locate", "search"):
+        kind=TaskType.INSPECT
+    elif value.strip() in {"hi","hello","hey","thanks","thank you"}:
+        kind=TaskType.CONVERSATION
+    else:
+        kind=TaskType.QUESTION
+    if read_only and kind in {TaskType.EDIT,TaskType.DEBUG,TaskType.EXECUTE}:
+        kind=TaskType.INSPECT
+    plain=kind is TaskType.CONVERSATION
+    tools=not plain
+    repo=kind not in {TaskType.CONVERSATION,TaskType.RESEARCH}
+    validation=kind in {TaskType.AUDIT,TaskType.EDIT,TaskType.DEBUG,TaskType.TEST,TaskType.EXECUTE,TaskType.MIXED}
+    complexity="high" if kind in {TaskType.AUDIT,TaskType.EDIT,TaskType.DEBUG,TaskType.MIXED} else "medium" if tools else "low"
+    return TaskProfile(kind, complexity, tools, repo, validation, plain)

{tamfis_code-0.6.14 → tamfis_code-0.7.0}/tamfis_code/runner_local.py

@@ -63,7 +63,7 @@ from .workspace import classify_root
 # legitimately needs many more tool calls (read several files, make several
 # edits, run tests, iterate). This exists only to guarantee termination if
 # something is genuinely stuck in a loop, not to cap normal work.
-MAX_AGENT_ROUNDS = 200
+MAX_AGENT_ROUNDS = 40
 
 # High reasoning is valuable for deliberate architecture work but makes the
 # interactive terminal feel stalled on ordinary audits/edits. Medium is the
@@ -4762,6 +4762,29 @@ async def run_local_agent_turn(
             except json.JSONDecodeError:
                 arguments = {}
 
+            guard = orchestrator.guard_tool_call(tc.name, arguments)
+            if not guard.allowed:
+                result = {
+                    "success": False,
+                    "error": guard.reason,
+                    "runtime_blocked": True,
+                }
+                working_messages.append({
+                    "role": "tool",
+                    "tool_call_id": tc.call_id,
+                    "content": json.dumps(result),
+                })
+                renderer.handle_event({
+                    "event_type": "tool_output",
+                    "payload": {"tool": tc.name, "result": result},
+                })
+                if guard.terminal:
+                    _persist_turn_checkpoint(status="failed", last_error=guard.reason)
+                    orchestrator.fail(guard.reason)
+                    renderer.handle_event({"event_type": "ai_task_failed", "payload": {"error": guard.reason}})
+                    return TaskOutcome(status="failed", error=guard.reason)
+                continue
+
             if tc.name == "retrieve_evidence":
                 # A pure local lookup by id -- read-only, no workspace scope
                 # or approval gate applies (it isn't a filesystem/shell tool
@@ -4949,7 +4972,16 @@ async def run_local_agent_turn(
             result = await mcp_server.call_tool(tc.name, arguments)
             result = _normalise_tool_result(tc.name, arguments, result, workspace_root)
             envelope.finish(result=result, success=bool(result.get("success")))
-            orchestrator.record_tool(envelope)
+            observation = orchestrator.record_tool(envelope)
+            if observation.terminal:
+                working_messages.append({
+                    "role": "tool",
+                    "tool_call_id": tc.call_id,
+                    "content": json.dumps(result, default=str),
+                })
+                _persist_turn_checkpoint(status="failed", last_error=observation.reason)
+                renderer.handle_event({"event_type": "ai_task_failed", "payload": {"error": observation.reason}})
+                return TaskOutcome(status="failed", error=observation.reason)
             renderer.handle_event({
                 "event_type": "tool_output",
                 "payload": {"tool": tc.name, "result": _tool_output_for_render(result)},

tamfis_code-0.7.0/tamfis_code/runtime/__init__.py

@@ -0,0 +1,13 @@
+"""Deterministic execution runtime for Tamfis-Code."""
+from .budgets import RuntimeBudgets
+from .controller import ExecutionController, GuardDecision, ObservationDecision
+from .state import RuntimePhase, RuntimeSnapshot
+
+__all__ = [
+    "ExecutionController",
+    "GuardDecision",
+    "ObservationDecision",
+    "RuntimeBudgets",
+    "RuntimePhase",
+    "RuntimeSnapshot",
+]

tamfis_code-0.7.0/tamfis_code/runtime/budgets.py

@@ -0,0 +1,18 @@
+"""Hard execution budgets that prevent unbounded agent loops."""
+from __future__ import annotations
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class RuntimeBudgets:
+    max_tool_calls: int = 40
+    max_identical_actions: int = 2
+    max_consecutive_empty_observations: int = 3
+    max_plan_revisions: int = 4
+    max_repair_rounds: int = 3
+    max_runtime_seconds: int = 900
+
+    def __post_init__(self) -> None:
+        for name, value in self.__dict__.items():
+            if value < 1:
+                raise ValueError(f"{name} must be at least 1")

tamfis_code-0.7.0/tamfis_code/runtime/controller.py

@@ -0,0 +1,147 @@
+"""Deterministic controller that owns progress, budgets and stall detection."""
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass, field
+from typing import Any
+
+from .budgets import RuntimeBudgets
+from .evidence import action_fingerprint, evidence_labels, is_empty_result, observation_fingerprint
+from .state import RuntimePhase, RuntimeSnapshot
+
+
+@dataclass(frozen=True)
+class GuardDecision:
+    allowed: bool
+    terminal: bool = False
+    reason: str = ""
+    fingerprint: str = ""
+
+
+@dataclass(frozen=True)
+class ObservationDecision:
+    useful: bool
+    terminal: bool = False
+    reason: str = ""
+    evidence: tuple[str, ...] = field(default_factory=tuple)
+
+
+class ExecutionController:
+    def __init__(self, budgets: RuntimeBudgets | None = None) -> None:
+        self.budgets = budgets or RuntimeBudgets()
+        self.snapshot = RuntimeSnapshot()
+        self.started_at = time.monotonic()
+        self._last_action = ""
+        self._last_observation = ""
+
+    def _fail(self, reason: str) -> None:
+        if not self.snapshot.terminal:
+            self.snapshot.failure_reason = reason
+            self.snapshot.transition(RuntimePhase.FAILED)
+
+    def _check_time(self) -> str:
+        elapsed = time.monotonic() - self.started_at
+        if elapsed >= self.budgets.max_runtime_seconds:
+            return f"Runtime budget exhausted after {int(elapsed)} seconds."
+        return ""
+
+    def start_planning(self) -> None:
+        if self.snapshot.phase == RuntimePhase.DISCOVER:
+            self.snapshot.transition(RuntimePhase.PLAN)
+
+    def start_execution(self) -> None:
+        if self.snapshot.phase in {RuntimePhase.DISCOVER, RuntimePhase.PLAN, RuntimePhase.OBSERVE, RuntimePhase.REPAIR}:
+            self.snapshot.transition(RuntimePhase.EXECUTE)
+
+    def guard_action(self, tool_name: str, arguments: dict[str, Any]) -> GuardDecision:
+        timeout = self._check_time()
+        if timeout:
+            self._fail(timeout)
+            return GuardDecision(False, True, timeout)
+        if self.snapshot.terminal:
+            return GuardDecision(False, True, self.snapshot.failure_reason or "Runtime is terminal.")
+        if self.snapshot.tool_calls >= self.budgets.max_tool_calls:
+            reason = f"Tool-call budget exhausted ({self.budgets.max_tool_calls})."
+            self._fail(reason)
+            return GuardDecision(False, True, reason)
+
+        fingerprint = action_fingerprint(tool_name, arguments)
+        count = self.snapshot.action_counts.get(fingerprint, 0) + 1
+        self.snapshot.action_counts[fingerprint] = count
+        self.snapshot.repeated_actions = count
+        if count > self.budgets.max_identical_actions:
+            reason = (
+                f"Blocked repeated action: {tool_name} with identical arguments was already attempted "
+                f"{count - 1} times without sufficient progress."
+            )
+            # Repeated action is refused first; terminal failure is reserved for
+            # continued no-progress pressure, so the model can choose a genuinely
+            # different strategy once.
+            terminal = self.snapshot.consecutive_empty_observations >= self.budgets.max_consecutive_empty_observations
+            if terminal:
+                self._fail(reason)
+            return GuardDecision(False, terminal, reason, fingerprint)
+
+        self.snapshot.tool_calls += 1
+        self._last_action = fingerprint
+        self.start_execution()
+        return GuardDecision(True, fingerprint=fingerprint)
+
+    def observe(self, tool_name: str, arguments: dict[str, Any], result: dict[str, Any]) -> ObservationDecision:
+        if self.snapshot.terminal:
+            return ObservationDecision(False, True, self.snapshot.failure_reason)
+        if self.snapshot.phase == RuntimePhase.EXECUTE:
+            self.snapshot.transition(RuntimePhase.OBSERVE)
+
+        empty = is_empty_result(tool_name, result)
+        fingerprint = observation_fingerprint(tool_name, result)
+        self.snapshot.observation_counts[fingerprint] = self.snapshot.observation_counts.get(fingerprint, 0) + 1
+        self._last_observation = fingerprint
+
+        if empty:
+            self.snapshot.empty_observations += 1
+            self.snapshot.consecutive_empty_observations += 1
+            count = self.snapshot.consecutive_empty_observations
+            if count >= self.budgets.max_consecutive_empty_observations:
+                reason = (
+                    f"Agent stalled after {count} consecutive tool results produced no useful evidence. "
+                    "The runtime stopped the loop instead of repeating reconnaissance."
+                )
+                self._fail(reason)
+                return ObservationDecision(False, True, reason)
+            self.snapshot.transition(RuntimePhase.EXECUTE)
+            return ObservationDecision(False, False, f"No useful evidence gained ({count}/{self.budgets.max_consecutive_empty_observations}).")
+
+        labels = tuple(evidence_labels(tool_name, arguments, result))
+        self.snapshot.evidence_items += len(labels) or 1
+        self.snapshot.consecutive_empty_observations = 0
+        self.snapshot.transition(RuntimePhase.EXECUTE)
+        return ObservationDecision(True, False, evidence=labels)
+
+    def begin_validation(self) -> None:
+        if self.snapshot.phase in {RuntimePhase.EXECUTE, RuntimePhase.OBSERVE, RuntimePhase.REPAIR}:
+            self.snapshot.transition(RuntimePhase.VALIDATE)
+
+    def record_repair(self) -> bool:
+        self.snapshot.repair_rounds += 1
+        if self.snapshot.repair_rounds > self.budgets.max_repair_rounds:
+            self._fail(f"Repair budget exhausted ({self.budgets.max_repair_rounds}).")
+            return False
+        if self.snapshot.phase in {RuntimePhase.EXECUTE, RuntimePhase.OBSERVE, RuntimePhase.VALIDATE}:
+            self.snapshot.transition(RuntimePhase.REPAIR)
+        return True
+
+    def record_plan_revision(self) -> bool:
+        self.snapshot.plan_revisions += 1
+        if self.snapshot.plan_revisions > self.budgets.max_plan_revisions:
+            self._fail(f"Plan revision budget exhausted ({self.budgets.max_plan_revisions}).")
+            return False
+        return True
+
+    def complete(self) -> None:
+        self.begin_validation()
+        if self.snapshot.phase == RuntimePhase.VALIDATE:
+            self.snapshot.transition(RuntimePhase.COMPLETE)
+
+    def fail(self, reason: str) -> None:
+        self._fail(reason)

tamfis_code-0.7.0/tamfis_code/runtime/evidence.py

@@ -0,0 +1,77 @@
+"""Stable action/observation fingerprints and evidence classification."""
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+from typing import Any
+
+_EMPTY_MARKERS = {"", "(empty)", "[]", "{}", "null", "none", "no matches", "no results"}
+_SPACE_RE = re.compile(r"\s+")
+
+
+def _canonical(value: Any) -> str:
+    try:
+        return json.dumps(value, sort_keys=True, separators=(",", ":"), default=str)
+    except Exception:
+        return repr(value)
+
+
+def digest(value: Any) -> str:
+    return hashlib.sha256(_canonical(value).encode("utf-8", "replace")).hexdigest()[:24]
+
+
+def action_fingerprint(tool_name: str, arguments: dict[str, Any]) -> str:
+    return f"{tool_name}:{digest(arguments)}"
+
+
+def normalise_text(value: Any) -> str:
+    return _SPACE_RE.sub(" ", str(value or "")).strip().casefold()
+
+
+def observation_fingerprint(tool_name: str, result: dict[str, Any]) -> str:
+    payload = result.get("result") if isinstance(result.get("result"), dict) else result
+    compact = {
+        "success": bool(result.get("success")),
+        "stdout": payload.get("stdout") if isinstance(payload, dict) else "",
+        "stderr": payload.get("stderr") if isinstance(payload, dict) else "",
+        "error": result.get("error") or (payload.get("error") if isinstance(payload, dict) else ""),
+        "path": payload.get("path") if isinstance(payload, dict) else "",
+        "items": payload.get("items") if isinstance(payload, dict) else None,
+        "matches": payload.get("matches") if isinstance(payload, dict) else None,
+        "files_changed": payload.get("files_changed") if isinstance(payload, dict) else None,
+    }
+    return f"{tool_name}:{digest(compact)}"
+
+
+def is_empty_result(tool_name: str, result: dict[str, Any]) -> bool:
+    if not bool(result.get("success")):
+        return True
+    payload = result.get("result") if isinstance(result.get("result"), dict) else result
+    if not isinstance(payload, dict):
+        return normalise_text(payload) in _EMPTY_MARKERS
+    if any(payload.get(key) for key in ("files_changed", "path", "destination")):
+        return False
+    for key in ("items", "matches", "results", "entries"):
+        if key in payload:
+            value = payload.get(key)
+            return not bool(value)
+    text = normalise_text(payload.get("stdout") or payload.get("content") or payload.get("output") or "")
+    error = normalise_text(payload.get("stderr") or payload.get("error") or result.get("error") or "")
+    if error and not text:
+        return True
+    return text in _EMPTY_MARKERS
+
+
+def evidence_labels(tool_name: str, arguments: dict[str, Any], result: dict[str, Any]) -> list[str]:
+    if is_empty_result(tool_name, result):
+        return []
+    payload = result.get("result") if isinstance(result.get("result"), dict) else result
+    labels = [f"tool:{tool_name}"]
+    path = ""
+    if isinstance(payload, dict):
+        path = str(payload.get("path") or payload.get("destination") or "")
+    path = path or str(arguments.get("path") or arguments.get("cwd") or "")
+    if path:
+        labels.append(f"path:{path}")
+    return labels