@chorus-aidlc/chorus 0.19.0 → 0.19.1

package/cli/operation-prompts.mjs

@@ -0,0 +1,99 @@
+// Shared by the server compatibility snapshot and payload-driven CLI execution.
+// Keep historical entry prefixes: older clients use the Research prefix for isolation.
+import { RESEARCH_INSTRUCTION_PREFIX } from "./operation-contract.mjs";
+
+const PROJECT_INSTRUCTION_LABEL_MAX_CHARS = 200;
+
+/**
+ * Compose the conversational-idea wake instruction (template v2 — the REVIEWED CONTRACT
+ * between the conversational create-idea entry and the woken daemon agent, superseding
+ * the client-side create→claim template of add-conversational-idea-entry).
+ *
+ * The idea is PRE-CREATED and already instance-assigned + elaborating, so both templates
+ * direct EDIT (never create, never claim — a claim would fail on the existing assignee).
+ *  - `elaborate` (default): edit → optional research → elaboration → panel guidance → end turn.
+ *  - `decompose`: edit the CONTAINER → keep isContainer → one lightweight scope-clarifying
+ *    elaboration → propose candidate CHILDREN as a structured elaboration round (one
+ *    single-select question per child, ≤15/round, never a multi-select) → end turn → on the
+ *    confirm re-wake create each accepted child via chorus_pm_create_idea with
+ *    parentUuid=<container>, children starting `open`, no auto-elaboration; the container's
+ *    own status stays `elaborated`. The confirm re-wake rides the EXISTING
+ *    `elaboration_answered` wake — no new wake/notification action is introduced.
+ *
+ * English (agent-facing, matching cli/prompts.mjs precedent); the user's description
+ * passes through VERBATIM under the delimiter. Exported for unit tests: the template's
+ * wording is code, and any change is a review-visible diff.
+ * @param {{ideaUuid: string, projectUuid: string, projectName?: string|null,
+ *   descriptionText: string, mode?: 'elaborate'|'decompose', researchFirst?: boolean}} params
+ */
+export function composeConversationalIdeaInstruction(params) {
+  // Name is display sugar; bound this user-controlled metadata independently of
+  // the description. The complete UUID remains the authoritative machine anchor.
+  const projectName = params.projectName?.trim();
+  const displayName = projectName && projectName.length > PROJECT_INSTRUCTION_LABEL_MAX_CHARS
+    ? `${projectName.slice(0, PROJECT_INSTRUCTION_LABEL_MAX_CHARS - 1)}…`
+    : projectName;
+  const projectLabel = displayName
+    ? `"${displayName}" (projectUuid: ${params.projectUuid})`
+    : `projectUuid: ${params.projectUuid}`;
+
+  const researchInstruction = [
+    params.researchFirst
+      ? "The user explicitly requested lightweight research before clarification."
+      : "Research is optional: use automatic judgment for a concrete, externally verifiable factual gap.",
+    "An explicit request to skip research in the user's instructions takes precedence.",
+    "Follow the shared research skill before the first formal elaboration: one bounded pass, approximately 2–5 minutes, at most 5 deeply read relevant sources; reuse existing evidence.",
+    "Save useful findings in the existing Idea content, preserving the user's meaning, and attach evidence with real ref:UUID citations. Do not create or claim this already-created Idea.",
+    "If tools are unavailable, results are empty, or the budget is exhausted, record the limitation and continue the normal steps in this turn. Do not research user preferences; ask through the elaboration panel when needed.",
+    "This initialization request applies once, not on every later wake or stage re-entry.",
+  ].join(" ");
+
+  if (params.mode === "decompose") {
+    return [
+      `[Chorus container-decompose entry] A new CONTAINER idea has been PRE-CREATED for project ${projectLabel} from the user's description below, and it is already assigned to you (status: elaborating, isContainer: true).`,
+      `  ideaUuid: ${params.ideaUuid}`,
+      ``,
+      `This conversation IS that container idea's root session. The user wants help DECOMPOSING it into child ideas. Do the following, in order:`,
+      `1. Edit the container via chorus_edit_idea: derive a concise title from the description and polish the content (keep the user's meaning). The current title is a placeholder.`,
+      `2. Ensure it stays a container: it was pre-created with isContainer=true — do NOT clear that flag (a container groups its child ideas and MUST NOT get a proposal of its own).`,
+      `Before step 3: ${researchInstruction}`,
+      `3. Run ONE lightweight elaboration round (chorus_pm_start_elaboration) to clarify the decomposition scope/dimension — how to slice the work into children. Keep it short; you may self-answer in headless or ask the user, then continue.`,
+      `4. Propose the candidate child ideas AS A STRUCTURED ELABORATION ROUND (chorus_pm_start_elaboration) for the user to review/edit/confirm — use ONE elaboration question PER proposed child (the child's title as the question text, a short rationale as its description), single-select. Elaboration questions are single-select and a round is capped at 15 questions, so propose at most 15 candidates per round and NEVER a single multi-select question; if you need more children, propose them across additional rounds. Do NOT create any child ideas yet — this round is the preview the user accepts/edits/declines per child.`,
+      `5. End the turn. The user's answers in the idea's elaboration panel will wake this same conversation (the existing elaboration-answered wake).`,
+      `6. On that re-wake, create each ACCEPTED child via chorus_pm_create_idea with parentUuid=${params.ideaUuid}. Each child starts in the "open" state — do NOT auto-elaborate them. The container's OWN status stays "elaborated"; creating children does not advance or alter it.`,
+      ``,
+      `Reference reflex: whenever an external link is evidence for this work (a precedent issue/PR, a reference implementation, official docs, a paper/blog), attach it via references — prefer the inline references[] param at creation time over a post-hoc chorus_add_reference.`,
+      ``,
+      `--- User's idea description ---`,
+      params.descriptionText,
+    ].join("\n");
+  }
+
+  return [
+    `[Chorus conversational idea entry] A new idea has been PRE-CREATED for project ${projectLabel} from the user's description below, and it is already assigned to you (status: elaborating).`,
+    `  ideaUuid: ${params.ideaUuid}`,
+    ``,
+    `This conversation IS that idea's root session — its elaboration and lifecycle wakes will continue here. Do the following, in order:`,
+    `1. Edit the idea via chorus_edit_idea: derive a concise title from the description and polish the content (keep the user's meaning; you may restructure). The current title is a placeholder.`,
+    `2. ${researchInstruction}`,
+    `3. After that optional step, start elaboration on the idea (chorus_pm_start_elaboration), following the idea skill — do NOT wait for another wake. Post a short summary of your questions in this conversation and direct the user to answer in the idea's elaboration panel.`,
+    `4. End the turn. The user's panel answers will wake this same conversation.`,
+    ``,
+    `Reference reflex: whenever an external link is evidence for this idea (a precedent issue/PR, a reference implementation, official docs, a paper/blog), attach it via references — prefer the inline references[] param at creation time over a post-hoc chorus_add_reference.`,
+    ``,
+    `--- User's idea description ---`,
+    params.descriptionText,
+  ].join("\n");
+}
+
+/** @param {string} ideaUuid */
+export function composeResearchInstruction(ideaUuid) {
+  return [
+    `${RESEARCH_INSTRUCTION_PREFIX} Explicit, one-time research request for ideaUuid: ${ideaUuid}.`,
+    "This is the existing Idea's root conversation. Before research and again before saving, re-read the Idea, ALL related proposals/tasks and execution history including theme descendants. If development has begun, report that the stage changed and STOP without research or edits.",
+    "Invoke the shared research skill for ONE bounded pass (approximately 2–5 minutes, at most 5 deeply read sources). Reuse existing evidence. An explicit user instruction to skip research takes precedence. Tools unavailable, empty results, or exhausted budget: record the limitation and stop.",
+    "Attach useful sources through existing references and obtain real UUIDs. Read the latest Idea content immediately before saving and MERGE concise findings, source citations using ref:UUID, implications, unknowns, and the stopping reason; preserve user text and existing evidence.",
+    "Preserve all elaboration rounds, questions, answers and resolved state. Do not create or claim an Idea, start elaboration, submit or modify a Proposal, change task status, or start development. If findings affect an approved proposal, only record the impact and revision needs in the Idea.",
+    "Report the findings and END this turn. This menu invocation does not resume the Idea or Proposal workflow. A later explicit Research request may run another bounded pass.",
+  ].join("\n");
+}

package/cli/operation.mjs

@@ -0,0 +1,46 @@
+import { CONVERSATIONAL_IDEA_DESCRIPTION_MAX_CHARS, RESEARCH_INSTRUCTION_PREFIX } from "./operation-contract.mjs";
+import { composeConversationalIdeaInstruction, composeResearchInstruction } from "./operation-prompts.mjs";
+
+// Canonical operations are identified by their trigger, never by prompt text.
+export const OPERATION_ACTIONS = new Set(["idea_creation_requested", "research_requested"]);
+
+const identity = (value) => typeof value === "string" && value.length > 0 && value.length <= 100;
+
+/** Validate before dedup/admission. Routing authority always comes from the session. */
+export function validateOperation(trigger, payload, { sessionId, directIdeaUuid, projectUuid }) {
+  const creation = trigger === "idea_creation_requested";
+  const fields = creation
+    ? ["version", "kind", "ideaUuid", "projectUuid", "mode", "researchFirst", "descriptionText"]
+    : ["version", "kind", "ideaUuid"];
+  if (!OPERATION_ACTIONS.has(trigger) ||
+      !payload || typeof payload !== "object" || Array.isArray(payload) ||
+      Object.keys(payload).length !== fields.length ||
+      fields.some((field) => !Object.hasOwn(payload, field)) ||
+      payload.version !== 1 || payload.kind !== (creation ? "idea_creation" : "research") ||
+      !identity(payload.ideaUuid) || payload.ideaUuid !== directIdeaUuid ||
+      sessionId !== directIdeaUuid ||
+      (creation && (!identity(payload.projectUuid) ||
+        (projectUuid !== undefined && payload.projectUuid !== projectUuid) ||
+        !["elaborate", "decompose"].includes(payload.mode) ||
+        typeof payload.researchFirst !== "boolean" ||
+        typeof payload.descriptionText !== "string" || !payload.descriptionText.trim() ||
+        payload.descriptionText.length > CONVERSATIONAL_IDEA_DESCRIPTION_MAX_CHARS))) {
+    throw new Error("Operation protocol error: invalid payload or session/Idea identity mismatch");
+  }
+  return payload;
+}
+
+export function isExactOperation(n) {
+  return OPERATION_ACTIONS.has(n?.action) ||
+    (n?.action === "human_instruction" &&
+      n.instructionText?.startsWith(RESEARCH_INSTRUCTION_PREFIX));
+}
+
+export function buildOperationPrompt(n) {
+  const p = validateOperation(n.action, n.operationPayload, {
+    sessionId: n.sessionId, directIdeaUuid: n.directIdeaUuid, projectUuid: n.projectUuid,
+  });
+  return p.kind === "research"
+    ? composeResearchInstruction(p.ideaUuid)
+    : composeConversationalIdeaInstruction(p);
+}

package/cli/prompts.mjs

@@ -13,6 +13,8 @@
 // is deliberately no --append-system-prompt; see claude-spawner.mjs). The preamble
 // also names the CHORUS_DAEMON_HEADLESS=1 env signal the spawner sets.
 
+import { buildOperationPrompt } from "./operation.mjs";
+
 /**
  * @typedef {Object} NotificationDetail
  * @property {string} uuid
@@ -463,6 +465,9 @@ function buildPromptBody(n) {
         `chorus_get_idea / chorus_get_comments) if you need context.${actorHint}`
       );
     }
+    case "idea_creation_requested":
+    case "research_requested":
+      return buildOperationPrompt(n);
     default:
       return null;
   }
@@ -523,4 +528,6 @@ export const WAKE_ACTIONS = new Set([
   // when the body is empty/missing (nothing to act on) — so this action is a wake
   // action only when it actually carries instruction text.
   "human_instruction",
+  "idea_creation_requested",
+  "research_requested",
 ]);

package/cli/wake-queue.mjs

@@ -144,7 +144,11 @@ export class WakeQueue {
     }
     // Coalesce: take everything pending for this key right now as one batch.
     // Items that arrive after this splice accumulate for the NEXT batch.
-    const items = queue.splice(0);
+    // An isolated instruction (Research) keeps the same serial lane but cannot
+    // merge with lifecycle wakes before or after it.
+    const boundary = queue.findIndex((item) => item?.isolated === true);
+    const count = boundary === 0 ? 1 : boundary > 0 ? boundary : queue.length;
+    const items = queue.splice(0, count);
     this.running.add(key);
     this.activeCount++;
 

package/cli/waker.mjs

@@ -19,6 +19,7 @@
 // wake. A failure is logged and swallowed — it must never crash the daemon
 // (no-silent-errors: visible log, no throw).
 
+import { OPERATION_ACTIONS, isExactOperation, validateOperation } from "./operation.mjs";
 import { buildBatchPrompt } from "./prompts.mjs";
 import { writeMcpConfig } from "./mcp-config.mjs";
 import { isNewSession, SESSION_CONFLICT_FAILURE } from "./claude-spawner.mjs";
@@ -108,6 +109,9 @@ export class Waker {
     // (including daemon restart) starts with an empty guard.
     /** @type {Set<string>} */
     this.deterministicConflictGuards = new Set();
+    // Retry exact launch-abort reports after a network outage. These timers carry
+    // delivery cleanup only; the existing server turn remains the lifecycle authority.
+    this.operationRecoveryTimers = new Set();
     // Daemon graceful-shutdown flag (fix-daemon-exit-orphan-running-turn). Set once
     // by interruptAll() and never cleared — a shutting-down Waker is on its way out.
     // The wake exit path reads it to report the TURN as interrupted(shutdown), and to
@@ -188,6 +192,8 @@ export class Waker {
    */
   interruptAll() {
     this.shuttingDown = true;
+    for (const timer of this.operationRecoveryTimers) clearTimeout(timer);
+    this.operationRecoveryTimers.clear();
     for (const [key, entry] of this.executions) {
       if (entry.status !== "running" || !entry.child) continue;
       try {
@@ -366,9 +372,27 @@ export class Waker {
    */
   async wakeBatch(notifications, key, attribution) {
     let cfg;
+    let operationTurnUuid = null;
     const receivedList = Array.isArray(notifications) ? notifications : [];
+    // Defense in depth for callers bypassing the router: malformed operations
+    // never clear a conflict guard, request admission or settle a pending turn.
+    try {
+      for (const n of receivedList.filter((n) => OPERATION_ACTIONS.has(n?.action))) {
+        validateOperation(n.action, n.operationPayload, {
+          sessionId: n.sessionId, directIdeaUuid: attribution?.directIdeaUuid,
+          projectUuid: n.projectUuid,
+        });
+        if (n.entityUuid !== n.directIdeaUuid || n.entityType !== "idea" ||
+            n.directIdeaUuid !== attribution?.directIdeaUuid) {
+          throw new Error("Operation protocol error: execution identity mismatch");
+        }
+      }
+    } catch (err) {
+      this.logger.warn(`[Chorus] operation remains pending and retryable: ${err}`);
+      return;
+    }
     const hasFreshHumanInstruction = receivedList.some(
-      (n) => n?.action === "human_instruction",
+      (n) => n?.action === "human_instruction" || OPERATION_ACTIONS.has(n?.action),
     );
     if (hasFreshHumanInstruction && this.deterministicConflictGuards.delete(key)) {
       this.logger.info(
@@ -437,6 +461,8 @@ export class Waker {
     const startMs = Date.now();
     const target = entity ? `${entity.entityType}:${entity.entityUuid}` : key;
     const sessionId = directIdeaUuid ?? first?.entityUuid ?? null;
+    const operations = list.filter(isExactOperation);
+    const operationRequestUuid = batchSize === 1 && operations.length ? first.turnUuid : null;
     const requestedRuntimeCwd =
       typeof first?.runtimeCwd === "string" && first.runtimeCwd
         ? first.runtimeCwd
@@ -447,6 +473,10 @@ export class Waker {
     const arrivalAction =
       batchSize > 1 ? `coalesced batch of ${batchSize}` : first?.action;
     try {
+      if (operations.length && (!operationRequestUuid || !sessionId || batchSize !== 1)) {
+        this.logger.warn(`[Chorus] Operation requires an isolated, exact pending turn — skipping ${key}`);
+        return;
+      }
       const prompt = buildBatchPrompt(list);
       if (!prompt) {
         this.logger.info(`[Chorus] no wake prompt for ${arrivalAction} on ${key} — skipping`);
@@ -475,6 +505,7 @@ export class Waker {
           status: "running",
           startedAt: new Date().toISOString(),
           child: null,
+          ...(operationRequestUuid ? { operationTurnUuid: operationRequestUuid } : {}),
         });
         this.#emitExecutionChange();
       }
@@ -523,6 +554,39 @@ export class Waker {
         this.logger.info(`[Chorus]   cwd=${cwd} action=${arrivalAction} root=${rootIdeaUuid ?? "(none)"}`);
       }
 
+      // The server's atomic pending->running edge rechecks Research eligibility
+      // under the same lock as development acceptance. Await admission BEFORE any
+      // backend can spawn; an offline/rejected/missing reporter must fail closed.
+      if (operations.length) {
+        if (execKey && this.interrupting.has(execKey)) {
+          await this.#retireUnstartedOperation({
+            sessionId, turnUuid: operationRequestUuid, status: "interrupted",
+            interruptedReason: "user",
+          });
+          return;
+        }
+        const admission = await this.advanceTurn({
+          sessionId, turnUuid: first.turnUuid, status: "running", coalescedCount: 1,
+          entityType: entity?.entityType ?? null,
+          entityUuid: entity?.entityUuid ?? null,
+        });
+        if (!admission?.ok || admission.data?.turnUuid !== first.turnUuid) {
+          this.logger.warn(`[Chorus] Operation admission rejected or unavailable for ${key} — no subprocess started`);
+          // A conflict may belong to an already-running consumer; never abort it.
+          // Otherwise the response may have been lost AFTER admission committed.
+          // Retire this exact unstarted request whether it is pending or running.
+          if ((execKey && this.interrupting.has(execKey)) || ![404, 409].includes(admission?.status)) {
+            await this.#retireUnstartedOperation({
+              sessionId, turnUuid: operationRequestUuid, status: "interrupted",
+              interruptedReason: execKey && this.interrupting.has(execKey) ? "user" : "crash",
+              transcriptRelayError: "Operation launch admission unavailable; no subprocess started",
+            });
+          }
+          return;
+        }
+        operationTurnUuid = first.turnUuid;
+      }
+
       cfg = this.writeMcpConfigFn(this.creds);
 
       await this.hooks?.onSessionStart?.({ rootIdeaKey: key, sessionId: sessionId ?? "", isNew });
@@ -536,16 +600,29 @@ export class Waker {
       // a spawn that never started (onChild never fired) does not attempt an illegal
       // pending→ended transition. There is no separate turn registry — the turn is
       // identified server-side by `sessionId`, which the waker already has here.
-      let turnAdvancedToRunning = false;
-      let runningTurnUuidPromise = Promise.resolve(null);
+      let turnAdvancedToRunning = operationTurnUuid !== null;
+      let runningTurnUuidPromise = Promise.resolve(operationTurnUuid);
+      let childStarted = false;
 
       // Track the session id the stream reports so the transcript hook can use
       // it even before spawner.wake() returns. (Do NOT reference the awaited
       // `result` inside onMessage — it's in the temporal dead zone there.)
       let observedSessionId = sessionId ?? "";
       const onChild = (child) => {
+        childStarted = true;
         const entry = execKey ? this.executions.get(execKey) : null;
         if (entry && entry.status === "running") entry.child = child;
+        if (operationTurnUuid && (this.shuttingDown || (execKey && this.interrupting.has(execKey)))) {
+          // Some backends await binary discovery before onChild. A stop during
+          // that interval must still terminate the child as soon as it exists.
+          try {
+            Promise.resolve(this.killer(child, {
+              sigintTimeoutMs: this.sigintTimeoutMs, logger: this.logger,
+            })).catch((err) => this.logger.warn(`[Chorus] cancelled operation child kill failed: ${err}`));
+          } catch (err) {
+            this.logger.warn(`[Chorus] cancelled operation child kill failed: ${err}`);
+          }
+        }
         if (sessionId && !turnAdvancedToRunning) {
           turnAdvancedToRunning = true;
           // Fire-and-forget; #advanceTurn swallows + logs its own failures so a
@@ -589,6 +666,14 @@ export class Waker {
         onChild,
         onMessage,
       };
+      if (operationTurnUuid && (this.shuttingDown || (execKey && this.interrupting.has(execKey)))) {
+        await this.#retireUnstartedOperation({
+          sessionId, turnUuid: operationTurnUuid, status: "interrupted",
+          interruptedReason: execKey && this.interrupting.has(execKey) ? "user" : "shutdown",
+          transcriptRelayError: "Operation cancelled before subprocess launch",
+        });
+        return;
+      }
       let result = await this.spawner.wake(wakeParams);
 
       // Claude can still reject a new-session launch when its durable session exists
@@ -597,6 +682,7 @@ export class Waker {
       // child for interrupt handling; onChild's gate keeps pending→running exactly once.
       if (
         isNew &&
+        !(operationTurnUuid && (this.shuttingDown || (execKey && this.interrupting.has(execKey)))) &&
         result?.failureClassification === SESSION_CONFLICT_FAILURE
       ) {
         this.logger.warn(
@@ -611,6 +697,15 @@ export class Waker {
         }
       }
 
+      if (operationTurnUuid && !childStarted) {
+        await this.#retireUnstartedOperation({
+          sessionId, turnUuid: operationTurnUuid, status: "interrupted",
+          interruptedReason: execKey && this.interrupting.has(execKey) ? "user" : "crash",
+          transcriptRelayError: "Operation subprocess did not start",
+        });
+        return;
+      }
+
       if (result && !probeIsAuthoritative) {
         this.logger.info(
           `[Chorus] backend ${result.isNew ? "started new" : "resumed"} session ${result.sessionId ?? sessionId ?? "(none)"}`
@@ -746,7 +841,16 @@ export class Waker {
       }
     } catch (err) {
       this.logger.warn(`[Chorus] wake failed for ${key}: ${err}`);
-      if (sessionId && requestedRuntimeCwd && typeof err?.code === "string") {
+      if (operationRequestUuid && sessionId) {
+        // Admission succeeded but setup/spawn threw: retire this exact turn so a
+        // failed launch cannot leave an indefinitely running operation.
+        await this.#retireUnstartedOperation({
+          sessionId, turnUuid: operationRequestUuid, status: "interrupted",
+          interruptedReason: execKey && this.interrupting.has(execKey) ? "user"
+            : requestedRuntimeCwd && typeof err?.code === "string" ? "invalid_path" : "crash",
+          transcriptRelayError: String(err?.message ?? err).slice(0, 500),
+        });
+      } else if (sessionId && requestedRuntimeCwd && typeof err?.code === "string") {
         const invalidPathTurnUuid = await this.#advanceTurn(sessionId, "running", entity);
         await this.#advanceTurn(
           sessionId,
@@ -785,6 +889,25 @@ export class Waker {
     }
   }
 
+  async #retireUnstartedOperation(report) {
+    try {
+      const result = await this.advanceTurn(report);
+      // Terminal retries are idempotent. A 404/409 means this exact row is gone
+      // or already settled differently; no other turn is selected or changed.
+      if (result?.ok || [404, 409].includes(result?.status)) return;
+    } catch (err) {
+      this.logger.warn(`[Chorus] Operation launch cleanup failed for ${report.turnUuid}: ${err}`);
+    }
+    if (this.shuttingDown) return; // offline reconcile / pending backfill owns restart
+    this.logger.warn(`[Chorus] Operation launch cleanup deferred for ${report.turnUuid}; retrying in 30s`);
+    const timer = setTimeout(() => {
+      this.operationRecoveryTimers.delete(timer);
+      void this.#retireUnstartedOperation(report);
+    }, 30_000);
+    timer.unref?.();
+    this.operationRecoveryTimers.add(timer);
+  }
+
   /**
    * Report an interrupted/crashed outcome via the injected reporter. Never throws
    * into the wake path — a reporter failure is logged and swallowed (the reporter

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chorus-aidlc/chorus",
-  "version": "0.19.0",
+  "version": "0.19.1",
   "description": "The Agent Harness for AI-Human Collaboration — session lifecycle, task state, sub-agent orchestration, observability, and failure recovery",
   "homepage": "https://github.com/Chorus-AIDLC/Chorus",
   "repository": {

package/prisma/migrations/20260927073000_add_daemon_operation_payload/migration.sql

@@ -0,0 +1 @@
+ALTER TABLE "DaemonSessionTurn" ADD COLUMN "operationPayload" JSONB;

package/prisma/schema.prisma

@@ -719,8 +719,9 @@ model DaemonSessionTurn {
   // immutable first-wake compatibility anchor.
   backendSessionId  String?
   seq               Int // monotonic per session
-  trigger           String // task_assigned | mentioned | elaboration | elaboration_verified | start_development | yolo_requested | resume | human_instruction
-  promptText        String? // free-text body for human_instruction; null otherwise (canonical source)
+  trigger           String // task_assigned | mentioned | elaboration | elaboration_verified | start_development | yolo_requested | resume | human_instruction | idea_creation_requested | research_requested
+  promptText        String? // human instruction body or server-composed operation compatibility snapshot
+  operationPayload  Json? // versioned dedicated operation; historical rows remain null
   status            String                    @default("pending") // pending | running | ended | interrupted
   // Discriminator for the `interrupted` status: `user` = user-requested interrupt,
   // `crash` = subprocess exited dirty, `shutdown` = daemon graceful shutdown killed