feat(tasks): phase 5 — ask_operator (structured question, pause, resume)

The last backend piece: when the agent hits a decision only the operator can
make, it surfaces a structured question instead of guessing or stalling.

- ask_operator(prompt, why?, options?, context_entities?): nomos-local tool
  that records a session_questions row, moves the task to awaiting_input, emits
  question.raised, and ENDS the turn (the agent loop returns after it, so the
  agent can't barrel past its own question). The prompt becomes the assistant's
  visible message so the question also shows inline in the transcript.
- Two resume paths, both close the question + emit question.answered + return
  the task to executing:
  - Panel: POST /sessions/{id}/questions/{qid}/answer → resumes the agent in the
    background with the answer injected (reusing the continuation machinery,
    refactored continueSession → resumeSession). Returns 202; the reply lands via
    message polling.
  - Chat reply: the next chat message on a task with an open question IS the
    answer — auto-closed in handleChat; the turn itself is the resume.

Verified end-to-end: forcing a decision paused the task at awaiting_input with
the structured question (prompt/why/options/entities); a panel answer resumed
the agent (it acknowledged host:strong and continued); a plain chat reply
auto-closed a second question. Cleanup + tests green.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

cmd/nomos/continue.go

@@ -82,17 +82,24 @@ func (a *agent) processContinuations(ctx context.Context) {
 // complaint this exists to fix — polling alone only helps if there's
 // something new to poll for.
 func (a *agent) continueSession(ctx context.Context, p pendingContinuation) {
-	note := buildContinuationNote(p)
 	slog.Info("nomos: auto-continuing session", "session", p.SessionID, "execution", p.ExecID, "status", p.Status)
+	a.resumeSession(ctx, p.SessionID, buildContinuationNote(p))
+}
 
+// resumeSession re-invokes the agent for a session with a system-injected note —
+// a finished execution (continueSession) or an operator's answer to a question
+// (handleAnswerQuestion) — persisting progress LIVE (a placeholder row updated
+// in place as each tool call lands) so the frontend poller sees each step,
+// instead of total silence until the whole resume concludes.
+func (a *agent) resumeSession(ctx context.Context, sessionID, note string) {
 	placeholder, _ := json.Marshal(map[string]any{
 		"role": "assistant",
 		"text": "",
 		"auto": true,
 	})
-	msgID, err := a.store.insertMessageReturningID(ctx, p.SessionID, "assistant", placeholder)
+	msgID, err := a.store.insertMessageReturningID(ctx, sessionID, "assistant", placeholder)
 	if err != nil {
-		slog.Error("nomos: continuation placeholder insert failed", "session", p.SessionID, "error", err)
+		slog.Error("nomos: resume placeholder insert failed", "session", sessionID, "error", err)
 	}
 
 	var toolCalls []map[string]any
@@ -141,17 +148,17 @@ func (a *agent) continueSession(ctx context.Context, p pendingContinuation) {
 				errText, _ = ev.Data.(string)
 			}
 		}
-		a.chatWith(cctx, p.SessionID, "", note, emit)
+		a.chatWith(cctx, sessionID, "", note, emit)
 		if finalText != "" || len(toolCalls) > 0 {
 			break
 		}
 		if attempt == 0 {
-			slog.Warn("nomos: auto-continuation produced nothing, retrying once", "session", p.SessionID, "execution", p.ExecID, "error", errText)
+			slog.Warn("nomos: resume produced nothing, retrying once", "session", sessionID, "error", errText)
 		}
 	}
 
 	if errText != "" && finalText == "" {
-		slog.Error("nomos: auto-continuation produced no response after retry", "session", p.SessionID, "execution", p.ExecID, "error", errText)
+		slog.Error("nomos: resume produced no response after retry", "session", sessionID, "error", errText)
 	}
 	persist() // final state — same row, updated one last time with the concluding text
 }