deepy-cli 0.2.3__tar.gz → 0.2.5__tar.gz

{deepy_cli-0.2.3 → deepy_cli-0.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: deepy-cli
-Version: 0.2.3
+Version: 0.2.5
 Summary: Deepy - Vibe coding for DeepSeek models in your terminal
 Keywords: deepseek,coding-agent,terminal,cli,agents
 Author: kirineko

{deepy_cli-0.2.3 → deepy_cli-0.2.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "deepy-cli"
-version = "0.2.3"
+version = "0.2.5"
 description = "Deepy - Vibe coding for DeepSeek models in your terminal"
 readme = "README.md"
 authors = [

{deepy_cli-0.2.3 → deepy_cli-0.2.5}/src/deepy/__init__.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-__version__ = "0.2.3"
+__version__ = "0.2.5"
 
 
 def main() -> None:

{deepy_cli-0.2.3 → deepy_cli-0.2.5}/src/deepy/data/tools/AskUserQuestion.md

@@ -10,6 +10,12 @@
 标注 `(Recommended)` 或中文等价表达。不要为了低影响细节提问；可以合理假设时
 继续推进并简短说明假设。
 
+Agent Skills 可能使用通用说法，例如 ask the user、ask one question at a time、
+wait for the user's response、get approval、review 或 confirm before continuing。
+在 Deepy 中，除非 skill 明确要求不要使用工具，否则这些等待用户输入的步骤都应通过
+`AskUserQuestion` 完成。开放问题也必须提供选项；可加入“自定义回答”/`Custom answer`
+作为选项，让用户输入自由文本。
+
 Args: `questions` (non-empty array). Each question needs `question` and non-empty `options`;
 each option needs `label` and may include `description`. Use `multiSelect=true` only when
 multiple choices are allowed.

deepy_cli-0.2.5/src/deepy/data/tools/todo_write.md

@@ -0,0 +1,16 @@
+## todo_write
+
+Maintain a session-scoped todo list for complex work.
+
+Use `todo_write` when the user asks for several deliverables, the work touches
+multiple files, or the task naturally breaks into three or more meaningful
+steps. Do not use it for simple questions, tiny one-step edits, or routine
+commands where a todo list would add noise.
+
+Each update replaces the complete list. Keep item `id` values stable across
+updates. Use exactly one `in_progress` item at a time, mark completed work as
+`completed`, and update the list only when real progress changes. Omit `todos`
+to read the current list; pass an empty list to clear it.
+
+This tool only tracks progress. It does not delegate to subagents and it does
+not request plan approval.

{deepy_cli-0.2.3 → deepy_cli-0.2.5}/src/deepy/llm/compaction.py

@@ -8,6 +8,7 @@ from typing import Any, Literal
 from deepy.config import Settings
 from deepy.prompts.compact import build_compact_prompt, build_compact_summary_message
 from deepy.sessions.jsonl import DeepyJsonlSession
+from deepy.todos import todo_state_prompt_text
 from deepy.usage import TokenUsage, usage_from_run_result
 
 from .context import estimate_tokens_for_item, estimate_tokens_for_items
@@ -81,6 +82,7 @@ async def compact_session(
         settings,
         provider=provider,
         focus_instruction=focus_instruction,
+        todo_state=session.todo_state(),
     )
     replacement = sanitize_sdk_items_for_replay(
         [build_compact_summary_message(summary), *to_preserve]
@@ -124,9 +126,7 @@ async def ensure_context_ready(
     before_tokens = state.active_tokens + additional_tokens
     latest_context_usage = session.latest_context_window_usage()
     trigger_tokens = (
-        latest_context_usage.used_tokens
-        if latest_context_usage is not None
-        else before_tokens
+        latest_context_usage.used_tokens if latest_context_usage is not None else before_tokens
     )
     compacted: CompactionResult | None = None
     if trigger_tokens >= settings.context.resolved_compact_threshold:
@@ -144,9 +144,7 @@ async def ensure_context_ready(
     else:
         after_context_usage = session.latest_context_window_usage()
         fit_tokens = (
-            after_context_usage.used_tokens
-            if after_context_usage is not None
-            else after_tokens
+            after_context_usage.used_tokens if after_context_usage is not None else after_tokens
         )
     if fit_tokens + settings.context.reserved_context_tokens >= settings.context.window_tokens:
         raise ContextCompactionError(
@@ -198,11 +196,16 @@ async def run_compaction_model(
     *,
     provider: ProviderBundle | None = None,
     focus_instruction: str | None = None,
+    todo_state: list[dict[str, str]] | None = None,
 ) -> tuple[str, TokenUsage]:
     from agents import Agent, RunConfig, Runner
 
     resolved_provider = provider or build_provider_bundle(settings)
-    prompt = build_compact_prompt(items, focus_instruction=focus_instruction)
+    prompt = build_compact_prompt(
+        items,
+        focus_instruction=focus_instruction,
+        todo_context=todo_state_prompt_text(todo_state or []),
+    )
     agent = Agent(
         name="Deepy Context Compactor",
         instructions="Create a compact continuation summary. Do not call tools.",
@@ -254,7 +257,10 @@ def _expand_preserve_start_for_tool_group(items: list[dict[str, Any]], preserve_
     if not needed_call_ids:
         return preserve_start
     for index in range(preserve_start - 1, -1, -1):
-        if items[index].get("type") == "function_call" and _call_id(items[index]) in needed_call_ids:
+        if (
+            items[index].get("type") == "function_call"
+            and _call_id(items[index]) in needed_call_ids
+        ):
             preserve_start = index
             needed_call_ids.discard(_call_id(items[index]))
             if not needed_call_ids:

{deepy_cli-0.2.3 → deepy_cli-0.2.5}/src/deepy/llm/runner.py

@@ -12,6 +12,7 @@ from deepy.config import Settings, load_settings
 from deepy.sessions.jsonl import DeepyJsonlSession
 from deepy.skills import find_skill
 from deepy.mcp import DeepyMcpRuntime
+from deepy.todos import normalize_todo_items
 from deepy.tools import ToolRuntime
 from deepy.usage import TokenUsage, merge_usage, normalize_usage, usage_from_run_result
 from deepy.utils import json as json_utils
@@ -24,6 +25,11 @@ from .events import DeepyStreamEvent, normalize_stream_event
 from .provider import ProviderBundle, build_provider_bundle
 
 DEFAULT_MAX_TURNS = 100
+INTERRUPTED_MARKER_TEXT = (
+    "Interrupted by user with Esc. This turn was stopped before completion. "
+    "Do not continue the interrupted request unless the user explicitly asks to continue."
+)
+INTERRUPTED_TOOL_OUTPUT_TEXT = "Tool execution interrupted by user with Esc."
 
 
 @dataclass(frozen=True)
@@ -60,7 +66,15 @@ async def run_prompt_once(
     root = (project_root or Path.cwd()).resolve()
     resolved_settings = settings or load_settings()
     resolved_provider = provider or build_provider_bundle(resolved_settings)
-    runtime = ToolRuntime(cwd=root, settings=resolved_settings)
+    session = (
+        DeepyJsonlSession.open(root, session_id) if session_id else DeepyJsonlSession.create(root)
+    )
+    initial_todos, _ = normalize_todo_items(session.todo_state())
+    runtime = ToolRuntime(
+        cwd=root,
+        settings=resolved_settings,
+        todo_items=initial_todos or [],
+    )
     created_mcp_runtime: DeepyMcpRuntime | None = None
     if mcp_runtime is None:
         created_mcp_runtime = DeepyMcpRuntime(resolved_settings, project_root=root)
@@ -76,11 +90,6 @@ async def run_prompt_once(
         mcp_servers=mcp_runtime.active_servers,
         preferred_mcp_web_search_tools=mcp_runtime.preferred_web_search_tools,
     )
-    session = (
-        DeepyJsonlSession.open(root, session_id)
-        if session_id
-        else DeepyJsonlSession.create(root)
-    )
     started_at = time.time()
     try:
         readiness = await ensure_context_ready(
@@ -124,6 +133,7 @@ async def run_prompt_once(
     pending_questions: list[dict[str, Any]] = []
     usage = TokenUsage()
     interrupt_task: asyncio.Task[bool] | None = None
+    session_baseline_count = len(await session.get_items())
     try:
         result = Runner.run_streamed(
             agent,
@@ -268,6 +278,12 @@ async def run_prompt_once(
         raise
 
     interrupted = interrupted or await _finish_interrupt_task(interrupt_task)
+    if interrupted:
+        await _reconcile_interrupted_session_tail(
+            session,
+            baseline_count=session_baseline_count,
+            prompt=prompt,
+        )
 
     final_output = getattr(result, "final_output", None)
     output = final_output if isinstance(final_output, str) else "".join(chunks)
@@ -508,6 +524,143 @@ async def _finish_interrupt_task(task: asyncio.Task[bool] | None) -> bool:
     return False
 
 
+async def _reconcile_interrupted_session_tail(
+    session: DeepyJsonlSession,
+    *,
+    baseline_count: int,
+    prompt: str,
+) -> None:
+    items = await session.get_items()
+    if baseline_count < 0 or baseline_count > len(items):
+        return
+    suffix = items[baseline_count:]
+    if not suffix:
+        return
+
+    if len(suffix) == 1 and _is_user_prompt_item(suffix[0], prompt):
+        await session.pop_item()
+        return
+
+    additions = _interrupted_tool_output_items(suffix)
+    if not _is_interrupt_marker_item(suffix[-1]):
+        additions.append(_interrupted_marker_item())
+    if additions:
+        await session.add_items(additions)
+
+
+def _is_user_prompt_item(item: dict[str, Any], prompt: str) -> bool:
+    if item.get("role") != "user":
+        return False
+    return _item_text_content(item) == prompt
+
+
+def _item_text_content(item: dict[str, Any]) -> str:
+    content = item.get("content")
+    if isinstance(content, str):
+        return content
+    if not isinstance(content, list):
+        return ""
+    parts: list[str] = []
+    for part in content:
+        if isinstance(part, dict):
+            text = part.get("text")
+            if text is None:
+                text = part.get("input_text")
+            if isinstance(text, str):
+                parts.append(text)
+    return "".join(parts)
+
+
+def _interrupted_tool_output_items(items: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    output_call_ids = {
+        call_id
+        for item in items
+        if (call_id := _function_call_output_id(item))
+    }
+    additions: list[dict[str, Any]] = []
+    added_call_ids: set[str] = set()
+    for item in items:
+        for call_id, output_item in _missing_output_items_for_call(item, output_call_ids):
+            if call_id in added_call_ids:
+                continue
+            additions.append(output_item)
+            added_call_ids.add(call_id)
+    return additions
+
+
+def _missing_output_items_for_call(
+    item: dict[str, Any],
+    output_call_ids: set[str],
+) -> list[tuple[str, dict[str, Any]]]:
+    call_id = _function_call_id(item)
+    if call_id:
+        return (
+            []
+            if call_id in output_call_ids
+            else [
+                (
+                    call_id,
+                    {
+                        "type": "function_call_output",
+                        "call_id": call_id,
+                        "output": INTERRUPTED_TOOL_OUTPUT_TEXT,
+                    },
+                )
+            ]
+        )
+
+    missing: list[tuple[str, dict[str, Any]]] = []
+    if item.get("role") != "assistant":
+        return missing
+    tool_calls = item.get("tool_calls")
+    if not isinstance(tool_calls, list):
+        return missing
+    for tool_call in tool_calls:
+        if not isinstance(tool_call, dict):
+            continue
+        chat_call_id = tool_call.get("id")
+        if not isinstance(chat_call_id, str) or not chat_call_id or chat_call_id in output_call_ids:
+            continue
+        missing.append(
+            (
+                chat_call_id,
+                {
+                    "role": "tool",
+                    "tool_call_id": chat_call_id,
+                    "content": INTERRUPTED_TOOL_OUTPUT_TEXT,
+                },
+            )
+        )
+    return missing
+
+
+def _function_call_id(item: dict[str, Any]) -> str:
+    if item.get("type") != "function_call":
+        return ""
+    call_id = item.get("call_id")
+    if call_id is None:
+        call_id = item.get("id")
+    return call_id if isinstance(call_id, str) else ""
+
+
+def _function_call_output_id(item: dict[str, Any]) -> str:
+    if item.get("type") == "function_call_output":
+        call_id = item.get("call_id")
+        return call_id if isinstance(call_id, str) else ""
+    if item.get("role") == "tool":
+        tool_call_id = item.get("tool_call_id")
+        return tool_call_id if isinstance(tool_call_id, str) else ""
+    return ""
+
+
+def _interrupted_marker_item() -> dict[str, Any]:
+    return {"role": "assistant", "content": INTERRUPTED_MARKER_TEXT}
+
+
+def _is_interrupt_marker_item(item: dict[str, Any]) -> bool:
+    return item.get("role") == "assistant" and item.get("content") == INTERRUPTED_MARKER_TEXT
+
+
 def _pending_questions_from_tool_output(output: str) -> list[dict[str, Any]]:
     if not output.strip():
         return []

{deepy_cli-0.2.3 → deepy_cli-0.2.5}/src/deepy/prompts/compact.py

@@ -94,6 +94,7 @@ def build_compact_prompt(
     session_messages: list[dict[str, Any]],
     *,
     focus_instruction: str | None = None,
+    todo_context: str | None = None,
 ) -> str:
     jsonl = "\n".join(_compact_message_json(message) for message in session_messages)
     focus = ""
@@ -104,7 +105,15 @@ def build_compact_prompt(
             "dropping current task state:\n"
             f"{focus_instruction.strip()}"
         )
-    return f"{COMPACT_PROMPT_BASE}{focus}\n\nconversation below:\n\n```jsonl\n{jsonl}\n```"
+    todo = ""
+    if todo_context and todo_context.strip():
+        todo = (
+            "\n\nCurrent todo state:\n"
+            "Preserve this active task plan in the summary so the next model turn can continue "
+            "or reconcile progress:\n"
+            f"{todo_context.strip()}"
+        )
+    return f"{COMPACT_PROMPT_BASE}{focus}{todo}\n\nconversation below:\n\n```jsonl\n{jsonl}\n```"
 
 
 def build_compact_summary_message(summary: str) -> dict[str, str]:

{deepy_cli-0.2.3 → deepy_cli-0.2.5}/src/deepy/prompts/system.py

@@ -53,6 +53,13 @@ Core rules:
 - Ask when clarification would materially improve the result: ambiguous intent, unclear scope,
   user preferences, high-impact trade-offs, or required approval. For low-impact details,
   proceed with a reasonable assumption and state it briefly.
+- Use `todo_write` for complex multi-step work, multi-file changes, or several
+  distinct deliverables. Keep one item `in_progress`, update the complete list
+  only when real task state changes, and reconcile completed work before the
+  final answer. Skip `todo_write` for simple questions and obvious one-step
+  tasks so progress tracking does not create noise.
+- `todo_write` is only for local task tracking. Do not treat it as subagent
+  delegation, a `task` tool, or a plan approval mode.
 
 Tool protocol:
 Tool results are JSON strings: ok, name, output, error, metadata, awaitUserResponse.
@@ -63,6 +70,10 @@ Skill protocol:
 - If the user's task matches an available skill, call `load_skill` with the exact skill name before relying on that skill's detailed instructions, scripts, references, or assets.
 - If the user explicitly invoked a skill, follow the loaded skill instructions and use the user's request inside that context.
 - Skill files are standard Agent Skills. Resolve relative scripts, references, and assets from the skill root returned by `load_skill`.
+- If a loaded skill says to ask the user, ask one question at a time, wait for
+  the user's response, get approval, or have the user review or confirm before
+  continuing, satisfy that wait point with `AskUserQuestion` unless the skill
+  explicitly says to ask in the final answer without tools.
 
 Tool documentation:
 {tool_docs_block}

{deepy_cli-0.2.3 → deepy_cli-0.2.5}/src/deepy/prompts/tool_docs.py

@@ -10,6 +10,7 @@ TOOL_DOC_FILES = (
     "AskUserQuestion.md",
     "WebSearch.md",
     "WebFetch.md",
+    "todo_write.md",
 )
 
 

{deepy_cli-0.2.3 → deepy_cli-0.2.5}/src/deepy/sessions/jsonl.py

@@ -8,13 +8,21 @@ from typing import Any
 
 from deepy.llm.context import estimate_tokens_for_item
 from deepy.llm.replay import sanitize_sdk_items_for_replay
-from deepy.usage import ContextWindowUsage, TokenUsage, context_window_usage, merge_usage, normalize_usage
+from deepy.todos import normalize_persisted_todo_state, todo_state_from_tool_output
+from deepy.usage import (
+    ContextWindowUsage,
+    TokenUsage,
+    context_window_usage,
+    merge_usage,
+    normalize_usage,
+)
 from deepy.utils import json as json_utils
 
 SESSION_INDEX_VERSION = 2
 MAX_SESSION_INDEX_ENTRIES = 50
 CONTEXT_UNDERCOUNT_REPAIR_RATIO = 2
 CONTEXT_UNDERCOUNT_REPAIR_MIN_DELTA = 128
+_UNSET = object()
 
 
 @dataclass(frozen=True)
@@ -30,6 +38,7 @@ class SessionEntry:
     last_usage_tokens: int | None = None
     pending_tokens: int = 0
     last_usage_record_count: int | None = None
+    todo_state: list[dict[str, str]] | None = None
 
 
 def project_code(project_root: Path) -> str:
@@ -123,7 +132,9 @@ class DeepyJsonlSession:
         with self.path.open("w", encoding="utf-8") as fh:
             for record in records:
                 fh.write(json_utils.dumps(record) + "\n")
-        self._loaded_items = [item for item in (_sdk_item_from_record(record) for record in records) if item]
+        self._loaded_items = [
+            item for item in (_sdk_item_from_record(record) for record in records) if item
+        ]
         state = self.context_token_state(records)
         self._touch_index(
             active_tokens=state.active_tokens,
@@ -144,6 +155,7 @@ class DeepyJsonlSession:
             last_usage_tokens=0,
             pending_tokens=0,
             last_usage_record_count=0,
+            todo_state=[],
         )
 
     def record_usage(self, usage: TokenUsage | dict[str, Any] | None) -> None:
@@ -186,7 +198,9 @@ class DeepyJsonlSession:
                         last_usage_record_count=None,
                         estimated=True,
                     )
-                pending_tokens = sum(_estimate_record_tokens(record) for record in source[last_usage_record_count:])
+                pending_tokens = sum(
+                    _estimate_record_tokens(record) for record in source[last_usage_record_count:]
+                )
                 checkpoint_tokens = last_usage_tokens + pending_tokens
                 estimated_tokens = self._estimate_active_tokens(source)
                 active_tokens = _repair_undercounted_context_tokens(
@@ -211,7 +225,9 @@ class DeepyJsonlSession:
 
     def latest_context_window_usage(self) -> ContextWindowUsage | None:
         previous = _entry_for_session(self.path.parent / "sessions-index.json", self.session_id)
-        latest_tokens = _optional_int(previous.get("latestContextWindowTokens")) if previous else None
+        latest_tokens = (
+            _optional_int(previous.get("latestContextWindowTokens")) if previous else None
+        )
         if latest_tokens is not None:
             return ContextWindowUsage(
                 used_tokens=latest_tokens,
@@ -223,6 +239,13 @@ class DeepyJsonlSession:
             return context_window_usage(usage)
         return None
 
+    def todo_state(self) -> list[dict[str, str]]:
+        previous = _entry_for_session(self.path.parent / "sessions-index.json", self.session_id)
+        if not previous:
+            return []
+        todo_state = normalize_persisted_todo_state(previous.get("todoState"))
+        return todo_state or []
+
     async def replace_items(
         self,
         items: list[dict[str, Any]],
@@ -308,6 +331,7 @@ class DeepyJsonlSession:
         last_usage_tokens: int | None = None,
         pending_tokens: int | None = None,
         last_usage_record_count: int | None = None,
+        todo_state: object = _UNSET,
     ) -> None:
         self.path.parent.mkdir(parents=True, exist_ok=True)
         index_path = self.path.parent / "sessions-index.json"
@@ -316,61 +340,64 @@ class DeepyJsonlSession:
         sessions = _index_sessions(raw)
         previous = next((entry for entry in sessions if entry.get("id") == self.session_id), {})
         sessions = [entry for entry in sessions if entry.get("id") != self.session_id]
-        sessions.insert(
-            0,
-            {
-                "id": self.session_id,
-                "path": self.path.name,
-                "activeTokens": active_tokens
-                if active_tokens is not None
-                else _coerce_int(previous.get("activeTokens"), 0),
-                **(
-                    {"latestContextWindowTokens": latest_context_window_tokens}
-                    if latest_context_window_tokens is not None
-                    else (
-                        {"latestContextWindowTokens": previous["latestContextWindowTokens"]}
-                        if "latestContextWindowTokens" in previous
-                        else {}
-                    )
-                ),
-                **(
-                    {"lastUsageTokens": last_usage_tokens}
-                    if last_usage_tokens is not None
-                    else (
-                        {"lastUsageTokens": previous["lastUsageTokens"]}
-                        if "lastUsageTokens" in previous
-                        else {}
-                    )
-                ),
-                **(
-                    {"pendingTokens": pending_tokens}
-                    if pending_tokens is not None
-                    else (
-                        {"pendingTokens": previous["pendingTokens"]}
-                        if "pendingTokens" in previous
-                        else {}
-                    )
-                ),
-                **(
-                    {"lastUsageRecordCount": last_usage_record_count}
-                    if last_usage_record_count is not None
-                    else (
-                        {"lastUsageRecordCount": previous["lastUsageRecordCount"]}
-                        if "lastUsageRecordCount" in previous
-                        else {}
-                    )
-                ),
-                "createdAt": _coerce_int(previous.get("createdAt"), now),
-                "updatedAt": now,
-                **({"usage": usage} if usage is not None else {}),
-                **(
-                    {"usage": previous["usage"]}
-                    if usage is None and isinstance(previous.get("usage"), dict)
+        entry = {
+            "id": self.session_id,
+            "path": self.path.name,
+            "activeTokens": active_tokens
+            if active_tokens is not None
+            else _coerce_int(previous.get("activeTokens"), 0),
+            **(
+                {"latestContextWindowTokens": latest_context_window_tokens}
+                if latest_context_window_tokens is not None
+                else (
+                    {"latestContextWindowTokens": previous["latestContextWindowTokens"]}
+                    if "latestContextWindowTokens" in previous
                     else {}
-                ),
-                **({"processes": previous["processes"]} if "processes" in previous else {}),
-            },
-        )
+                )
+            ),
+            **(
+                {"lastUsageTokens": last_usage_tokens}
+                if last_usage_tokens is not None
+                else (
+                    {"lastUsageTokens": previous["lastUsageTokens"]}
+                    if "lastUsageTokens" in previous
+                    else {}
+                )
+            ),
+            **(
+                {"pendingTokens": pending_tokens}
+                if pending_tokens is not None
+                else (
+                    {"pendingTokens": previous["pendingTokens"]}
+                    if "pendingTokens" in previous
+                    else {}
+                )
+            ),
+            **(
+                {"lastUsageRecordCount": last_usage_record_count}
+                if last_usage_record_count is not None
+                else (
+                    {"lastUsageRecordCount": previous["lastUsageRecordCount"]}
+                    if "lastUsageRecordCount" in previous
+                    else {}
+                )
+            ),
+            "createdAt": _coerce_int(previous.get("createdAt"), now),
+            "updatedAt": now,
+            **({"usage": usage} if usage is not None else {}),
+            **(
+                {"usage": previous["usage"]}
+                if usage is None and isinstance(previous.get("usage"), dict)
+                else {}
+            ),
+            **({"processes": previous["processes"]} if "processes" in previous else {}),
+        }
+        if todo_state is _UNSET:
+            if "todoState" in previous:
+                entry["todoState"] = previous["todoState"]
+        elif todo_state is not None:
+            entry["todoState"] = todo_state
+        sessions.insert(0, entry)
         payload = {
             "version": SESSION_INDEX_VERSION,
             "sessions": sessions[:MAX_SESSION_INDEX_ENTRIES],
@@ -379,10 +406,13 @@ class DeepyJsonlSession:
 
     def _touch_index_after_append(self, appended_items: list[dict[str, Any]]) -> None:
         previous = _entry_for_session(self.path.parent / "sessions-index.json", self.session_id)
+        todo_state = _latest_todo_state_from_items(appended_items)
         if previous and _optional_int(previous.get("lastUsageTokens")) is not None:
             last_usage_tokens = _optional_int(previous.get("lastUsageTokens")) or 0
             previous_pending = _coerce_int(previous.get("pendingTokens"), 0)
-            pending_tokens = previous_pending + sum(estimate_tokens_for_item(item) for item in appended_items)
+            pending_tokens = previous_pending + sum(
+                estimate_tokens_for_item(item) for item in appended_items
+            )
             self._touch_index(
                 active_tokens=last_usage_tokens + pending_tokens,
                 last_usage_tokens=last_usage_tokens,
@@ -391,9 +421,13 @@ class DeepyJsonlSession:
                     previous.get("lastUsageRecordCount"),
                     max(0, len(self._load_records()) - len(appended_items)),
                 ),
+                todo_state=todo_state if todo_state is not None else _UNSET,
             )
             return
-        self._touch_index(active_tokens=self._estimate_active_tokens())
+        self._touch_index(
+            active_tokens=self._estimate_active_tokens(),
+            todo_state=todo_state if todo_state is not None else _UNSET,
+        )
 
 
 @dataclass(frozen=True)
@@ -436,6 +470,7 @@ def list_session_entries(project_root: Path, deepy_home: Path | None = None) ->
                 last_usage_tokens=_optional_int(item.get("lastUsageTokens")),
                 pending_tokens=_coerce_int(item.get("pendingTokens"), 0),
                 last_usage_record_count=_optional_int(item.get("lastUsageRecordCount")),
+                todo_state=normalize_persisted_todo_state(item.get("todoState")),
             )
         )
     return entries
@@ -460,7 +495,11 @@ def _index_sessions(raw: dict[str, Any]) -> list[dict[str, Any]]:
 
 def _entry_for_session(index_path: Path, session_id: str) -> dict[str, Any] | None:
     return next(
-        (entry for entry in _index_sessions(_read_index(index_path)) if entry.get("id") == session_id),
+        (
+            entry
+            for entry in _index_sessions(_read_index(index_path))
+            if entry.get("id") == session_id
+        ),
         None,
     )
 
@@ -473,6 +512,18 @@ def _sdk_item_from_record(record: dict[str, Any]) -> dict[str, Any] | None:
     return dict(item) if isinstance(item, dict) else None
 
 
+def _latest_todo_state_from_items(items: list[dict[str, Any]]) -> list[dict[str, str]] | None:
+    latest: list[dict[str, str]] | None = None
+    for item in items:
+        output = item.get("output")
+        if output is None and item.get("role") == "tool":
+            output = item.get("content")
+        todo_state = todo_state_from_tool_output(output)
+        if todo_state is not None:
+            latest = todo_state
+    return latest
+
+
 def _coerce_int(value: Any, default: int) -> int:
     if isinstance(value, bool):
         return default