alysis-code 0.13.7__tar.gz → 0.13.8__tar.gz

{alysis_code-0.13.7 → alysis_code-0.13.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alysis-code
-Version: 0.13.7
+Version: 0.13.8
 Summary: Open-source coding agent for hosted and local models.
 Project-URL: Changelog, https://github.com/AlysisAi/alysis-code/blob/main/docs/CHANGELOG.md
 Project-URL: Documentation, https://github.com/AlysisAi/alysis-code/tree/main/docs
@@ -152,8 +152,10 @@ sandbox only when explicitly configured with `verify_sandbox.mode="off"` or
 
 Two layers control what the agent may do — one enforces, one focuses.
 
-**Execution modes** are the enforcement layer. Choose one per command with `--mode`, switch in chat
-with `/mode`, or set a default with `alysis-code config set default_mode <mode>`:
+**Execution modes** are the enforcement layer. Choose one per command with `--mode`, select the
+next message's permissions with `/permissions` or **Shift+Tab**, or set a default with
+`alysis-code config set default_mode <mode>`. A selection leaves the active turn's permissions
+unchanged until the next message starts:
 
 | Mode | Behavior |
 | --- | --- |
@@ -176,6 +178,10 @@ A persona is a convention, never a permission: it can keep or lower your executi
 never raise it. Define your own in `.alysis_personas/*.md`.
 [Learn more](https://alysiscode.com/docs/concepts/personas)
 
+Use `/persona architect` for planning in chat, or `/forge` for a plan-driven execution workflow.
+The legacy chat Plan Mode and its `/plan` commands have been removed; Forge retains its plan views
+and editor. Persona changes made during a running turn apply after that turn finishes.
+
 ## Project Links
 
 - [Website](https://alysiscode.com/)

{alysis_code-0.13.7 → alysis_code-0.13.8}/README.md

@@ -93,8 +93,10 @@ sandbox only when explicitly configured with `verify_sandbox.mode="off"` or
 
 Two layers control what the agent may do — one enforces, one focuses.
 
-**Execution modes** are the enforcement layer. Choose one per command with `--mode`, switch in chat
-with `/mode`, or set a default with `alysis-code config set default_mode <mode>`:
+**Execution modes** are the enforcement layer. Choose one per command with `--mode`, select the
+next message's permissions with `/permissions` or **Shift+Tab**, or set a default with
+`alysis-code config set default_mode <mode>`. A selection leaves the active turn's permissions
+unchanged until the next message starts:
 
 | Mode | Behavior |
 | --- | --- |
@@ -117,6 +119,10 @@ A persona is a convention, never a permission: it can keep or lower your executi
 never raise it. Define your own in `.alysis_personas/*.md`.
 [Learn more](https://alysiscode.com/docs/concepts/personas)
 
+Use `/persona architect` for planning in chat, or `/forge` for a plan-driven execution workflow.
+The legacy chat Plan Mode and its `/plan` commands have been removed; Forge retains its plan views
+and editor. Persona changes made during a running turn apply after that turn finishes.
+
 ## Project Links
 
 - [Website](https://alysiscode.com/)

{alysis_code-0.13.7 → alysis_code-0.13.8}/docs/CHANGELOG.md

@@ -8,6 +8,43 @@ Notable user-facing changes to Alysis Code are recorded here. This project follo
 
 No user-facing changes yet.
 
+## [0.13.8] - 2026-09-16
+
+### Changed
+
+- Remove legacy chat Plan Mode, its draft/approve flow, and its prompts and toolbar
+  state. Use the Architect persona for planning in chat; Forge retains its plan views
+  and editor.
+- Replace `/mode` with `/permissions`. Permission selections and Shift+Tab apply to
+  the next user message, with the pending choice visible beside the active permissions.
+- Apply persona changes and approved persona-switch proposals only after the active
+  turn finishes. Preserve pending permission selections when resuming a conversation.
+- Show pending steering messages and queued follow-ups. Shift+Left recalls the newest
+  queued message for editing. Interruptions preserve undelivered work and wait for the
+  current worker to finish before another turn starts.
+- Read large Git diffs in complete pages with a content identifier that detects
+  changes between pages. The agent can select a path or inspect staged changes.
+- Allow a background-process wait of up to 900 seconds, bounded by the remaining
+  run budget and returning early when its requested condition is met.
+- Explain how to correct rejected verification commands, including how to use the
+  session's configured verification contract.
+
+### Fixed
+
+- Keep plain assistant replies in conversation history so follow-up requests retain
+  the previous answer even when the provider returns no extra metadata.
+- Redact credential fields inside nested JSON, tool arguments, feedback text, and
+  support bundles. Omit data that exceeds the safe redaction depth and non-UTF-8
+  diagnostic artifacts that cannot be sanitized reliably.
+- Clean up incomplete support bundles after cancellation or I/O errors, support long
+  Windows export paths, and open report drafts without disrupting terminal output.
+- Inspect Git changes without running configured diff programs, text converters,
+  filesystem monitors, or content filters. Worktree reads that require content
+  filters or submodule helpers return guidance for an approved shell command;
+  staged diffs and unaffected scoped paths remain available.
+- Preserve hosted-account explanations for rolling usage limits, concurrent requests,
+  reserved credits, and temporary routing or capacity problems.
+
 ## [0.13.7] - 2026-09-11
 
 ### Added
@@ -271,7 +308,8 @@ Public launch and repository-layout refresh.
 Release notes for versions before 0.9.8 remain available in the
 [GitHub Releases archive](https://github.com/AlysisAi/alysis-code/releases).
 
-[Unreleased]: https://github.com/AlysisAi/alysis-code/compare/v0.13.7...HEAD
+[Unreleased]: https://github.com/AlysisAi/alysis-code/compare/v0.13.8...HEAD
+[0.13.8]: https://github.com/AlysisAi/alysis-code/compare/v0.13.7...v0.13.8
 [0.13.7]: https://github.com/AlysisAi/alysis-code/compare/v0.13.6.2...v0.13.7
 [0.13.6.2]: https://github.com/AlysisAi/alysis-code/compare/v0.13.6.1...v0.13.6.2
 [0.13.6.1]: https://github.com/AlysisAi/alysis-code/compare/v0.13.6...v0.13.6.1

{alysis_code-0.13.7 → alysis_code-0.13.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "alysis-code"
-version = "0.13.7"
+version = "0.13.8"
 description = "Open-source coding agent for hosted and local models."
 readme = "README.md"
 requires-python = ">=3.11"

{alysis_code-0.13.7 → alysis_code-0.13.8}/src/alysis_code/__init__.py

@@ -1,3 +1,3 @@
 __all__ = ["__version__"]
 
-__version__ = "0.13.7"
+__version__ = "0.13.8"

{alysis_code-0.13.7 → alysis_code-0.13.8}/src/alysis_code/agent/prompt_context.py

@@ -22,7 +22,6 @@ from ..extensions.activation import (
 from ..extensions.models import normalize_extension_id, plugin_slug_from_id
 from ..extensions.state import load_global_state, load_project_state
 from ..personas import DEFAULT_PERSONA, normalize_persona, persona_modes_enabled
-from ..plan_mode import extract_approved_plan_user_message
 from ..repo_scan import (
     _MANIFEST_SPECS,
     _README_NAMES,
@@ -1460,10 +1459,7 @@ def _build_repo_task_brief_message(
     }:
         return None
 
-    clean = (
-        extract_approved_plan_user_message(pending_instruction)
-        or str(pending_instruction or "").strip()
-    )
+    clean = str(pending_instruction or "").strip()
     if not clean or _is_host_managed_user_context_message(clean):
         return None
     if clean[:1] in {"/", ":"} and "\n" not in clean:
@@ -1828,11 +1824,10 @@ def refresh_session_task_brief_from_observed_turn(
         return False
     messages_obj, existing_index, current_content, inserted_placeholder = ensured
 
-    approved_plan_message = extract_approved_plan_user_message(instruction)
-    if not approved_plan_message and material_edit_count <= 0:
+    if material_edit_count <= 0:
         return inserted_placeholder
 
-    clean = approved_plan_message or str(instruction or "").strip()
+    clean = str(instruction or "").strip()
     if not clean or _is_host_managed_user_context_message(clean):
         return inserted_placeholder
     if clean[:1] in {"/", ":"} and "\n" not in clean:
@@ -2090,9 +2085,6 @@ def _build_user_message(
     image_paths: list[str] | None,
 ) -> tuple[dict[str, Any], dict[str, Any]]:
     log_payload: dict[str, Any] = {"content": instruction}
-    display_content = extract_approved_plan_user_message(instruction)
-    if display_content and display_content != instruction:
-        log_payload["display_content"] = display_content
     if not image_paths:
         return {"role": "user", "content": instruction}, log_payload
 

{alysis_code-0.13.7 → alysis_code-0.13.8}/src/alysis_code/agent/session.py

@@ -552,7 +552,7 @@ class AgentSession:
     persona: str = "code"
     # The user's chosen execution mode remembered while a narrowing persona
     # (architect/ask) is active, so switching back to code/debug restores it.
-    # None when the active persona narrows nothing. An explicit /mode <exec>
+    # None when the active persona narrows nothing. An explicit /permissions <exec>
     # always wins and clears the restore point (and restores the write scope).
     persona_restore_mode: str | None = None
     # The user's base allow_write_globs snapshotted alongside
@@ -1292,15 +1292,21 @@ class AgentSession:
         )
         if rewrite_payload is not None:
             self.store.append("final_summary_rewrite", rewrite_payload)
-        assistant_message = None
+        # Keep ordinary text replies in history so follow-up requests retain the
+        # assistant turn even when the provider supplies no opaque metadata.
+        assistant_message = (
+            None if internal_fallback else {"role": "assistant", "content": emitted_text}
+        )
         if assistant_response is not None:
-            candidate_message = assistant_message_from_response(
+            assistant_message = assistant_message_from_response(
                 assistant_response,
                 content=emitted_text,
             )
-            if PROVIDER_METADATA_KEY in candidate_message:
-                assistant_message = candidate_message
-        extra_payload = {"message": assistant_message} if assistant_message is not None else None
+        extra_payload = (
+            {"message": assistant_message}
+            if assistant_message is not None and PROVIDER_METADATA_KEY in assistant_message
+            else None
+        )
         if internal_fallback and self.subagent_depth > 0:
             # A nested run's locally generated stop report is internal state. The
             # nested surface forwards assistant messages up to the parent's panel,

{alysis_code-0.13.7 → alysis_code-0.13.8}/src/alysis_code/agent/steering.py

@@ -15,13 +15,64 @@ steps, and must persist across resume.
 from __future__ import annotations
 
 from collections import deque
+from dataclasses import dataclass
 from threading import Event, RLock
+from typing import Any
 
 MAX_STEER_MESSAGE_CHARS = 4000
 MAX_PENDING_STEER_MESSAGES = 16
+MAX_PENDING_OPS = 16
 _TRUNCATION_MARKER = " [truncated]"
 
 
+@dataclass(frozen=True)
+class ResolvedOperation:
+    """A validated operation that is safe for worker-thread application."""
+
+    kind: str
+    payload: Any
+    display_label: str
+
+
+class OpsInbox:
+    """Bounded, thread-safe FIFO for resolved mid-turn operations."""
+
+    __slots__ = ("_lock", "_operations")
+
+    def __init__(self) -> None:
+        self._lock = RLock()
+        self._operations: deque[ResolvedOperation] = deque()
+
+    def send(self, operation: ResolvedOperation) -> bool:
+        """Queue ``operation`` or return False when the inbox is full."""
+        if not isinstance(operation, ResolvedOperation):
+            raise TypeError("operation must be a ResolvedOperation")
+        with self._lock:
+            if len(self._operations) >= MAX_PENDING_OPS:
+                return False
+            self._operations.append(operation)
+            return True
+
+    def drain(self) -> list[ResolvedOperation]:
+        """Remove and return all pending operations, oldest first."""
+        with self._lock:
+            if not self._operations:
+                return []
+            operations = list(self._operations)
+            self._operations.clear()
+            return operations
+
+    def snapshot(self) -> list[ResolvedOperation]:
+        """Return pending operations in FIFO order without removing them."""
+        with self._lock:
+            return list(self._operations)
+
+    def pending_count(self) -> int:
+        """Return the number of operations waiting for application."""
+        with self._lock:
+            return len(self._operations)
+
+
 def _normalize_steer_message(message: str) -> str:
     normalized = str(message or "").strip()
     if not normalized:
@@ -160,6 +211,21 @@ def wait_signal_digest(signals: list[dict[str, str]]) -> dict[str, object]:
     }
 
 
+def ops_inbox_for(session: object, *, create: bool = False) -> OpsInbox | None:
+    """Return a session's ops inbox, optionally attaching one as an attribute."""
+    existing = getattr(session, "ops_inbox", None)
+    if isinstance(existing, OpsInbox):
+        return existing
+    if not create:
+        return None
+    inbox = OpsInbox()
+    try:
+        session.ops_inbox = inbox  # type: ignore[attr-defined]
+    except Exception:  # noqa: BLE001 - frozen or slotted sessions opt out
+        return None
+    return inbox
+
+
 def steer_inbox_for(session: object, *, create: bool = False) -> SteerInbox | None:
     """Return a session's inbox, optionally attaching one as a plain attribute."""
     existing = getattr(session, "steer_inbox", None)

{alysis_code-0.13.7 → alysis_code-0.13.8}/src/alysis_code/agent/tools_assembly.py

@@ -154,6 +154,7 @@ from ..usage_tracker import UsageSummary
 from ..verification_command_analysis import (
     VerificationCommandEvidentiaryCapability,
     analyze_verification_command,
+    verification_rejection_guidance,
 )
 from ..verify_gate import (
     ResolvedVerifyCommands,
@@ -696,6 +697,11 @@ _READONLY_MAIN_SESSION_BUILTIN_TOOL_NAMES = frozenset(
 _READONLY_TOP_LEVEL_WEB_TOOL_NAMES = frozenset({"web_fetch", "web_search"})
 
 
+# Long builds can wait once instead of forcing repeated model calls. The wait
+# still returns on completion, responds to cancellation, and is clamped to the
+# remaining run budget by _clamp_shell_wait_seconds.
+_MAX_SHELL_WAIT_SECONDS = 900.0
+
 # Out-of-band channel for handing the turn's cancellation token to the shell
 # wait path, mirroring _SUBAGENT_CANCELLATION_TOKEN_ARG. The key is an object()
 # rather than a string so it can never collide with a model-supplied argument,
@@ -3076,6 +3082,15 @@ def build_tools(
         )
         trusted_shell_commands = trusted_shell_expression_command_set(current_selection)
 
+        def _invalid_command_message(reason: str) -> str:
+            # Keep the machine-readable reason token (anything parsing the error
+            # still works) and append the concrete fix, so a rejection reads as
+            # "here is how to make this a usable check" rather than as a test
+            # failure the model tries to "repair" by rewriting working code.
+            guidance = verification_rejection_guidance(reason)
+            base = "verification command is invalid: " + reason
+            return f"{base} -- {guidance}" if guidance else base
+
         def _validate_explicit_verify_candidate(command: str) -> None:
             normalized_exact = " ".join(str(command or "").strip().split())
             trusted = normalized_exact in trusted_shell_commands
@@ -3085,9 +3100,9 @@ def build_tools(
                 workspace_root=root,
             )
             if analysis.rejection_reason:
-                raise VerifyError("verification command is invalid: " + analysis.rejection_reason)
+                raise VerifyError(_invalid_command_message(analysis.rejection_reason))
             if _has_disallowed_shell_control_flow(command) and not trusted:
-                raise VerifyError("verification command is invalid: disallowed_shell_control_flow")
+                raise VerifyError(_invalid_command_message("disallowed_shell_control_flow"))
 
         selection_metadata = verification_selection_payload(
             current_selection
@@ -3144,7 +3159,11 @@ def build_tools(
             )
             if incompatible_commands:
                 raise VerifyError(
-                    "verify_run commands must stay within the session's effective verification contract."
+                    "verify_run commands must stay within the session's effective verification "
+                    "contract. Omit the `commands` argument to run the resolved contract "
+                    f"({', '.join(current_effective_verification_commands)}), or run your own "
+                    "command with shell_run -- a passing shell_run of the project's test command "
+                    "also counts as verification evidence."
                 )
             commands = requested_commands
         elif verify_cmd is not None and unavailable_verification_contract:
@@ -3188,13 +3207,15 @@ def build_tools(
                 workspace_root=root,
             )
             if analysis.rejection_reason:
-                raise VerifyError("verification command is invalid: " + analysis.rejection_reason)
+                raise VerifyError(_invalid_command_message(analysis.rejection_reason))
             if (
                 _has_disallowed_shell_control_flow(command)
                 and normalized_exact not in trusted_shell_commands
             ):
                 raise VerifyError(
-                    "verification commands must be single commands without shell control flow or chaining."
+                    "verification commands must be single commands without shell control flow or "
+                    "chaining. Pass just the test command (e.g. `pytest -q`); a leading "
+                    "`cd <dir> &&` is fine, but move other setup into a separate shell_run."
                 )
         guard_verify(commands)
         workspace_services = _workspace_services_before_verification()
@@ -3644,7 +3665,7 @@ def build_tools(
             raise AgentRuntimeError(f"Invalid wait_seconds value: {raw_wait!r}") from exc
         if wait_seconds < 0:
             raise AgentRuntimeError("wait_seconds must be non-negative")
-        return min(wait_seconds, 60.0)
+        return min(wait_seconds, _MAX_SHELL_WAIT_SECONDS)
 
     def _coerce_shell_max_bytes(raw_max_bytes: Any) -> int | None:
         if raw_max_bytes is None:
@@ -4315,7 +4336,13 @@ def build_tools(
 
     _append_builtin_tool(
         "git_diff",
-        run=lambda _args: git_diff(root=root),
+        run=lambda args: git_diff(
+            root=root,
+            path=args.get("path"),
+            staged=bool(args.get("staged", False)),
+            offset=args.get("offset", 0),
+            diff_id=args.get("diff_id"),
+        ),
     )
 
     if git_backed_workspace:

{alysis_code-0.13.7 → alysis_code-0.13.8}/src/alysis_code/agent/turn/core.py

@@ -165,7 +165,12 @@ from ..sensitive_output import (
     redact_sensitive_tool_result,
     sensitive_tool_boundary,
 )
-from ..steering import build_steer_messages, steer_inbox_for, wait_signal_digest
+from ..steering import (
+    build_steer_messages,
+    ops_inbox_for,
+    steer_inbox_for,
+    wait_signal_digest,
+)
 from ..subagent_execution import _SUBAGENT_PREASSIGNED_RUN_ID_ARG
 from ..tools_assembly import (
     _SHELL_CANCELLABLE_WAIT_TOOL_NAMES,
@@ -1698,9 +1703,16 @@ def run_turn(
         self.messages = copy.deepcopy(pre_turn_messages)
         _set_session_pinned_prefix_len(self, pre_turn_pinned_prefix_len)
         if steered_pending_restore:
+            restored_steers = list(steered_pending_restore)
             rollback_inbox = steer_inbox_for(self)
             if rollback_inbox is not None:
-                rollback_inbox.restore_front(steered_pending_restore)
+                rollback_inbox.restore_front(restored_steers)
+                notify_restored = getattr(self.surface, "on_steer_messages_restored", None)
+                if callable(notify_restored):
+                    try:
+                        notify_restored(restored_steers)
+                    except Exception:
+                        pass
             steered_pending_restore.clear()
         self.store.append(
             "warning",
@@ -3901,7 +3913,6 @@ def run_turn(
             return _deadline_exhausted_result("step_loop", step=step)
         _throw_if_cancelled()
         steps_attempted = step
-        stream_used = self.stream
         step_ephemeral_suffix_system_messages: list[str] = []
         remaining_tool_steps_after_this = None if turn_max_steps is None else turn_max_steps - step
         if remaining_tool_steps_after_this == 0:
@@ -4084,6 +4095,55 @@ def run_turn(
         # plain callable attribute keeps every chat() signature unchanged.
         _on_text_delta.stream_restart = _on_stream_restart  # type: ignore[attr-defined]
 
+        # Apply resolved operations before user steering at the worker-thread
+        # step boundary. The UI validates and queues these operations, but only
+        # this worker owns mutations to state read by an active turn.
+        ops_inbox = ops_inbox_for(self)
+        if ops_inbox is not None:
+            try:
+                staged_operations = ops_inbox.drain()
+            except Exception as exc:  # noqa: BLE001 - staged ops cannot fail a turn
+                self.store.append(
+                    "warning",
+                    {
+                        "warning": "staged_operation_delivery_failed",
+                        "step": step,
+                        "error": str(exc),
+                    },
+                )
+            else:
+                apply_staged_operation = getattr(self, "apply_staged_operation", None)
+                for staged_operation in staged_operations:
+                    label = str(staged_operation.display_label or staged_operation.kind).strip()
+                    try:
+                        if not callable(apply_staged_operation):
+                            raise RuntimeError("no staged-operation apply handler is attached")
+                        apply_staged_operation(staged_operation)
+                    except Exception as exc:  # noqa: BLE001 - drop this op, keep turn alive
+                        self.store.append(
+                            "warning",
+                            {
+                                "warning": "staged_operation_apply_failed",
+                                "kind": staged_operation.kind,
+                                "step": step,
+                                "error": str(exc),
+                            },
+                        )
+                        _emit_surface_error(
+                            self.surface,
+                            "staged_operation_apply_failed",
+                            f"{label} - failed to apply: {exc}",
+                            True,
+                        )
+                        continue
+                    self.store.append(
+                        "staged_operation_applied",
+                        {"kind": staged_operation.kind, "step": step},
+                    )
+                    emit_info = getattr(self.surface, "emit_info", None)
+                    if callable(emit_info):
+                        emit_info(f"{label} - applied")
+
         # Drain user steering at the worker-thread step boundary. The previous
         # step's tool results are already committed, so this cannot split tool
         # call/result adjacency. It is also before compaction, so any replacement
@@ -4118,6 +4178,9 @@ def run_turn(
                         },
                     )
 
+        # Streaming is a per-step setting. Read it only after staged operations
+        # have applied so a mid-turn toggle affects this boundary's LLM call.
+        stream_used = self.stream
         request_messages = _request_messages_for_step(self.messages)
         try:
             if self.conversation_compactor is not None: