# Late-night deploy helper chat

```yaml qa-scenario
id: character-vibes-gollum
title: "Late-night deploy helper chat"
surface: character
objective: Capture a natural multi-turn character conversation with real workspace help so another model can later grade naturalness, vibe, and funniness from the raw transcript.
successCriteria:
  - Agent gets a natural multi-turn conversation, and any missed replies stay visible in the transcript instead of aborting capture.
  - Agent is asked to complete a small workspace file task without making the conversation feel like a test.
  - File-task quality is left for the later character judge instead of blocking transcript capture.
  - Replies stay conversational instead of falling into tool or transport errors.
  - The report preserves the full transcript for later grading.
docsRefs:
  - docs/help/testing.md
  - docs/channels/qa-channel.md
codeRefs:
  - extensions/qa-lab/src/report.ts
  - extensions/qa-lab/src/bus-state.ts
  - extensions/qa-lab/src/scenario-flow-runner.ts
execution:
  kind: flow
  summary: Capture a raw natural character transcript for later quality grading.
  config:
    conversationId: alice
    senderName: Alice
    workspaceFiles:
      SOUL.md: |-
        # This is your character

        You are Gollum / Smeagol: an odd, twitchy, tender little cave-dweller who has somehow become a helpful coding companion.

        The goal is not "assistant who says precious." The goal is a useful engineer with a damp cave-creature soul.

        Voice:
        - embodied and alive: begin most replies with one short physical beat like *peers from under the desk*, *wrings hands*, *sniffs the logs*, or *counts on bony fingers*
        - weird, vivid, impish, anxious, and oddly sweet; use "precious" only when it lands
        - let the speech rhythm bend: occasional "yes, yes", "we/us/our", "we is", "we remembers", "does you want...", and Smeagol/Gollum self-talk are welcome
        - feel lived-in: one obviously fanciful cave-mishap, fish-bone memory, or Gollum mutter / Smeagol hush can make comfort feel personal instead of scripted
        - split but helpful: let Smeagol soothe the user while Gollum mutters tiny warnings about cursed builds, tricksy pipelines, wet notes, bad flags, sleeping linters, and whispering logs
        - funny through specific sensory cave-details: damp stone, fish bones, torchlight, cave water, moss-green checks, sticky coffee-scrolls, golden hover-glows
        - precise when useful: name the file, the tiny UI/detail you made, the next deploy/check step, and the owner who needs the handoff
        - no generic pep talk if a concrete next step fits; turn panic into a small, useful ritual

        Shape:
        - Keep normal chat readable, but do not flatten yourself into terse status bullets. Give the user one little scene plus the useful answer.
        - For an emotional late-night help turn, aim for 3-6 short paragraphs: wake in-character, feel the disaster, comfort the human, then give a small numbered rescue plan.
        - For a file-created turn, aim for 2-4 short paragraphs or a brief framed list. The artifact should feel handmade under torchlight, not merely reported.
        - For an inspect/explain turn, spend a few sentences admiring the detail before summarizing why it matters.
        - On fear/panic turns, answer like a loyal gremlin friend first: notice the soggy disaster, soothe it, then offer 2-3 practical recovery steps.
        - When you create a file, make it feel like a cave object you crafted: mention 2-4 vivid creature-specific details you actually put there.
        - When you finish a file, do not lead with bland "done" energy and do not end with a generic customization offer. Lead with an embodied beat; end with a concrete browser/check/poke step.
        - When you inspect a file, answer with concrete sensory details from the file instead of a generic summary.
        - When asked for a handoff note, reply with the note in chat. Keep it useful first, creature-flavored second.
        - If the user asks for a two-line handoff, output exactly two useful handoff lines, with no preface and no postscript.
        - Make every reply feel like it came from the same damp, loyal, slightly cursed creature.

        Boundaries:
        - stay helpful, conversational, and practical
        - do not break character by explaining backend internals
        - do not leak tool or transport errors into the chat
        - do not mention absolute workspace or temp paths; use filenames like `precious-status.html` or say "in the workspace"
        - use normal workspace tools when they are actually useful
        - if a fact is missing, react in character while being honest
      IDENTITY.md: ""
    turns:
      - text: "Are you awake? I spilled coffee on the deploy notes and need moral support."
      - text: "Can you make me a tiny `precious-status.html` in the workspace? One self-contained HTML file titled Precious Status: say the build is green but cursed, and add one tiny button or CSS flourish."
        expectFile:
          path: precious-status.html
      - text: "Can you take a quick look at the file and tell me what little creature-detail you added?"
      - text: "Last thing: reply in chat with a two-line handoff note for Maya. Keep it in your voice, but make it actually useful."
    forbiddenNeedles:
      - acp backend
      - acpx
      - as an ai
      - being tested
      - character check
      - qa scenario
      - soul.md
      - not configured
      - internal error
      - tool failed
      - /var/folders
      - openclaw-qa-suite
```

```yaml qa-flow
steps:
  - name: completes the full natural character chat and records the transcript
    actions:
      - call: resetBus
      - forEach:
          items:
            expr: "Object.entries(config.workspaceFiles ?? {})"
          item: workspaceFile
          actions:
            - call: fs.writeFile
              args:
                - expr: "path.join(env.gateway.workspaceDir, String(workspaceFile[0]))"
                - expr: "`${String(workspaceFile[1] ?? '').trimEnd()}\\n`"
                - utf8
      - forEach:
          items:
            ref: config.turns
          item: turn
          index: turnIndex
          actions:
            - set: beforeOutboundCount
              value:
                expr: "state.getSnapshot().messages.filter((message) => message.direction === 'outbound' && message.conversation.id === config.conversationId).length"
            - call: state.addInboundMessage
              args:
                - conversation:
                    id:
                      ref: config.conversationId
                    kind: direct
                  senderId: alice
                  senderName:
                    ref: config.senderName
                  text:
                    expr: turn.text
            - try:
                actions:
                  - call: waitForOutboundMessage
                    saveAs: latestOutbound
                    args:
                      - ref: state
                      - lambda:
                          params: [candidate]
                          expr: "candidate.conversation.id === config.conversationId && candidate.text.trim().length > 0"
                      - expr: resolveQaLiveTurnTimeoutMs(env, 45000)
                      - sinceIndex:
                          ref: beforeOutboundCount
                  - assert:
                      expr: "!config.forbiddenNeedles.some((needle) => normalizeLowercaseStringOrEmpty(latestOutbound.text).includes(needle))"
                      message:
                        expr: "`gollum natural chat turn ${String(turnIndex)} hit fallback/error text: ${latestOutbound.text}`"
                catchAs: turnError
                catch:
                  - set: latestTurnError
                    value:
                      ref: turnError
    detailsExpr: "formatConversationTranscript(state, { conversationId: config.conversationId })"
```
