feat(resume-builder): Slice 1B — full conversation history + proactive_offer chip

The two user complaints behind this slice:
  1. "Is each new question going to a fresh gpt instance?" — agent was
     forgetting mid-session because build_resume_builder_prompt hard-
     sliced history at [-12:].
  2. "I want it to suggest things — like draft a summary based on what
     I've shared" — agent never volunteered, only answered.

Slice 1B addresses both end-to-end (backend + UI):

- Dropped the [-12:] truncation. New _slice_history_for_budget helper
  takes the most recent suffix that fits under 30k chars (~7.5k
  tokens); always keeps at least the newest entry. In-memory cap
  bumped 48 → 200 entries (the per-prompt char budget defends the
  token budget; the entry cap is a long-session memory safety valve).
- Added proactive_offer: str | None as a 5th key to the resume_builder
  LLM contract. Prompt teaches the model when to fire (enough signal
  to draft something) and HOW to phrase it (first-person imperative
  CTA, not a question or vague offer). Concrete good/bad examples in
  the prompt; cap of 200 chars at the backend boundary.
- _run_llm_turn returns (assistant_message, proactive_offer); threaded
  through _serialize_session into the response payload.
- Frontend: ResumeBuilderSessionResponse gets proactive_offer field.
  ResumeIntake renders it as a "✨ ..." pill below the assistant
  message when present. handleResumeBuilderAnswer now accepts an
  optional overrideText so the chip submits the offer directly
  without round-tripping through the textarea state.
- 4 new tests for the budget-aware history slicer (under/over budget,
  single-entry-over-budget kept, empty input).

Verification: 172 tests across affected suites all green (168 → 172).
Frontend tsc + eslint exit 0.

What's still parked (report.md Phase 2/3): pending_followups[] promise
tracking, web_search tool, full conversational eval (15-20 rubric-
scored fixtures), ADR-031.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: LEANDERANTONY

backend/services/resume_builder_service.py

@@ -1512,6 +1512,7 @@ def _serialize_session(
     session: ResumeBuilderSession,
     *,
     assistant_message: str | None = None,
+    proactive_offer: str | None = None,
 ):
     # `_step_index("review")` returns 0 because "review" isn't in
     # RESUME_BUILDER_STEPS — that used to flicker the UI back to 0%
@@ -1533,6 +1534,12 @@ def _serialize_session(
         "total_steps": len(RESUME_BUILDER_STEPS),
         "progress_percent": progress_percent,
         "assistant_message": assistant_message or _current_prompt(session.current_step),
+        # Slice 1B: optional click-to-accept CTA the UI renders as a
+        # chip below the assistant_message. Carried only on turns
+        # where the LLM fired one — other call sites (regex fallback,
+        # /update, /generate, /commit) leave this null because there's
+        # no LLM payload to read it from.
+        "proactive_offer": proactive_offer,
         "draft_profile": asdict(session.draft),
         "generated_resume_markdown": session.generated_resume_markdown,
         "generated_resume_plain_text": session.generated_resume_plain_text,
@@ -1899,11 +1906,14 @@ def _run_llm_turn(
 ):
     """Drive one conversational turn through the LLM intake prompt.
 
-    Returns the assistant message text on success. Mutates the session
-    in place: applies `draft_updates`, updates `status` and
-    `current_step`, appends the user/assistant turn pair to
-    `conversation_history`. Raises `AgentExecutionError` on any failure
-    so the caller can swallow it and fall back to the regex flow.
+    Returns a tuple ``(assistant_message, proactive_offer)`` on
+    success. ``proactive_offer`` is a short CTA string the UI renders
+    as a clickable chip below the assistant_message, or None when the
+    model didn't fire one this turn. Mutates the session in place:
+    applies `draft_updates`, updates `status` and `current_step`,
+    appends the user/assistant turn pair to `conversation_history`.
+    Raises `AgentExecutionError` on any failure so the caller can
+    swallow it and fall back to the regex flow.
 
     Slice 1A: when the OpenAIService exposes a `run_tool_loop`
     method (the agentic-loop entry-point that supports Responses-API
@@ -1973,6 +1983,25 @@ def _run_llm_turn(
     if not assistant_message:
         raise AgentExecutionError("LLM returned an empty assistant_message.")
 
+    # Slice 1B: proactive_offer rides on the assistant_message turn but
+    # is rendered separately by the UI (as a clickable chip the user
+    # can accept with one click). Null / empty / placeholder values
+    # are normalized to None so the UI doesn't render a dead chip.
+    raw_offer = payload.get("proactive_offer")
+    proactive_offer: str | None
+    if isinstance(raw_offer, str):
+        stripped = raw_offer.strip()
+        # Cap at a friendly length — the chip button can't render a
+        # full sentence comfortably. Past this the prompt is doing
+        # something wrong (writing a question, not a CTA); cropping
+        # also defends the UI from accidental paragraph blobs.
+        if 0 < len(stripped) <= 200:
+            proactive_offer = stripped
+        else:
+            proactive_offer = None
+    else:
+        proactive_offer = None
+
     raw_status = str(payload.get("status") or "").strip().lower()
     status = raw_status if raw_status in _VALID_STATUSES else "collecting"
     session.status = status
@@ -2015,14 +2044,20 @@ def _run_llm_turn(
     session.conversation_history.append(
         {"role": "assistant", "content": assistant_message}
     )
-    # Cap memory: keep only the last 24 turn pairs (+ any interleaved
-    # tool events) so a long session doesn't blow the prompt budget.
-    # The model still sees enough context for back-references; older
-    # turns are summarized by the current `draft` state itself.
-    if len(session.conversation_history) > 48:
-        session.conversation_history = session.conversation_history[-48:]
-
-    return assistant_message
+    # Cap memory: keep up to ~100 turn pairs (+ any interleaved tool
+    # events) per session. Slice 1B widened this from the previous 48
+    # entries because the user complaint was "is each new question
+    # going to a fresh gpt instance?" — the agent was forgetting
+    # mid-session, and a 12-pair window was clearly too narrow. The
+    # prompt-time guard
+    # (``prompts._slice_history_for_budget`` with a 30k-char cap) is
+    # what actually defends the per-turn token budget; this hard cap
+    # is just a long-session memory safety valve so pathological
+    # sessions don't grow unboundedly in process memory.
+    if len(session.conversation_history) > 200:
+        session.conversation_history = session.conversation_history[-200:]
+
+    return assistant_message, proactive_offer
 
 
 def _advance_step_after_regex_apply(session: ResumeBuilderSession, current_step: str):
@@ -2068,14 +2103,15 @@ def answer_resume_builder_message(
     # on JSON-decode failures, or on any other LLM error.
     if openai_service is not None and openai_service.is_available():
         try:
-            assistant_message = _run_llm_turn(
+            assistant_message, proactive_offer = _run_llm_turn(
                 session=session,
                 user_message=normalized_message,
                 openai_service=openai_service,
             )
             return _serialize_session(
                 session,
                 assistant_message=assistant_message,
+                proactive_offer=proactive_offer,
             )
         except AgentExecutionError as exc:
             log_event(

docs/DEVLOG.md

@@ -1687,3 +1687,107 @@ plan):
 Slice 1A demo path: paste a public GitHub URL into the resume builder
 and watch the agent read it. The honesty patch + tool dispatch fall
 out for free.
+
+## Day 57: Résumé-builder Slice 1B — full conversation history + `proactive_offer` chip
+
+Slice 1A made the agent capable; Slice 1B makes it FEEL intelligent.
+The two user complaints behind this slice:
+
+1. "Is each new question going to a fresh gpt instance?" — the agent
+   was forgetting mid-conversation. Why: `build_resume_builder_prompt`
+   hard-sliced history at `[-12:]` (the last 6 user/assistant pairs).
+   Past that point the model saw nothing — no context, no callbacks,
+   no "as I said earlier." Felt like a fresh instance because, prompt-
+   wise, it nearly was.
+2. "I want it to suggest things — like draft a summary based on the
+   projects I shared, the way you do." — the agent never volunteered.
+   It asked questions and saved answers; it never said "given what
+   we have, want me to draft your professional summary?"
+
+Slice 1B addresses both, end-to-end (backend + UI):
+
+**(1) Full conversation history with a character-budget guard.**
+
+- Dropped the hard `history[-12:]` slice in `build_resume_builder_prompt`.
+- New `_slice_history_for_budget(history, max_chars=...)` helper
+  (default 30 000 chars ≈ ~7 500 tokens) walks newest-first,
+  accumulating serialized entries until adding the next would exceed
+  budget. Returns a contiguous SUFFIX of the history in chronological
+  order. ALWAYS keeps at least the most recent entry so an over-budget
+  newest message doesn't silently break the chat.
+- The in-memory `conversation_history` cap bumped from 48 to 200
+  (~100 turn pairs + interleaved tool events) — the soft prompt-time
+  guard is what defends per-turn token budget; the hard cap is a
+  pathological-session memory safety valve.
+- New unit tests for the slicer (4 cases: under-budget passthrough;
+  over-budget keeps a suffix; single-entry-over-budget still returned;
+  empty/None input).
+
+**(2) `proactive_offer` JSON channel + UI chip.**
+
+- Added `proactive_offer: str | None` as a 5th key to the resume-
+  builder LLM contract. Documented in
+  `prompts/resume_builder/v1.json` with concrete examples of GOOD
+  offers ("Draft my professional summary"; "Group my skills into
+  Languages / Frameworks / Tools") and BAD ones ("Help me with my
+  resume" — too vague; "Continue" — not an action; "Are you done?"
+  — that's a question, not an offer). The prompt also tells the
+  model the CTA is rendered FROM THE USER'S point of view (first-
+  person imperative), so the user clicks the chip to say "yes, do
+  that." Mirrored byte-for-byte in `tests/test_prompts.py` and added
+  to the `expected_keys` assertion so a typo in the JSON fails at
+  parse time. Slice 1B also caps the offer at 200 chars at the
+  backend boundary — defense against a model that returns a full
+  paragraph instead of a CTA.
+- `_run_llm_turn` returns a `(assistant_message, proactive_offer)`
+  tuple; the caller (`answer_resume_builder_message`) threads the
+  offer through to `_serialize_session`, which adds it to the
+  response payload alongside `assistant_message`.
+- Frontend: added `proactive_offer?: string | null` to
+  `ResumeBuilderSessionResponse`. In `ResumeIntake.tsx`, when the
+  field is populated, render a single pill-shaped chip below the
+  assistant message ("✨ Draft my professional summary"). The chip
+  calls a new `onBuilderProactiveOfferAccept(offer)` callback —
+  `handleResumeBuilderAnswer` in `WorkspaceShell` now accepts an
+  optional `overrideText` parameter, so the chip submits the offer
+  text directly without round-tripping through the textarea state
+  (avoiding the React setState async window where a Continue click
+  fires before the prefilled value commits).
+
+What this changes for users:
+
+- The agent remembers across the whole session — you can correct a
+  field you mentioned 15 turns ago and the model knows what you're
+  referring to. Within prompt-budget anyway (30k chars ≈ ~25 dense
+  turn pairs; for typical sessions, the whole thing fits).
+- The agent volunteers. Once you've shared a few projects and
+  experience entries, you'll see a "✨ Draft my professional summary"
+  chip pop up — one click and the model goes off and writes it from
+  what you've already told it. No more typing "yes, do that" by hand.
+
+What's still parked (`report.md` Phase 2/3):
+
+- Promise tracking (`pending_followups[]` session state, so the agent
+  remembers things it said it would do later)
+- `web_search` tool for company / role / domain context
+- Full conversational eval (15–20 hand-curated transcript fixtures
+  + rubric) — important quality infra; the smaller 5–8 fixture
+  minimal eval is also still parked. Slice 1B intentionally doesn't
+  block on eval; the changes are additive (existing behavior
+  preserved when `proactive_offer` is null and full history fits
+  under budget) and locally tested.
+- ADR-031 for the agentic shape (draft during Slice 1C, accept when
+  the rest of Phase 2 lands).
+
+Verification: **172 tests** across `tests/test_prompts.py` +
+`tests/test_resume_builder.py` + the Slice 1A tool tests +
+`test_prompt_registry` + `test_cost_tracking` +
+`test_structured_outputs` + `test_backend_workspace` — all green
+(168 → 172, the 4 added are the budget-slicer unit tests). Frontend
+`tsc --noEmit` clean (exit 0). Frontend `eslint src` clean (exit 0).
+
+Demo path: open the resume builder, give the agent a couple of
+projects + an experience entry, watch the "✨ Draft my professional
+summary" chip appear below its next reply. Click it — the agent
+writes the summary from what you've told it so far. No retyping, no
+restating.

frontend/src/components/workspace/ResumeIntake.tsx

@@ -162,6 +162,12 @@ export type ResumeIntakeProps = {
   onBuilderExportThemeChange: (theme: ArtifactTheme) => void;
   onBuilderExport: (format: WorkspaceArtifactExportFormat) => void;
   onBuilderAnswerSubmit: () => void;
+  /** Slice 1B: accept the assistant's proactive offer (one-click CTA
+   *  chip). The offer text is submitted as the next user turn so the
+   *  agent can act on it immediately. Optional so callers that
+   *  haven't been updated still work — when omitted, the chip just
+   *  doesn't render. */
+  onBuilderProactiveOfferAccept?: (offer: string) => void;
   onBuilderGenerate: () => void;
   onBuilderCommit: () => void;
   onBuilderDraftSave: () => void;
@@ -206,6 +212,7 @@ export function ResumeIntake({
   onBuilderExportThemeChange,
   onBuilderExport,
   onBuilderAnswerSubmit,
+  onBuilderProactiveOfferAccept,
   onBuilderGenerate,
   onBuilderCommit,
   onBuilderDraftSave,
@@ -588,6 +595,41 @@ export function ResumeIntake({
                   </p>
                 )}
 
+                {/* Slice 1B: proactive_offer renders as a single
+                    one-click CTA chip below the latest assistant
+                    reply. Hidden during loading so the user can't
+                    double-submit while a turn is in flight. The
+                    parent owns the actual submit — clicking calls
+                    `onBuilderProactiveOfferAccept(offer)` which
+                    bypasses the textarea state and dispatches the
+                    offer text as the next user turn. */}
+                {builderSession?.proactive_offer &&
+                onBuilderProactiveOfferAccept &&
+                !builderLoading ? (
+                  <button
+                    aria-label={`Accept assistant suggestion: ${builderSession.proactive_offer}`}
+                    className="rd-btn rd-btn-sm"
+                    onClick={() =>
+                      onBuilderProactiveOfferAccept(
+                        builderSession.proactive_offer ?? "",
+                      )
+                    }
+                    style={{
+                      alignSelf: "flex-start",
+                      background: "var(--surface-2)",
+                      border: "1px solid var(--border-1)",
+                      borderRadius: 999,
+                      color: "var(--fg-1)",
+                      fontSize: 12.5,
+                      fontWeight: 500,
+                      padding: "6px 12px",
+                    }}
+                    type="button"
+                  >
+                    ✨ {builderSession.proactive_offer}
+                  </button>
+                ) : null}
+
                 {builderNotice ? (
                   <div className={noticeClassName(builderNotice.level)}>
                     {builderNotice.message}

frontend/src/components/workspace/WorkspaceShell.tsx

@@ -1281,13 +1281,17 @@ export function WorkspaceShell() {
     }
   }
 
-  async function handleResumeBuilderAnswer() {
+  async function handleResumeBuilderAnswer(overrideText?: string) {
     if (!resumeBuilderSession) {
       await handleStartResumeBuilder();
       return;
     }
 
-    if (!resumeBuilderAnswer.trim()) {
+    // Slice 1B: the proactive_offer chip submits the offer text
+    // directly, bypassing the textarea state — this is the
+    // override path. Plain Continue clicks use the textarea state.
+    const rawText = overrideText ?? resumeBuilderAnswer;
+    if (!rawText.trim()) {
       setResumeBuilderNotice({
         level: "warning",
         message: "Add an answer before continuing.",
@@ -1301,7 +1305,7 @@ export function WorkspaceShell() {
       message: "Saving your answer and moving to the next step...",
     });
 
-    const userMessage = resumeBuilderAnswer.trim();
+    const userMessage = rawText.trim();
     try {
       const response = await sendResumeBuilderMessage(
         resumeBuilderSession.session_id,
@@ -2235,6 +2239,9 @@ export function WorkspaceShell() {
             mode={resumeIntakeMode}
             onBuilderAnswerChange={setResumeBuilderAnswer}
             onBuilderAnswerSubmit={() => void handleResumeBuilderAnswer()}
+            onBuilderProactiveOfferAccept={(offer) =>
+              void handleResumeBuilderAnswer(offer)
+            }
             onBuilderCommit={() => void handleResumeBuilderCommit()}
             onBuilderDraftSave={() => void handleResumeBuilderDraftSave()}
             onBuilderExport={(format) =>

frontend/src/lib/api-types.ts

@@ -363,6 +363,14 @@ export type ResumeBuilderSessionResponse = {
   total_steps: number;
   progress_percent: number;
   assistant_message: string;
+  /** Slice 1B: optional one-click CTA the LLM fires when it has
+   *  enough signal to draft a piece of the resume (e.g. "Draft my
+   *  professional summary from what we have so far"). UI renders as
+   *  a small chip below the assistant_message; click submits the
+   *  offer text as the next user turn. Null on turns where the model
+   *  didn't fire one — most turns leave this null because asking the
+   *  next question is more useful than offering a draft. */
+  proactive_offer?: string | null;
   draft_profile: ResumeBuilderDraftProfile;
   generated_resume_markdown: string;
   generated_resume_plain_text: string;