iac-code 0.4.0__tar.gz → 0.5.0__tar.gz

{iac_code-0.4.0 → iac_code-0.5.0}/MANIFEST.in

@@ -1,7 +1,7 @@
 include LICENSE
 include README.md
 include pyproject.toml
-recursive-include src/iac_code *.yml *.yaml *.json *.md *.mo *.po
+recursive-include src/iac_code *.yml *.yaml *.json *.md *.rego *.mo *.po
 
 prune tests
 prune htmlcov

{iac_code-0.4.0 → iac_code-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: iac_code
-Version: 0.4.0
+Version: 0.5.0
 Summary: Your AI-powered Infrastructure as Code assistant
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
@@ -21,7 +21,7 @@ License-File: LICENSE
   <img src="website/static/img/logo-with-front.png" alt="iac-code" width="200">
 </p>
 <p align="center">
-  <em>AI-powered Infrastructure as Code assistant for Alibaba Cloud (ROS / Terraform) through natural language interaction.</em>
+  <em>AI-powered Infrastructure as Code assistant for cloud infrastructure through natural language interaction. Currently supports Alibaba Cloud ROS and Terraform workflows.</em>
 </p>
 <p align="center">
   <a href="https://github.com/aliyun/iac-code/actions/workflows/test.yml"><img src="https://github.com/aliyun/iac-code/actions/workflows/test.yml/badge.svg" alt="Test"></a>

{iac_code-0.4.0 → iac_code-0.5.0}/README.md

@@ -2,7 +2,7 @@
   <img src="website/static/img/logo-with-front.png" alt="iac-code" width="200">
 </p>
 <p align="center">
-  <em>AI-powered Infrastructure as Code assistant for Alibaba Cloud (ROS / Terraform) through natural language interaction.</em>
+  <em>AI-powered Infrastructure as Code assistant for cloud infrastructure through natural language interaction. Currently supports Alibaba Cloud ROS and Terraform workflows.</em>
 </p>
 <p align="center">
   <a href="https://github.com/aliyun/iac-code/actions/workflows/test.yml"><img src="https://github.com/aliyun/iac-code/actions/workflows/test.yml/badge.svg" alt="Test"></a>
@@ -73,4 +73,4 @@ See the [Contributing Guide](https://aliyun.github.io/iac-code/getting-started/c
 
 | [DingTalk](https://qr.dingtalk.com/action/joingroup?code=v1,k1,ubm/77U7qRh/STFZUNBP26X4PNg2z6+uhiPcLGtDNfU=&_dt_no_comment=1&origin=11) | [Discord](https://discord.gg/qECFuFBwF) |
 | :----------------------------------------------------------: | :----------------------------------------------------------: |
-| [<img src="website/static/img/qrcode-dingtalk.jpg" width="120" height="120" alt="DingTalk">](https://qr.dingtalk.com/action/joingroup?code=v1,k1,ubm/77U7qRh/STFZUNBP26X4PNg2z6+uhiPcLGtDNfU=&_dt_no_comment=1&origin=11) | [<img src="website/static/img/qrcode-discord.jpg" width="120" height="120" alt="Discord">](https://discord.gg/qECFuFBwF) |
+| [<img src="website/static/img/qrcode-dingtalk.jpg" width="120" height="120" alt="DingTalk">](https://qr.dingtalk.com/action/joingroup?code=v1,k1,ubm/77U7qRh/STFZUNBP26X4PNg2z6+uhiPcLGtDNfU=&_dt_no_comment=1&origin=11) | [<img src="website/static/img/qrcode-discord.jpg" width="120" height="120" alt="Discord">](https://discord.gg/qECFuFBwF) |

{iac_code-0.4.0 → iac_code-0.5.0}/pyproject.toml

@@ -91,6 +91,7 @@ version = {attr = "iac_code.__version__"}
     "**/*.yaml",
     "**/*.json",
     "**/*.md",
+    "**/*.rego",
     "**/*.mo",
     "**/*.po",
 ]

iac_code-0.5.0/src/iac_code/__init__.py

@@ -0,0 +1,2 @@
+__version__ = "0.5.0"
+__release_date__ = "2026-06-11"

{iac_code-0.4.0 → iac_code-0.5.0}/src/iac_code/a2a/executor.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import asyncio
+import contextlib
 import logging
 import os
 import uuid
@@ -27,7 +28,7 @@ from iac_code.a2a.types import (
 )
 from iac_code.services.agent_factory import AgentFactoryOptions, create_agent_runtime
 from iac_code.services.session_storage import SessionStorage
-from iac_code.services.telemetry import use_session_id
+from iac_code.services.telemetry import use_session_id, use_user_id
 
 logger = logging.getLogger(__name__)
 _CONTEXT_LOCK_ACQUIRE_TIMEOUT_SECONDS = 1
@@ -87,6 +88,7 @@ class IacCodeA2AExecutor(AgentExecutor):
                 getattr(context, "message", None), "metadata", None
             )
             cwd = self._resolve_cwd(metadata)
+            user_id = self._resolve_user_id(metadata)
             prompt = self._prompt_from_context(context, cwd=cwd)
         except Exception as exc:
             if _is_retryable_executor_error(exc):
@@ -222,7 +224,8 @@ class IacCodeA2AExecutor(AgentExecutor):
                     context_id=context_id,
                     state=TaskState.TASK_STATE_WORKING,
                 )
-                with use_session_id(ctx.session_id):
+                user_id_ctx = use_user_id(user_id) if user_id else contextlib.nullcontext()
+                with use_session_id(ctx.session_id), user_id_ctx:
                     async for event in runtime.agent_loop.run_streaming(prompt):
                         text_chunk = await publish_stream_event(
                             event_queue,
@@ -348,6 +351,19 @@ class IacCodeA2AExecutor(AgentExecutor):
             resolved_cwd.mkdir(parents=True, exist_ok=True)
         return str(resolved_cwd)
 
+    def _resolve_user_id(self, metadata: Any | None) -> str | None:
+        if metadata is not None and hasattr(metadata, "DESCRIPTOR"):
+            metadata = MessageToDict(metadata, preserving_proto_field_name=False)
+        if not isinstance(metadata, Mapping):
+            return None
+        raw_iac_meta = metadata.get("iac_code")
+        if not isinstance(raw_iac_meta, Mapping):
+            return None
+        raw_user_id = raw_iac_meta.get("user_id")
+        if isinstance(raw_user_id, str) and raw_user_id.strip():
+            return raw_user_id.strip()
+        return None
+
     def _prompt_from_context(self, context: RequestContext, *, cwd: str) -> str:
         message = getattr(context, "message", None)
         if not isinstance(message, Message):

{iac_code-0.4.0 → iac_code-0.5.0}/src/iac_code/a2a/persistence.py

@@ -8,6 +8,7 @@ from pathlib import Path
 from typing import cast
 
 from iac_code.a2a.types import validate_protocol_id
+from iac_code.utils.file_security import atomic_write_text
 
 _INTERRUPTED_RESTORE_STATES = {"submitted", "working", "auth-required"}
 
@@ -175,9 +176,7 @@ class A2APersistenceStore:
 
     @staticmethod
     def _write_json(path: Path, data: dict[str, object]) -> None:
-        tmp = path.with_suffix(".json.tmp")
-        tmp.write_text(json.dumps(data, ensure_ascii=False, sort_keys=True), encoding="utf-8")
-        tmp.replace(path)
+        atomic_write_text(path, json.dumps(data, ensure_ascii=False, sort_keys=True))
 
     @staticmethod
     def _read_json(path: Path) -> dict[str, object] | None:

{iac_code-0.4.0 → iac_code-0.5.0}/src/iac_code/a2a/push.py

@@ -262,6 +262,7 @@ class A2APushNotifier:
         config = self.load_config(task_id)
         if config is None:
             return False
+        validate_push_callback_url(config.callback_url)
         payload = {"taskId": task_id, "contextId": context_id, "state": state}
         for attempt in range(self._max_attempts):
             try:

{iac_code-0.4.0 → iac_code-0.5.0}/src/iac_code/a2a/push_queue.py

@@ -50,6 +50,7 @@ class A2APushJob:
             "configId": self.config_id,
             "url": self.url,
             "payload": self.payload,
+            "headers": redact_push_headers(self.headers),
             "attempt": self.attempt,
             "nextAttemptAt": self.next_attempt_at,
             "lastError": self.last_error,
@@ -137,7 +138,10 @@ class LocalFileA2APushQueue:
         current = time.time() if now is None else now
         self._recover_expired_inflight(current)
         for path in sorted(self.pending_dir.glob("*.json")):
-            job = self._read(path)
+            try:
+                job = self._read(path)
+            except FileNotFoundError:
+                continue
             if job.next_attempt_at > current:
                 continue
             target = self.inflight_dir / path.name
@@ -146,7 +150,10 @@ class LocalFileA2APushQueue:
                 next_attempt_at=current + self._inflight_timeout_seconds,
                 last_error=job.last_error,
             )
-            path.replace(target)
+            try:
+                path.replace(target)
+            except FileNotFoundError:
+                continue
             self._write(target, leased)
             return self._read(target)
         return None
@@ -265,8 +272,14 @@ class RedisStreamsA2APushQueue:
         members = await self._redis.zrangebyscore(self._retry_key, "-inf", now, start=0, num=10)
         for member in members:
             encoded = _decode_redis_field(member)
-            await self._redis.xadd(self._stream, {"job": encoded})
-            await self._redis.zrem(self._retry_key, member)
+            pipe = self._redis.pipeline() if hasattr(self._redis, "pipeline") else None
+            if pipe is not None:
+                pipe.xadd(self._stream, {"job": encoded})
+                pipe.zrem(self._retry_key, member)
+                await pipe.execute()
+            else:
+                await self._redis.xadd(self._stream, {"job": encoded})
+                await self._redis.zrem(self._retry_key, member)
 
     async def _claim_expired(self) -> A2APushJob | None:
         xautoclaim = getattr(self._redis, "xautoclaim", None)

{iac_code-0.4.0 → iac_code-0.5.0}/src/iac_code/a2a/push_secrets.py

@@ -23,6 +23,7 @@ class A2APushSecretKeyring:
         self._env_managed = False
         self._active_key_id = ""
         self._keys: dict[str, str] = {}
+        self._created_at: dict[str, int] = {}
 
     @property
     def active_key_id(self) -> str:
@@ -55,6 +56,7 @@ class A2APushSecretKeyring:
         if key_id in self._keys:
             raise A2APushSecretError(f"A2A push secret encryption key already exists: {key_id}")
         self._keys[key_id] = Fernet.generate_key().decode("ascii")
+        self._created_at[key_id] = int(time.time())
         self._active_key_id = key_id
         self._write()
         return key_id
@@ -74,6 +76,7 @@ class A2APushSecretKeyring:
             return
         self._active_key_id = _new_key_id()
         self._keys = {self._active_key_id: Fernet.generate_key().decode("ascii")}
+        self._created_at = {self._active_key_id: int(time.time())}
         self._loaded = True
         self._write()
 
@@ -86,6 +89,11 @@ class A2APushSecretKeyring:
             for item in keys
             if isinstance(item, dict) and item.get("id") and item.get("fernetKey")
         }
+        self._created_at = {
+            str(item["id"]): int(item["createdAt"])
+            for item in keys
+            if isinstance(item, dict) and item.get("id") and item.get("createdAt") is not None
+        }
         self._active_key_id = str(data.get("activeKeyId") or "")
         if not self._active_key_id or self._active_key_id not in self._keys:
             raise A2APushSecretError("A2A push secret keyring does not contain its active key")
@@ -96,7 +104,7 @@ class A2APushSecretKeyring:
         data = {
             "activeKeyId": self._active_key_id,
             "keys": [
-                {"id": key_id, "fernetKey": key, "createdAt": int(time.time())}
+                {"id": key_id, "fernetKey": key, "createdAt": self._created_at.get(key_id, int(time.time()))}
                 for key_id, key in sorted(self._keys.items())
             ],
         }

{iac_code-0.4.0 → iac_code-0.5.0}/src/iac_code/a2a/task_store.py

@@ -51,12 +51,13 @@ class A2ATaskStore(TaskStore):
     async def save(self, task: Task, context: ServerCallContext | None = None) -> None:
         owner = self._owner(context)
         task_id = validate_protocol_id(task.id)
-        owner_tasks = self._sdk_tasks.setdefault(owner, {})
-        previous = owner_tasks.get(task_id)
-        if previous is not None:
-            self._remove_sdk_task_from_index(owner, task_id, previous.context_id)
-        owner_tasks[task_id] = _copy_task(task)
-        self._sdk_tasks_by_context.setdefault(owner, {}).setdefault(task.context_id, set()).add(task_id)
+        async with self._mutation_lock:
+            owner_tasks = self._sdk_tasks.setdefault(owner, {})
+            previous = owner_tasks.get(task_id)
+            if previous is not None:
+                self._remove_sdk_task_from_index(owner, task_id, previous.context_id)
+            owner_tasks[task_id] = _copy_task(task)
+            self._sdk_tasks_by_context.setdefault(owner, {}).setdefault(task.context_id, set()).add(task_id)
 
     async def delete(self, task_id: str, context: ServerCallContext | None = None) -> None:
         owner = self._owner(context)

{iac_code-0.4.0 → iac_code-0.5.0}/src/iac_code/a2a/transports/redis_streams.py

@@ -97,13 +97,18 @@ class RedisStreamsA2AClient:
 
     async def _read_responses(self, correlation_id: str) -> AsyncIterator[RedisStreamsMessage]:
         deadline = asyncio.get_running_loop().time() + self._timeout_seconds
+        # Start from "0-0" instead of "$" to avoid a race where the server
+        # responds before the first xread call.  After each batch we advance
+        # the cursor to the last entry ID we saw, which is the standard
+        # Redis Streams consumer pattern.
+        last_id = "0-0"
         consecutive_errors = 0
         max_consecutive_errors = 3
         while asyncio.get_running_loop().time() < deadline:
             try:
                 remaining = deadline - asyncio.get_running_loop().time()
                 rows = await asyncio.wait_for(
-                    self._redis.xread({self._response_stream: "$"}, count=1, block=100),
+                    self._redis.xread({self._response_stream: last_id}, count=10, block=100),
                     timeout=max(0.001, min(0.2, remaining)),
                 )
                 consecutive_errors = 0
@@ -121,6 +126,8 @@ class RedisStreamsA2AClient:
                 continue
             for _stream, entries in rows:
                 for entry_id, fields in entries:
+                    # Advance cursor past this entry so we don't re-read it.
+                    last_id = entry_id if isinstance(entry_id, str) else entry_id.decode("utf-8")
                     message = parse_redis_entry(entry_id, fields)
                     if message.correlation_id == correlation_id:
                         yield message

{iac_code-0.4.0 → iac_code-0.5.0}/src/iac_code/a2a/transports/unix.py

@@ -2,6 +2,8 @@ from __future__ import annotations
 
 import asyncio
 import contextlib
+import os
+import stat
 from collections.abc import AsyncIterator
 from pathlib import Path
 from typing import Any
@@ -10,10 +12,19 @@ from iac_code.a2a.transports.dispatcher import A2ARuntimeComponents
 from iac_code.a2a.transports.stdio import StdioA2AClient, StdioA2AServer
 
 
+def _is_socket(path: Path) -> bool:
+    try:
+        return stat.S_ISSOCK(os.lstat(path).st_mode)
+    except OSError:
+        return False
+
+
 def validate_socket_path(socket_path: str) -> Path:
     path = Path(socket_path)
     if not path.parent.exists():
         raise ValueError(f"Unix socket parent does not exist: {path.parent}")
+    if path.exists() and not _is_socket(path):
+        raise ValueError(f"Path exists and is not a Unix socket: {path}")
     return path
 
 
@@ -22,11 +33,15 @@ class UnixA2AServer:
         self._components = components
         self._socket_path = validate_socket_path(socket_path)
         self._server: asyncio.AbstractServer | None = None
+        self._owns_socket = False
 
     async def serve(self) -> None:
         if self._socket_path.exists():
+            if not _is_socket(self._socket_path):
+                raise ValueError(f"Path exists and is not a Unix socket: {self._socket_path}")
             self._socket_path.unlink()
         self._server = await asyncio.start_unix_server(self._handle_client, path=str(self._socket_path))
+        self._owns_socket = True
         async with self._server:
             await self._server.serve_forever()
 
@@ -43,8 +58,9 @@ class UnixA2AServer:
         if self._server is not None:
             self._server.close()
             await self._server.wait_closed()
-        with contextlib.suppress(FileNotFoundError):
-            self._socket_path.unlink()
+        if self._owns_socket:
+            with contextlib.suppress(FileNotFoundError):
+                self._socket_path.unlink()
         await self._components.aclose()
 
 

{iac_code-0.4.0 → iac_code-0.5.0}/src/iac_code/acp/http_sse.py

@@ -247,9 +247,39 @@ class HTTPConnectionBridge:
                     self._initialized.set()
                 else:
                     try:
-                        self._sse_queue.put_nowait(message)
-                    except asyncio.QueueFull:
-                        logger.warning("SSE queue full for connection %s, discarding message", self.connection_id[:8])
+                        # Apply backpressure: block until space is available
+                        # (up to a timeout) rather than silently discarding.
+                        await asyncio.wait_for(self._sse_queue.put(message), timeout=30.0)
+                    except asyncio.TimeoutError:
+                        # Client is not consuming events within a reasonable
+                        # window — send an error notification and tear down.
+                        logger.error(
+                            "SSE queue full for connection %s: client not consuming events, closing",
+                            self.connection_id[:8],
+                        )
+                        error_event = json.dumps(
+                            {
+                                "jsonrpc": "2.0",
+                                "method": "notifications/cancelled",
+                                "params": {
+                                    "reason": "SSE queue full: client is not consuming events",
+                                },
+                            }
+                        )
+                        # Make room by discarding the oldest pending event so
+                        # the error notification reaches the client.
+                        try:
+                            self._sse_queue.get_nowait()
+                        except asyncio.QueueEmpty:
+                            pass
+                        try:
+                            self._sse_queue.put_nowait(error_event)
+                        except asyncio.QueueFull:
+                            pass
+                        # Break out of the read loop — the finally block will
+                        # send the sentinel and trigger connection teardown.
+                        fatal_error = True
+                        break
         except asyncio.CancelledError:
             raise
         except Exception:
@@ -290,11 +320,31 @@ _connections: dict[str, HTTPConnectionBridge] = {}
 
 _ACP_CONN_HEADER = "Acp-Connection-Id"
 _INIT_TIMEOUT = 30.0
+# Maximum allowed request body size (4 MiB). Requests exceeding this limit
+# are rejected with 413 to prevent unbounded memory consumption.
+_MAX_BODY_BYTES = 4 * 1024 * 1024
 
 
 async def _handle_post(request: Request) -> Response:
     """Handle ``POST /acp`` — JSON-RPC requests from the client."""
+    # Enforce body size limit to prevent unbounded memory consumption.
+    content_length = request.headers.get("content-length")
+    if content_length is not None:
+        try:
+            if int(content_length) > _MAX_BODY_BYTES:
+                return JSONResponse(
+                    {"error": "Request body too large"},
+                    status_code=413,
+                )
+        except (ValueError, OverflowError):
+            pass
+
     body = await request.body()
+    if len(body) > _MAX_BODY_BYTES:
+        return JSONResponse(
+            {"error": "Request body too large"},
+            status_code=413,
+        )
     message = body.decode("utf-8")
 
     try:

{iac_code-0.4.0 → iac_code-0.5.0}/src/iac_code/acp/server.py

@@ -3,13 +3,17 @@ from __future__ import annotations
 import asyncio
 import contextlib
 import logging
+import os
+import sys
 import time
 import uuid
+from pathlib import Path
 from typing import Any
 
 import acp
 
 from iac_code import __version__
+from iac_code.a2a.parts import allowed_cwd_roots, is_relative_to
 from iac_code.acp.metrics import ACPMetrics
 from iac_code.acp.session import ACPSession, Message, _is_auth_error
 from iac_code.acp.slash_registry import ACP_SUPPORTED_COMMANDS
@@ -23,7 +27,11 @@ from iac_code.services.agent_factory import AgentFactoryOptions, create_agent_ru
 from iac_code.services.session_index import SessionEntry, SessionIndex
 from iac_code.services.session_resolver import ResolutionStatus, resolve_session_argument
 from iac_code.services.session_storage import SessionStorage
-from iac_code.utils.project_paths import format_resume_command, same_project_path
+from iac_code.utils.project_paths import (
+    _looks_like_windows_path,
+    format_resume_command,
+    same_project_path,
+)
 
 SESSION_IDLE_TIMEOUT = 3600  # 1 hour
 CLEANUP_INTERVAL = 300  # 5 minutes
@@ -31,6 +39,10 @@ CLEANUP_INTERVAL = 300  # 5 minutes
 logger = logging.getLogger(__name__)
 
 
+def _runtime_command_memory_manager(runtime: object) -> object | None:
+    return getattr(runtime, "legacy_memory_manager", None) or getattr(runtime, "memory_manager", None)
+
+
 class ACPServer:
     def __init__(self) -> None:
         self.conn: acp.Client | None = None
@@ -101,6 +113,36 @@ class ACPServer:
             raise acp.RequestError.invalid_params({"session_id": "Session not found"})
         return session
 
+    @staticmethod
+    def _validate_cwd(cwd: str) -> str:
+        """Validate the working directory path.
+
+        Ensures the path is absolute and falls within one of the allowed CWD
+        roots (same policy as the A2A executor).  Returns the original *cwd*
+        string on success (not resolved) so that session storage lookups
+        remain consistent.  Raises :class:`acp.RequestError` on failure.
+        """
+        if not cwd:
+            raise acp.RequestError.invalid_params({"cwd": "cwd must be an absolute path"})
+        # Accept both POSIX and Windows absolute paths.  ``os.path.isabs``
+        # treats rooted POSIX-style paths (``/tmp``) as absolute on Windows
+        # too, while ``_looks_like_windows_path`` catches drive-letter forms
+        # (``C:\foo``) on POSIX hosts.
+        is_windows_path = _looks_like_windows_path(cwd)
+        if not os.path.isabs(cwd) and not is_windows_path:
+            raise acp.RequestError.invalid_params({"cwd": "cwd must be an absolute path"})
+        # When a Windows-style path is received on a non-Windows host, we
+        # cannot resolve it against the local filesystem; skip the
+        # root-containment and is_dir checks for that case only.
+        if is_windows_path and sys.platform != "win32":
+            return cwd
+        resolved = Path(cwd).resolve()
+        if not any(is_relative_to(resolved, root) for root in allowed_cwd_roots()):
+            raise acp.RequestError.invalid_params({"cwd": "cwd is outside allowed roots"})
+        if resolved.exists() and not resolved.is_dir():
+            raise acp.RequestError.invalid_params({"cwd": "cwd is not a directory"})
+        return cwd
+
     async def initialize(
         self,
         protocol_version: int,
@@ -144,6 +186,8 @@ class ACPServer:
         if self.conn is None:
             raise acp.RequestError.internal_error({"error": "ACP client not connected"})
 
+        cwd = self._validate_cwd(cwd)
+
         # Convert MCP server configs from ACP protocol types to internal dicts
         mcp_configs = _convert_mcp_servers(mcp_servers)
 
@@ -161,7 +205,7 @@ class ACPServer:
             self.conn,
             mcp_configs=mcp_configs,
             metrics=self.metrics,
-            memory_manager=getattr(runtime, "memory_manager", None),
+            memory_manager=_runtime_command_memory_manager(runtime),
         )
         self.sessions[session.id] = session
         self.metrics.record_session_created()
@@ -268,6 +312,8 @@ class ACPServer:
         if self.conn is None:
             raise acp.RequestError.internal_error({"error": "ACP client not connected"})
 
+        cwd = self._validate_cwd(cwd)
+
         # 1. Already active in memory — return immediately
         if session_id in self.sessions:
             model = load_saved_model() or DEFAULT_MODEL
@@ -303,7 +349,7 @@ class ACPServer:
             self.conn,
             mcp_configs=mcp_configs,
             metrics=self.metrics,
-            memory_manager=getattr(runtime, "memory_manager", None),
+            memory_manager=_runtime_command_memory_manager(runtime),
         )
         self.sessions[session_id] = session
         self.metrics.record_session_created()
@@ -334,6 +380,8 @@ class ACPServer:
         if self.conn is None:
             raise acp.RequestError.internal_error({"error": "ACP client not connected"})
 
+        cwd = self._validate_cwd(cwd)
+
         # 1. Collect history from the source session
         history: list[Message] = []
         if session_id in self.sessions:
@@ -372,7 +420,7 @@ class ACPServer:
             self.conn,
             mcp_configs=mcp_configs,
             metrics=self.metrics,
-            memory_manager=getattr(runtime, "memory_manager", None),
+            memory_manager=_runtime_command_memory_manager(runtime),
         )
         self.sessions[new_session_id] = session
         self.metrics.record_session_created()
@@ -396,6 +444,8 @@ class ACPServer:
         mcp_servers: list[MCPServer] | None = None,
         **kwargs: Any,
     ) -> acp.schema.ResumeSessionResponse:
+        cwd = self._validate_cwd(cwd)
+
         # 1. If session is still active in memory by exact id, enforce project ownership before returning.
         active_session = self.sessions.get(session_id)
         if active_session is not None:
@@ -482,7 +532,7 @@ class ACPServer:
             self.conn,
             mcp_configs=mcp_configs,
             metrics=self.metrics,
-            memory_manager=getattr(runtime, "memory_manager", None),
+            memory_manager=_runtime_command_memory_manager(runtime),
         )
         self.sessions[resolved_session_id] = session
         self.metrics.record_session_created()

{iac_code-0.4.0 → iac_code-0.5.0}/src/iac_code/acp/session.py

@@ -18,7 +18,14 @@ from iac_code.acp.slash_registry import ACPSlashRegistry
 from iac_code.acp.state import TurnState
 from iac_code.acp.tools import ACPTerminalBashTool
 from iac_code.acp.types import ACPContentBlock
-from iac_code.agent.message import Message, TextBlock, ThinkingBlock, ToolResultBlock, ToolUseBlock
+from iac_code.agent.message import (
+    Message,
+    TextBlock,
+    ThinkingBlock,
+    ToolResultBlock,
+    ToolUseBlock,
+    is_recalled_memory_message,
+)
 from iac_code.services.telemetry import use_session_id
 from iac_code.state.app_state import lookup_permission, record_permission
 from iac_code.types.permissions import PermissionDecision
@@ -64,6 +71,9 @@ def _history_message_to_updates(msg: Message) -> list[Any]:
       ``ToolCallProgress``.
     * **user** tool-result blocks are emitted as completed ``ToolCallProgress``.
     """
+    if is_recalled_memory_message(msg):
+        return []
+
     updates: list[Any] = []
     content = msg.content
 
@@ -157,6 +167,20 @@ _PREFIX_ALLOW_RULE = "allow_rule:"
 _PREFIX_DENY_RULE = "deny_rule:"
 
 
+def _tool_supports_blanket_allow(agent_loop, tool_name: str) -> bool:
+    """Return False only when the registered tool explicitly disables blanket allow."""
+    registry = getattr(agent_loop, "tool_registry", None)
+    get_tool = getattr(registry, "get", None)
+    if get_tool is None:
+        return True
+
+    tool = get_tool(tool_name)
+    if tool is None:
+        return True
+
+    return bool(getattr(tool, "supports_blanket_allow", True))
+
+
 class ACPSession:
     def __init__(
         self,
@@ -457,7 +481,7 @@ class ACPSession:
                     kind="allow_always",
                 )
             )
-        else:
+        elif _tool_supports_blanket_allow(self.agent_loop, tool_name):
             options.append(
                 acp.schema.PermissionOption(
                     option_id=_OPTION_ALLOW_ALWAYS,