kiwimatecoder 0.1.0__tar.gz → 0.2.0__tar.gz

{kiwimatecoder-0.1.0 → kiwimatecoder-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kiwimatecoder
-Version: 0.1.0
+Version: 0.2.0
 Summary: AI-powered coding assistant CLI. Bring your own API key.
 License: MIT License
         
@@ -217,6 +217,7 @@ paths outside the workspace root; writes stay sandboxed.
 | `/dry-run [on\|off\|toggle]` | Preview mutating actions without running them. |
 | `/undo [count]`, `/checkpoints` | Restore files changed by recent tools, or list checkpoints. |
 | `/todos` | Show the agent's task list. |
+| `/goal [--rounds N] <objective>`, `/goal pause\|resume\|clear` | Keep the agent working on an objective across rounds until it reports the goal achieved or blocked, or the round limit is reached. Bare `/goal` shows the current goal (see [Goals](#goals)). |
 | `/templates` | List custom prompt templates discovered in the workspace and user command directories. |
 | `/compact [budget]` | Trim older history to fit a token budget. |
 | `/save`, `/load`, `/sessions`, `/fork [name]`, `/export [path]` | Save, resume, branch, or export sessions as Markdown. |
@@ -316,6 +317,8 @@ The assistant has these capabilities, all scoped to the workspace:
 - `shell_jobs` — start, list, read, or kill detached background commands
   (approval-gated; see below).
 - `update_todos` — keep the visible task list in sync with multi-step work.
+- `update_goal` — report progress on, or the outcome of, a `/goal`. It is only
+  offered to the model while a goal is active (see Goals below).
 - `task` — delegate a focused investigation to a subagent with its own context
   (approval-gated; see below).
 - `ask_user` — ask a clarifying question with optional choices (interactive
@@ -1659,6 +1662,38 @@ kiwimatecoder config verify show
 kiwimatecoder config verify clear
 ```
 
+## Goals
+
+`/goal` keeps the agent working on an objective across several rounds, so a
+larger task can run without you prompting each step:
+
+```text
+/goal make every test in tests/parser pass without changing expected output
+/goal --rounds 20 migrate the config loader to TOML
+/goal
+/goal pause
+/goal resume
+/goal clear
+```
+
+Each round is an ordinary agent turn. After a round, the agent starts another
+unless it reports the goal with `update_goal`:
+
+- `achieved`, once it has checked the result (the summary says how);
+- `blocked`, when it needs something only you can provide (the summary says what).
+
+A goal also pauses when the round limit is reached (10 by default, up to 100
+with `--rounds`), when a round ends abnormally (the budget is spent, the provider
+fails, or the tool-call limit is hit), or when you press Ctrl-C or run
+`/goal pause`. Messages you type during a round steer it, as usual.
+`/goal resume` gives it a fresh round allowance. A goal saved with `/save`
+comes back paused, so nothing runs until you resume it.
+
+Permission prompts still apply to every tool call. For an unattended run, pick
+`/mode auto-accept`, or answer `a` (always) at a prompt for the tools you trust.
+If the objective starts with a word such as `clear`, put `--` first:
+`/goal -- clear the build cache and rerun the tests`.
+
 ## Budgets
 
 Cap a session's spend by tokens, cost, or both. The agent warns at 80% and

{kiwimatecoder-0.1.0 → kiwimatecoder-0.2.0}/README.md

@@ -176,6 +176,7 @@ paths outside the workspace root; writes stay sandboxed.
 | `/dry-run [on\|off\|toggle]` | Preview mutating actions without running them. |
 | `/undo [count]`, `/checkpoints` | Restore files changed by recent tools, or list checkpoints. |
 | `/todos` | Show the agent's task list. |
+| `/goal [--rounds N] <objective>`, `/goal pause\|resume\|clear` | Keep the agent working on an objective across rounds until it reports the goal achieved or blocked, or the round limit is reached. Bare `/goal` shows the current goal (see [Goals](#goals)). |
 | `/templates` | List custom prompt templates discovered in the workspace and user command directories. |
 | `/compact [budget]` | Trim older history to fit a token budget. |
 | `/save`, `/load`, `/sessions`, `/fork [name]`, `/export [path]` | Save, resume, branch, or export sessions as Markdown. |
@@ -275,6 +276,8 @@ The assistant has these capabilities, all scoped to the workspace:
 - `shell_jobs` — start, list, read, or kill detached background commands
   (approval-gated; see below).
 - `update_todos` — keep the visible task list in sync with multi-step work.
+- `update_goal` — report progress on, or the outcome of, a `/goal`. It is only
+  offered to the model while a goal is active (see Goals below).
 - `task` — delegate a focused investigation to a subagent with its own context
   (approval-gated; see below).
 - `ask_user` — ask a clarifying question with optional choices (interactive
@@ -1618,6 +1621,38 @@ kiwimatecoder config verify show
 kiwimatecoder config verify clear
 ```
 
+## Goals
+
+`/goal` keeps the agent working on an objective across several rounds, so a
+larger task can run without you prompting each step:
+
+```text
+/goal make every test in tests/parser pass without changing expected output
+/goal --rounds 20 migrate the config loader to TOML
+/goal
+/goal pause
+/goal resume
+/goal clear
+```
+
+Each round is an ordinary agent turn. After a round, the agent starts another
+unless it reports the goal with `update_goal`:
+
+- `achieved`, once it has checked the result (the summary says how);
+- `blocked`, when it needs something only you can provide (the summary says what).
+
+A goal also pauses when the round limit is reached (10 by default, up to 100
+with `--rounds`), when a round ends abnormally (the budget is spent, the provider
+fails, or the tool-call limit is hit), or when you press Ctrl-C or run
+`/goal pause`. Messages you type during a round steer it, as usual.
+`/goal resume` gives it a fresh round allowance. A goal saved with `/save`
+comes back paused, so nothing runs until you resume it.
+
+Permission prompts still apply to every tool call. For an unattended run, pick
+`/mode auto-accept`, or answer `a` (always) at a prompt for the tools you trust.
+If the objective starts with a word such as `clear`, put `--` first:
+`/goal -- clear the build cache and rerun the tests`.
+
 ## Budgets
 
 Cap a session's spend by tokens, cost, or both. The agent warns at 80% and

{kiwimatecoder-0.1.0 → kiwimatecoder-0.2.0}/kiwimatecoder/agent.py

@@ -116,6 +116,9 @@ class Agent:
         self.confirm = confirm
         self.bus = bus if bus is not None else events.BUS
         self._budget_warned = False
+        # Why the most recent run_turn ended ("stop", "budget", ...); the REPL
+        # reads it to decide whether a /goal keeps going. None while a turn runs.
+        self.last_stop_reason: str | None = None
         self.ascii_mode = bool(ascii_mode)
         self.output_mode = output_mode if output_mode in ui.OUTPUT_MODES else "normal"
         self.event_handler = event_handler
@@ -133,6 +136,11 @@ class Agent:
         except Exception:
             _log.debug("event handler failed for %s", name, exc_info=True)
 
+    def _done(self, reason: str, **payload: Any) -> None:
+        """Record how a turn ended, then tell the event handler."""
+        self.last_stop_reason = reason
+        self._emit("done", reason=reason, **payload)
+
     def _redacted_args(self, args: dict[str, Any]) -> dict[str, Any]:
         """Return a JSON-safe copy of tool arguments with secrets redacted."""
         try:
@@ -211,10 +219,11 @@ class Agent:
 
     async def run_turn(self, user_input: str) -> None:
         """Process one user message, looping over tool calls until the model stops."""
+        self.last_stop_reason = None
         blocked, reason = self._budget_exceeded()
         if blocked:
             self.console.print(f"[red]{escape(reason)}[/red]")
-            self._emit("done", reason="budget", error=reason)
+            self._done("budget", error=reason)
             return
 
         from kiwimatecoder.config import get_model_routing
@@ -246,7 +255,7 @@ class Agent:
             except ProviderError as exc:
                 self.console.print(f"\n[red]{escape(str(exc))}[/red]")
                 self._emit("error", kind="provider", error=str(exc))
-                self._emit("done", reason="provider_error")
+                self._done("provider_error")
                 return
 
             self.session.messages.append(assistant_msg)
@@ -260,11 +269,11 @@ class Agent:
                     # The model must answer the steered message.
                     continue
                 self._warn_budget()
-                self._emit("done", reason="stop")
+                self._done("stop")
                 return
 
             if self.max_turns is not None and tool_turns >= self.max_turns:
-                self._emit("done", reason="max_turns", limit=self.max_turns)
+                self._done("max_turns", limit=self.max_turns)
                 return
             edited = await self._handle_tool_calls(tool_calls) or edited
             tool_turns += 1
@@ -384,9 +393,11 @@ class Agent:
         rest as a second line of defense). Subagents never see ``task`` (no
         nested subagents) or ``ask_user`` (no interactive user), and ``task``
         is hidden for everyone while subagents are disabled. ``browser`` is
-        hidden until browser automation is enabled in config.
+        hidden until browser automation is enabled in config. ``update_goal``
+        is offered only while a /goal is active.
         """
         from kiwimatecoder.config import get_browser, get_subagents
+        from kiwimatecoder.goal import ACTIVE
 
         schemas = tools.tool_schemas(
             read_only=self.session.mode is PermissionMode.PLAN
@@ -398,6 +409,9 @@ class Agent:
             excluded.add("task")
         if not get_browser()["enabled"]:
             excluded.add("browser")
+        goal = self.session.goal
+        if goal is None or goal.status != ACTIVE:
+            excluded.add("update_goal")
         if excluded:
             schemas = [
                 schema

{kiwimatecoder-0.1.0 → kiwimatecoder-0.2.0}/kiwimatecoder/commands.py

@@ -18,6 +18,7 @@ from rich.markup import escape
 from rich.panel import Panel
 from rich.table import Table
 
+from kiwimatecoder import goal as goal_module
 from kiwimatecoder import tools
 from kiwimatecoder import media as media_module
 from kiwimatecoder import memory as memory_module
@@ -956,13 +957,17 @@ def _expand_context_input(
     if pattern.is_absolute() or pattern.root or pattern.drive:
         return [], [f"Glob patterns must be relative to the workspace: {raw_path}"]
 
+    # Python 3.10-3.12 raise ValueError for "a**b", but 3.13 just returns no matches,
+    # so the rule is checked here: '**' is a wildcard only as a whole path component.
+    if any("**" in part and part != "**" for part in pattern.parts):
+        return [], ["Invalid glob pattern: '**' can only be an entire path component"]
+
     root = session.workspace_root.resolve()
     errors: list[str] = []
     matches: list[Path] = []
     try:
         candidates = sorted(root.glob(raw_path))
     except (NotImplementedError, ValueError, OSError) as exc:
-        # e.g. "a**b": '**' can only be an entire path component
         return [], [f"Invalid glob pattern: {exc}"]
     for candidate in candidates:
         try:
@@ -6279,6 +6284,92 @@ def _media(
     return CommandResult.CONTINUE
 
 
+def _goal(arg: str, session: Session, console: Console) -> str:
+    """Show, set, pause, resume or clear the session goal (see kiwimatecoder.goal).
+
+    Setting or resuming a goal only marks it due; the REPL runs the rounds once
+    this command returns.
+    """
+    try:
+        command = goal_module.parse_goal_command(arg)
+    except ValueError as exc:
+        console.print(f"[yellow]{escape(str(exc))}[/yellow]")
+        return CommandResult.CONTINUE
+
+    goal = session.goal
+    if command.verb == "show":
+        _print_goal(goal, console)
+    elif command.verb == "set":
+        session.goal = goal_module.new_goal(command.objective, command.max_rounds)
+        console.print(
+            f"[green]Goal set[/green] (up to {session.goal.max_rounds} rounds): "
+            f"{escape(session.goal.objective)}"
+        )
+        console.print(
+            "[dim]Ctrl-C stops it. Permission prompts still apply; /mode auto-accept "
+            "lets it run unattended.[/dim]"
+        )
+    elif command.verb == "pause":
+        if goal is None or goal.status != goal_module.ACTIVE:
+            console.print("[yellow]No running goal to pause.[/yellow]")
+        else:
+            # Not due means a round is in progress, which finishes before the pause.
+            running = not goal.due
+            goal_module.pause(goal, "paused by you")
+            console.print(
+                "[yellow]Goal will pause after the current round.[/yellow]"
+                if running
+                else "[yellow]Goal paused.[/yellow]"
+            )
+            console.print("[dim]/goal resume continues it.[/dim]")
+    elif command.verb == "resume":
+        if goal is None:
+            console.print("[yellow]No goal to resume. Set one with /goal <objective>.[/yellow]")
+        elif goal.status == goal_module.ACHIEVED:
+            console.print(
+                "[dim]That goal is already achieved. Set a new one with /goal <objective>.[/dim]"
+            )
+        elif goal.status == goal_module.ACTIVE:
+            console.print("[dim]The goal is already running.[/dim]")
+        else:
+            goal_module.resume(goal)
+            console.print(f"[green]Resuming goal[/green] (up to {goal.max_rounds} more rounds).")
+    elif command.verb == "clear":
+        if goal is None:
+            console.print("[dim]No goal to clear.[/dim]")
+        else:
+            session.goal = None
+            console.print("[dim]Goal cleared.[/dim]")
+    return CommandResult.CONTINUE
+
+
+def _print_goal(goal: goal_module.Goal | None, console: Console) -> None:
+    if goal is None:
+        console.print("[dim]No goal set. Start one with /goal <objective>.[/dim]")
+        return
+    detail = f"{goal.status}, round {goal.rounds} of {goal.max_rounds}"
+    if not goal.rounds:
+        detail = f"{goal.status}, up to {goal.max_rounds} rounds"
+    console.print(f"[bold]Goal:[/bold] {escape(goal.objective)}")
+    console.print(f"Status: {escape(detail)}")
+    if goal.progress:
+        console.print(f"Last progress: {escape(goal.progress)}")
+    labels = {
+        goal_module.ACHIEVED: "Result",
+        goal_module.BLOCKED: "Needs",
+        goal_module.PAUSED: "Why",
+    }
+    if goal.outcome and goal.status in labels:
+        console.print(f"{labels[goal.status]}: {escape(goal.outcome)}")
+    hints = {
+        goal_module.ACTIVE: "Running. /goal pause stops it after this round.",
+        goal_module.PAUSED: "/goal resume continues it. /goal clear drops it.",
+        goal_module.BLOCKED: "Answer the question above, then /goal resume.",
+        goal_module.ACHIEVED: "Done. Set a new goal with /goal <objective>.",
+    }
+    console.print(f"[dim]{hints[goal.status]}[/dim]")
+
+
 _COMMANDS: dict[str, Callable[[str, Session, Console], str]] = {
     "help": _help,
     "exit": _exit,
@@ -6311,6 +6402,7 @@ _COMMANDS: dict[str, Callable[[str, Session, Console], str]] = {
     "rewind": _undo,
     "checkpoints": _checkpoints,
     "todos": _todos,
+    "goal": _goal,
     "memory": _memory,
     "compact": _compact,
     "index": _index,
@@ -6400,6 +6492,12 @@ _HELP_GROUPS = [
             ("/undo [count]", "Restore files changed by recent tool actions."),
             ("/checkpoints", "List captured file checkpoints."),
             ("/todos", "Show the agent's task list."),
+            (
+                "/goal [--rounds N] <objective> | pause | resume | clear",
+                "Work toward an objective across rounds until the agent reports it "
+                "achieved or blocked, or the round limit (default 10) is reached. "
+                "Bare /goal shows the current goal.",
+            ),
             (
                 "/memory [list|add|add-user|clear]",
                 "Show or edit persistent project and user memory.",
@@ -6534,6 +6632,7 @@ _COMMAND_DESCRIPTIONS = {
     "rewind": "Alias for /undo.",
     "checkpoints": "List captured file checkpoints.",
     "todos": "Show the agent's task list.",
+    "goal": "Work toward an objective across rounds, or show, pause, resume, or clear it.",
     "memory": "Show or edit persistent project and user memory.",
     "compact": "Trim older history to fit a token budget.",
     "index": "Show, refresh, or delete the codebase index used by semantic search.",
@@ -6576,6 +6675,12 @@ _MODE_DESCRIPTIONS = {
     "plan": "Read-only planning mode.",
 }
 
+_GOAL_ACTION_DESCRIPTIONS = {
+    "pause": "Stop the goal after the current round.",
+    "resume": "Continue a paused or blocked goal.",
+    "clear": "Drop the goal.",
+}
+
 _MEMORY_ACTION_DESCRIPTIONS = {
     "list": "Show project and user memory.",
     "add": "Append a fact to project memory.",
@@ -6717,6 +6822,8 @@ def slash_argument_completions(
         choices = _MODE_DESCRIPTIONS
     elif command == "memory":
         choices = _MEMORY_ACTION_DESCRIPTIONS
+    elif command == "goal":
+        choices = _GOAL_ACTION_DESCRIPTIONS
     elif command == "index":
         choices = _INDEX_ACTION_DESCRIPTIONS
     elif command == "model" and session is not None:

kiwimatecoder-0.2.0/kiwimatecoder/goal.py

@@ -0,0 +1,229 @@
+"""Session goals: an objective the agent keeps working on across rounds.
+
+``/goal <objective>`` sets one and the REPL runs agent rounds back to back until
+the model reports it achieved or blocked, the round cap is reached, or a round
+ends abnormally (budget, provider error, tool-call limit, Ctrl-C). This module
+holds the state and builds the prompts; the REPL drives the rounds.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from typing import Any
+
+ACTIVE = "active"
+PAUSED = "paused"
+ACHIEVED = "achieved"
+BLOCKED = "blocked"
+STATUSES = (ACTIVE, PAUSED, ACHIEVED, BLOCKED)
+
+DEFAULT_MAX_ROUNDS = 10
+MAX_ROUNDS_LIMIT = 100
+MAX_OBJECTIVE_CHARS = 4000
+
+# Why a round ended, from the agent's "done" reason. Anything but a normal stop
+# pauses the goal, and the reason is shown so the user knows what happened.
+_STOP_REASONS = {
+    "interrupted": "you interrupted it",
+    "budget": "the budget is spent",
+    "provider_error": "the provider returned an error",
+    "max_turns": "the tool-call limit was reached",
+}
+
+_USAGE = (
+    "Usage: /goal <objective> · /goal --rounds N <objective> · "
+    "/goal pause | resume | clear · /goal"
+)
+_ROUNDS_FLAG = re.compile(r"^--rounds(?=\s|$)\s*(\S*)\s*(.*)$", re.DOTALL)
+
+
+@dataclass
+class Goal:
+    """One standing objective and how far the agent has got with it."""
+
+    objective: str
+    max_rounds: int = DEFAULT_MAX_ROUNDS
+    status: str = ACTIVE
+    rounds: int = 0  # rounds run since the goal was set or last resumed
+    progress: str = ""  # latest in_progress note from update_goal
+    outcome: str = ""  # summary given with achieved/blocked, or why it paused
+    due: bool = True  # runtime only: another round should run now
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "objective": self.objective,
+            "max_rounds": self.max_rounds,
+            "status": self.status,
+            "rounds": self.rounds,
+            "progress": self.progress,
+            "outcome": self.outcome,
+        }
+
+    @classmethod
+    def from_dict(cls, data: Any) -> Goal | None:
+        """Restore a saved goal. A goal that was running is restored as paused,
+        so the user decides when to continue it (``/goal resume``)."""
+        if not isinstance(data, dict):
+            return None
+        raw_objective = data.get("objective")
+        objective = raw_objective.strip() if isinstance(raw_objective, str) else ""
+        if not objective:
+            return None
+        status = str(data.get("status") or PAUSED)
+        outcome = str(data.get("outcome") or "")
+        if status not in STATUSES or status == ACTIVE:
+            status = PAUSED
+            outcome = "restored from a saved session"
+        return cls(
+            objective=objective,
+            max_rounds=_clamp_rounds(data.get("max_rounds")),
+            status=status,
+            rounds=max(0, _as_int(data.get("rounds"))),
+            progress=str(data.get("progress") or ""),
+            outcome=outcome,
+            due=False,
+        )
+
+
+@dataclass(frozen=True)
+class GoalCommand:
+    """A parsed ``/goal`` argument."""
+
+    verb: str  # "show", "set", "pause", "resume" or "clear"
+    objective: str = ""
+    max_rounds: int = DEFAULT_MAX_ROUNDS
+
+
+def parse_goal_command(arg: str) -> GoalCommand:
+    """Parse the text after ``/goal``. Raises ``ValueError`` with a message."""
+    text = arg.strip()
+    if not text:
+        return GoalCommand("show")
+
+    # "--" makes the rest an objective even when it reads like a verb.
+    if text == "--" or text.startswith("-- "):
+        objective = text[2:].strip()
+        if not objective:
+            raise ValueError(_USAGE)
+        return GoalCommand("set", _checked_objective(objective))
+
+    max_rounds = DEFAULT_MAX_ROUNDS
+    flag = _ROUNDS_FLAG.match(text)
+    if flag:
+        value, text = flag.group(1), flag.group(2).strip()
+        # isascii: str.isdigit() accepts forms such as "²" that int() rejects.
+        if not (value.isascii() and value.isdigit()) or not (
+            1 <= int(value) <= MAX_ROUNDS_LIMIT
+        ):
+            raise ValueError(f"--rounds takes a number from 1 to {MAX_ROUNDS_LIMIT}.")
+        max_rounds = int(value)
+        if not text:
+            raise ValueError("--rounds needs an objective, e.g. /goal --rounds 20 fix the tests.")
+        return GoalCommand("set", _checked_objective(text), max_rounds)
+
+    verb = text.lower()
+    if verb in ("pause", "resume", "clear"):
+        return GoalCommand(verb)
+    return GoalCommand("set", _checked_objective(text), max_rounds)
+
+
+def _checked_objective(text: str) -> str:
+    if len(text) > MAX_OBJECTIVE_CHARS:
+        raise ValueError(f"A goal can be at most {MAX_OBJECTIVE_CHARS} characters.")
+    return text
+
+
+def new_goal(objective: str, max_rounds: int = DEFAULT_MAX_ROUNDS) -> Goal:
+    return Goal(objective=objective.strip(), max_rounds=_clamp_rounds(max_rounds))
+
+
+def start_round(goal: Goal) -> str:
+    """Begin the next round and return the user message that starts it."""
+    goal.rounds += 1
+    goal.due = False
+    if goal.rounds == 1:
+        return opening_prompt(goal)
+    return continuation_prompt(goal)
+
+
+def finish_round(goal: Goal, stop_reason: str | None) -> None:
+    """Decide, after a round, whether another round is due.
+
+    The goal keeps going only when the model stopped on its own and the round
+    budget is not spent. A status set by ``update_goal`` during the round
+    (achieved or blocked) is left alone.
+    """
+    goal.due = False
+    if goal.status != ACTIVE:
+        return
+    if stop_reason != "stop":
+        pause(goal, _STOP_REASONS.get(stop_reason or "", "the round ended early"))
+        return
+    if goal.rounds >= goal.max_rounds:
+        pause(goal, f"reached the {goal.max_rounds}-round limit")
+        return
+    goal.due = True
+
+
+def pause(goal: Goal, reason: str) -> None:
+    goal.status = PAUSED
+    goal.outcome = reason
+    goal.due = False
+
+
+def resume(goal: Goal) -> None:
+    """Make the goal active again with a fresh round allowance."""
+    goal.status = ACTIVE
+    goal.rounds = 0
+    goal.outcome = ""
+    goal.due = True
+
+
+def close(goal: Goal, status: str, summary: str) -> None:
+    """Record the outcome reported through ``update_goal``."""
+    goal.status = status
+    goal.outcome = summary
+    goal.due = False
+
+
+def opening_prompt(goal: Goal) -> str:
+    return (
+        "You are working toward a goal the user set. Work through it step by step, "
+        "using tools as needed, until the objective is fully met. Do not stop to ask "
+        "for confirmation unless you are genuinely blocked.\n\n"
+        f"Goal: {goal.objective}\n\n"
+        "Report through the update_goal tool:\n"
+        '- status "in_progress" with a one-line summary after meaningful progress;\n'
+        '- status "achieved" only once you have checked the result, with a summary of '
+        "how you verified it;\n"
+        '- status "blocked" only if you need something only the user can provide, with '
+        "a summary of exactly what you need."
+    )
+
+
+def continuation_prompt(goal: Goal) -> str:
+    note = (
+        f"Last progress note: {goal.progress}"
+        if goal.progress
+        else "No progress note has been recorded yet."
+    )
+    return (
+        f"Keep working toward the goal (round {goal.rounds} of {goal.max_rounds}).\n"
+        f"Goal: {goal.objective}\n"
+        f"{note}\n\n"
+        "Continue from where you left off. When the objective is fully met and "
+        'verified, call update_goal with status "achieved"; if you are blocked on '
+        'something only the user can give, call it with status "blocked".'
+    )
+
+
+def _clamp_rounds(value: Any) -> int:
+    return min(MAX_ROUNDS_LIMIT, max(1, _as_int(value, DEFAULT_MAX_ROUNDS)))
+
+
+def _as_int(value: Any, default: int = 0) -> int:
+    try:
+        return int(value)
+    except (TypeError, ValueError):
+        return default

{kiwimatecoder-0.1.0 → kiwimatecoder-0.2.0}/kiwimatecoder/repl.py

@@ -60,6 +60,7 @@ from rich.panel import Panel
 from rich.syntax import Syntax
 
 from kiwimatecoder import __version__, browser, events, hooks, images, lsp, mcp, notify, plugins, ui
+from kiwimatecoder import goal as goal_module
 from kiwimatecoder.agent import Agent
 from kiwimatecoder.commands import (
     CommandOption,
@@ -1168,6 +1169,7 @@ async def _run_turn_with_steering(
         raise
 
     if interrupted:
+        agent.last_stop_reason = "interrupted"
         console.print(f"\n[yellow]{t('prompt.interrupted')}[/yellow]")
 
     if await _process_deferred_commands(session):
@@ -1175,6 +1177,48 @@ async def _run_turn_with_steering(
     return exit_requested
 
 
+def _announce_goal_stop(goal: goal_module.Goal) -> None:
+    """Say why a goal stopped after a round (it is not due another one)."""
+    if goal.status == goal_module.ACHIEVED:
+        console.print(
+            f"[green]Goal achieved after {goal.rounds} round(s).[/green] "
+            f"{escape(goal.outcome)}"
+        )
+    elif goal.status == goal_module.BLOCKED:
+        console.print(
+            f"[yellow]Goal blocked: {escape(goal.outcome)}[/yellow]\n"
+            "[dim]Answer above, then /goal resume.[/dim]"
+        )
+    elif goal.status == goal_module.PAUSED:
+        console.print(
+            f"[yellow]Goal paused: {escape(goal.outcome)}.[/yellow] "
+            "[dim]/goal resume continues it, /goal clear drops it.[/dim]"
+        )
+
+
+async def _drive_goal(
+    agent: Agent, pt_session: PromptSession[str], session: Session
+) -> bool:
+    """Run goal rounds back to back while the session goal is due.
+
+    Each round is an ordinary agent turn, so steering, Ctrl-C and approvals all
+    work as they do elsewhere. Returns True when the REPL should exit.
+    """
+    while session.goal is not None and session.goal.due:
+        goal = session.goal
+        prompt = goal_module.start_round(goal)
+        # Plain text rather than a box-drawing rule, which ASCII mode cannot show.
+        console.print(f"[dim]goal round {goal.rounds} of {goal.max_rounds}[/dim]")
+        if await _run_turn_with_steering(agent, pt_session, session, prompt):
+            return True
+        # A /goal command may have replaced or cleared the goal mid-round.
+        if session.goal is goal:
+            goal_module.finish_round(goal, agent.last_stop_reason)
+            if not goal.due:
+                _announce_goal_stop(goal)
+    return False
+
+
 def _run_lifecycle_hooks(
     bus: events.EventBus, event: str, session: Session
 ) -> None:
@@ -1296,6 +1340,9 @@ async def _run_interactive(
 
     try:
         while True:
+            # A goal set by /goal (or queued during a turn) runs before the next prompt.
+            if await _drive_goal(agent, pt_session, session):
+                break
             try:
                 prompt_str = (
                     HTML("<ansicyan>... </ansicyan>")