@@ -65,10 +65,11 @@ def need_compaction(self) -> bool:
     def compact(self) -> bool:
         """Compact the conversation; return True on success.
 
-        On success the history is replaced by the summary frame followed
-        by every real user prompt (nudges and other harness-injected
-        messages excluded), so the model keeps the actual requests; the
-        last prompt is the resume request for the next round.
+        On success the history is replaced by the summary frame, every
+        real user prompt (nudges and other harness-injected messages
+        excluded), and a trailing resume message telling the model what
+        is already done — the summary and the prompts alone end on a
+        bare user request, which invites redoing finished work.
         """
         loop = self.loop
         prompts = user_prompt_texts(loop.messages)
@@ -87,8 +88,10 @@ def compact(self) -> bool:
             # stays untouched): it is part of the user turn, never a
             # system message.  Every real user prompt (nudges and other
             # harness-injected messages excluded) is preserved verbatim
-            # after the frame, so the model keeps the actual requests.
-            loop.messages = compacted_messages(summary, prompts)
+            # after the frame, so the model keeps the actual requests,
+            # and the trailing resume message states that the summarised
+            # work is done (injected flag: TUI and filters skip it).
+            loop.messages = compacted_messages(summary, prompts, resume=True)
             # The shared conversation now is the compacted one: mirror it
             # onto session.last_messages so the TUI (renders from it) and
             # a later manual /compact start from the summary, not the old
 
@@ -500,7 +500,11 @@ def user_prompt_texts(messages: list) -> list[str]:
     (``remember_user_text`` excludes reminders for title generation —
     a different purpose, so the filters differ.)
     """
-    nudge = config.NUDGE_MESSAGE
+    # Harness-injected one-liners replayed verbatim on every compaction
+    # would accumulate: the completion nudge, and the resume message the
+    # automatic compaction appends (a bare "keep going" carries no task
+    # content — the summary already covers the progress it refers to).
+    injected = {config.NUDGE_MESSAGE, config.RESUME_MESSAGE}
     is_reminder: list[bool] = []
     last_reminder = -1
     for msg in messages:
@@ -523,7 +527,7 @@ def user_prompt_texts(messages: list) -> list[str]:
         if _message_role(msg) != "user":
             continue
         text = _message_text(msg)
-        if not text or text == nudge:
+        if not text or text in injected:
             continue
         if text.startswith(config.COMPACT_HEADER):
             continue
@@ -587,19 +591,29 @@ def compact_summary(
     return summary or None
 
 
-def compacted_messages(summary: str, prompts: list[str]) -> list[Message]:
+def compacted_messages(summary: str, prompts: list[str], resume: bool = False) -> list[Message]:
     """The post-compaction history: the summary frame as a user message
     followed by every preserved user prompt, oldest first.
 
     The summary lives in the user turn (the system prompt is passed
     separately and stays untouched); *prompts* are the real user
     requests (see ``user_prompt_texts``) that must survive compaction.
+
+    *resume* appends ``config.RESUME_MESSAGE`` (flagged ``injected``, so
+    the TUI and the filters skip it) after the prompts: without it the
+    rebuilt history ends with a bare user request and the model may redo
+    work the summary already records.  Only the automatic in-loop
+    compaction passes it — the manual /compact command waits for the
+    next user message instead.
     """
     frame = (config.COMPACT_HEADER + summary + config.COMPACT_SEPARATOR).strip()
-    return [
+    messages = [
         Message(role="user", content=frame),
         *[Message(role="user", content=p) for p in prompts],
     ]
+    if resume:
+        messages.append(Message(role="user", content=config.RESUME_MESSAGE, injected=True))
+    return messages
 
 
 # ---- custom agent discovery -----------------------------------------------
 
@@ -44,6 +44,18 @@
 # ---- compaction -----------------------------------------------------------
 COMPACT_HEADER = "**[Compacted Summary]**\n\n"
 COMPACT_SEPARATOR = "\n\n---\n\n**[Context compacted]**\n\n---\n\n"
+# Appended after the summary frame + preserved prompts on the AUTOMATIC
+# path only (AgentLoop -> ContextManager.compact).  The rebuilt history
+# ends with the original user request, and a bare request reads as "start
+# here", so the model tends to redo work the summary already records.  The
+# manual /compact command does NOT inject it: it replaces the history and
+# waits for the next user message.
+RESUME_MESSAGE = (
+    "Compaction just finished; the summary above records the work already done. "
+    "Do not repeat completed steps or re-run finished tool calls. "
+    "Review which parts of the request above are already done "
+    "and continue with the unfinished ones."
+)
 
 # ---- token calibration ----------------------------------------------------
 CALIBRATION_MIN = 0.5
 
@@ -670,14 +670,16 @@ def _mode_prompts(self) -> dict[str, str]:
     def remember_user_text(self, messages: list) -> None:
         """Remember the last real user message for session-title generation.
 
-        Skips harness-injected messages (nudges, plan/build-switch
-        reminders, queued mode prompts — flagged ``injected``) so a
-        title is never generated from "Review the original user request
-        and the Task Completion Rules…" or a mode-switch reminder.
+        Skips harness-injected messages (nudges, the post-compaction
+        resume message, plan/build-switch reminders, queued mode prompts
+        — flagged ``injected``; the content check also covers restored
+        sessions, where the flag is lost) so a title is never generated
+        from "Review the original user request and the Task Completion
+        Rules…" or a mode-switch reminder.
         """
-        nudge = config.NUDGE_MESSAGE
+        injected = {config.NUDGE_MESSAGE, config.RESUME_MESSAGE}
         for m in reversed(messages):
-            if m.role == "user" and not m.injected and m.text() != nudge:
+            if m.role == "user" and not m.injected and m.text() not in injected:
                 self.store.remember_first_user_message(m.text())
                 break
 
 
@@ -144,11 +144,12 @@ def _is_injected_user_text(text: str) -> bool:
 
     Live sessions flag injected messages directly; these content checks
     cover restored sessions, where the flag is lost in the markdown
-    round-trip: the completion nudge, the <system-reminder>-wrapped
-    plan/build-switch prompts (plan.md, plan-mode.md, build-switch.md
-    all start with the reminder tag), and the plan-exit approval notice.
+    round-trip: the completion nudge, the post-compaction resume message,
+    the <system-reminder>-wrapped plan/build-switch prompts (plan.md,
+    plan-mode.md, build-switch.md all start with the reminder tag), and
+    the plan-exit approval notice.
     """
-    if text == config.NUDGE_MESSAGE:
+    if text == config.NUDGE_MESSAGE or text == config.RESUME_MESSAGE:
         return True
     return _is_mode_reminder_text(text)
 
 
@@ -943,14 +943,18 @@ def fake_estimate(*a, **k):
                 )
                 result = loop.run()
         self.assertEqual(result, "answer after compaction")
-        # the history is [summary frame, task one, task two, final
-        # answer]: the old assistant turn is gone, every real prompt
-        # survives, and the second compaction (the fake ratio stays
-        # high for two rounds) did not stack another frame
-        self.assertEqual(len(loop.messages), 4)
+        # the history is [summary frame, task one, task two, resume
+        # message, final answer]: the old assistant turn is gone, every
+        # real prompt survives, and the automatic compaction appended
+        # the resume message that stops the model redoing the work
+        self.assertEqual(len(loop.messages), 5)
         self.assertTrue(loop.messages[0].text().startswith("**[Compacted Summary]**"))
         self.assertEqual([m.text() for m in loop.messages[1:3]], ["task one", "task two"])
-        self.assertEqual(loop.messages[3].text(), "answer after compaction")
+        self.assertEqual(loop.messages[3].text(), config.RESUME_MESSAGE)
+        self.assertTrue(loop.messages[3].injected)
+        self.assertEqual(loop.messages[4].text(), "answer after compaction")
+        # exactly one resume message (a second compaction would stack it)
+        self.assertEqual(sum(1 for m in loop.messages if m.text() == config.RESUME_MESSAGE), 1)
         # the shared history mirrors the compacted conversation
         self.assertEqual(
             [m.text() for m in session.last_messages], [m.text() for m in loop.messages]
@@ -1593,12 +1597,14 @@ def test_compact_keeps_prompts_excluding_nudges_and_frames(self):
             ],
         )
         self.assertTrue(loop.compact())
-        self.assertEqual([m.role for m in loop.messages], ["user", "user", "user", "user"])
+        self.assertEqual([m.role for m in loop.messages], ["user"] * 5)
         self.assertTrue(loop.messages[0].text().startswith("**[Compacted Summary]**"))
         self.assertEqual(
-            [m.text() for m in loop.messages[1:]],
+            [m.text() for m in loop.messages[1:4]],
             ["first", "second", plan_notice],
         )
+        # the automatic path closes with the resume message
+        self.assertEqual(loop.messages[4].text(), config.RESUME_MESSAGE)
 
     def test_compact_empty_summary_returns_false(self):
         """A compaction response with no text must not replace the
 
@@ -18,6 +18,7 @@
     _parse_skill_frontmatter,
     agent_exclude_tools,
     assemble_tool_instructions,
+    compacted_messages,
     discover_agents,
     discover_skills,
     index_skills,
@@ -406,6 +407,17 @@ def test_plan_exit_notice_is_latest_reminder(self):
         ]
         self.assertEqual(user_prompt_texts(msgs), ["approve the plan", notice])
 
+    def test_excludes_resume_message(self):
+        """The resume message appended by the automatic compaction is
+        harness-injected: replaying it as a prompt would stack one copy
+        per compaction and never carry task content."""
+        msgs = [
+            Message(role="user", content="real question"),
+            Message(role="assistant", content="ok"),
+            Message(role="user", content=config.RESUME_MESSAGE, injected=True),
+        ]
+        self.assertEqual(user_prompt_texts(msgs), ["real question"])
+
     def test_excludes_previous_summary_frames(self):
         frame = config.COMPACT_HEADER + "old summary" + config.COMPACT_SEPARATOR
         msgs = [
@@ -495,6 +507,34 @@ def test_no_image_part_no_note(self):
         self.assertEqual(user_prompt_texts(msgs), ["plain text"])
 
 
+class TestCompactedMessages(unittest.TestCase):
+    """The post-compaction history: summary frame, preserved prompts and
+    (automatic path only) a trailing resume message."""
+
+    def test_frame_then_prompts(self):
+        msgs = compacted_messages("sum", ["one", "two"])
+        self.assertEqual([m.role for m in msgs], ["user", "user", "user"])
+        self.assertTrue(msgs[0].text().startswith(config.COMPACT_HEADER))
+        self.assertIn("sum", msgs[0].text())
+        self.assertTrue(msgs[0].text().endswith(config.COMPACT_SEPARATOR.strip()))
+        self.assertEqual([m.text() for m in msgs[1:]], ["one", "two"])
+        self.assertFalse(any(m.injected for m in msgs))
+
+    def test_resume_message_appended_last(self):
+        """Without the resume message the history ends on a bare user
+        request, which invites redoing work the summary records."""
+        msgs = compacted_messages("sum", ["one"], resume=True)
+        self.assertEqual([m.text() for m in msgs[1:]], ["one", config.RESUME_MESSAGE])
+        self.assertTrue(msgs[-1].injected)
+        self.assertTrue(msgs[-1].role == "user")
+
+    def test_resume_message_dropped_by_prompt_filter(self):
+        """A second compaction must not carry the resume message over as
+        a user prompt."""
+        msgs = compacted_messages("sum", ["one"], resume=True)
+        self.assertEqual(user_prompt_texts(msgs), ["one"])
+
+
 class TestAssembleToolInstructions(unittest.TestCase):
     """Tests for assemble_tool_instructions and load_agent_prompt's
     {{TOOL_INSTRUCTIONS}} placeholder substitution."""
 
@@ -412,6 +412,36 @@ def test_failed_save_does_not_arm_the_debounce(self):
         self.assertEqual(self.session._last_save_at, self.clock)
 
 
+class TestRememberUserText(unittest.TestCase):
+    """The first real user message (title source) must skip harness
+    one-liners: the completion nudge and the post-compaction resume
+    message."""
+
+    def test_resume_message_not_used_as_title_source(self):
+        session = RecordingSession()
+        session.remember_user_text(
+            [
+                Message(role="user", content="real request"),
+                Message(role="assistant", content="ok"),
+                Message(role="user", content=config.RESUME_MESSAGE, injected=True),
+            ]
+        )
+        self.assertEqual(session.store.first_user_message(), "real request")
+
+    def test_restored_resume_message_not_used_as_title_source(self):
+        """A restored session loses the ``injected`` flag: the content
+        check must still keep the resume message out of the title."""
+        session = RecordingSession()
+        session.remember_user_text(
+            [
+                Message(role="user", content="real request"),
+                Message(role="assistant", content="ok"),
+                Message(role="user", content=config.RESUME_MESSAGE),
+            ]
+        )
+        self.assertEqual(session.store.first_user_message(), "real request")
+
+
 class TestTitleGeneration(unittest.TestCase):
     """Session-title generation: reasoning preamble stripped (even when
     it is not a prefix), failures logged and non-fatal."""
@@ -814,6 +844,23 @@ def test_success_keeps_every_user_prompt(self):
             ],
         )
 
+    def test_success_does_not_inject_resume_message(self):
+        """The manual command waits for the next user message: injecting
+        the automatic path's resume message would make the model start
+        working again on its own.  A resume message left by an earlier
+        automatic compaction is dropped, never carried over."""
+        session = RecordingSession()
+        session.tools_enabled = False
+        session.last_messages = [
+            Message(role="user", content="first"),
+            Message(role="assistant", content="ok"),
+            Message(role="user", content=config.RESUME_MESSAGE, injected=True),
+        ]
+        ok, _ = session.compact_conversation()
+        self.assertTrue(ok)
+        self.assertNotIn(config.RESUME_MESSAGE, [m.text() for m in session.last_messages])
+        self.assertEqual([m.text() for m in session.last_messages[1:]], ["first"])
+
     def test_success_flushes_past_the_debounce(self):
         """Compaction rewrites the whole conversation, so the save must
         bypass the auto_save debounce — otherwise the compacted history
 
@@ -11,6 +11,7 @@
 from rich.live import Live
 
 from python_agent_harness.core.models import ImagePart, Message, TextPart, ToolCall
+from python_agent_harness.session import config
 from tests.support import plan_cleanup  # noqa: F401,E402  (side-effect: auto-remove /tmp plan dirs)
 from tests.support.tui_test_utils import make_tui
 
@@ -1081,6 +1082,20 @@ def test_compacted_summary_renders_as_user_message(self):
         self.assertIn("fixed the bug", out)
         self.assertNotIn("**user:**", out)
 
+    def test_resume_message_not_rendered_as_user_input(self):
+        """The post-compaction resume message is harness-injected: it
+        must not show up as something the user typed (live sessions flag
+        it, restored sessions fall back to the content check)."""
+        tui, buf = make_tui()
+        tui.session.last_messages = [
+            Message(role="user", content=config.RESUME_MESSAGE, injected=True),
+            Message(role="user", content=config.RESUME_MESSAGE),
+        ]
+        tui.console.print(tui._render_frame())
+        out = buf.getvalue()
+        self.assertNotIn("**user:**", out)
+        self.assertNotIn("Do not repeat completed steps", out)
+
     def test_lone_surrogates_never_reach_the_terminal(self):
         """A restored session can carry lone surrogates (the tools read
         non-UTF-8 files with surrogateescape).  Rich hands them to the