@growthub/cli 0.10.1 → 0.12.1

package/assets/worker-kits/growthub-custom-workspace-starter-v1/apps/workspace/app/api/workspace/helper/apply/route.js

@@ -0,0 +1,307 @@
+/**
+ * POST /api/workspace/helper/apply
+ *
+ * Governed mutation endpoint for workspace helper proposals.
+ *
+ * Takes accepted WorkspaceHelperProposal objects from a prior query response,
+ * validates each against the PATCH allowlist + validateWorkspaceConfig, writes
+ * the merged config, and persists a durable receipt per applied proposal.
+ *
+ * The apply step is always explicit and human-reviewed. The helper never
+ * calls this route on its own — it is a separate governed action.
+ *
+ * Request body (WorkspaceHelperApplyRequest):
+ *   {
+ *     proposals: WorkspaceHelperProposal[],
+ *     reviewedBy?: string,
+ *     sessionId?: string,
+ *   }
+ *
+ * Response (WorkspaceHelperApplyResponse):
+ *   {
+ *     ok: boolean,
+ *     applied: WorkspaceHelperApplyReceipt[],
+ *     skipped: { proposal, reason }[],
+ *     workspaceConfig?: object,
+ *     error?: string,
+ *   }
+ */
+
+import { NextResponse } from "next/server";
+import {
+  readWorkspaceConfig,
+  writeWorkspaceConfig,
+  readWorkspaceSourceRecords,
+  writeWorkspaceSourceRecords,
+  describePersistenceMode,
+} from "@/lib/workspace-config";
+import {
+  applyProposalToConfig,
+  validateProposalForApply,
+  buildApplyReceipt,
+  upsertHelperThreadRow,
+} from "@/lib/workspace-helper-apply";
+
+const HELPER_APPLY_SOURCE_KEY = "helper:apply:receipts";
+
+async function POST(request) {
+  let body;
+  try {
+    body = await request.json();
+  } catch {
+    return NextResponse.json({ ok: false, error: "invalid JSON body" }, { status: 400 });
+  }
+
+  if (!Array.isArray(body?.proposals) || body.proposals.length === 0) {
+    return NextResponse.json(
+      { ok: false, error: "proposals must be a non-empty array" },
+      { status: 400 }
+    );
+  }
+
+  const reviewedBy = typeof body.reviewedBy === "string" ? body.reviewedBy.trim() : "user";
+  const sessionId = typeof body.sessionId === "string" ? body.sessionId.trim() : null;
+  const threadId = typeof body.threadId === "string" && body.threadId.trim() ? body.threadId.trim() : null;
+  const appliedAt = new Date().toISOString();
+
+  let currentConfig;
+  try {
+    currentConfig = await readWorkspaceConfig();
+  } catch (err) {
+    return NextResponse.json(
+      { ok: false, error: err?.message || "failed to read workspace config" },
+      { status: 500 }
+    );
+  }
+
+  const applied = [];
+  const skipped = [];
+  let workingConfig = currentConfig;
+
+  for (const proposal of body.proposals) {
+    if (
+      !proposal ||
+      typeof proposal.type !== "string" ||
+      typeof proposal.affectedField !== "string" ||
+      !proposal.payload ||
+      typeof proposal.payload !== "object"
+    ) {
+      skipped.push({ proposal, reason: "malformed proposal: missing type, affectedField, or payload" });
+      continue;
+    }
+
+    // explain.object proposals are informational — no config write needed
+    if (proposal.type === "explain.object") {
+      applied.push(buildApplyReceipt(proposal, appliedAt, reviewedBy, sessionId));
+      continue;
+    }
+
+    const validation = validateProposalForApply(proposal, workingConfig);
+    if (!validation.ok) {
+      skipped.push({ proposal, reason: validation.error || "failed validation" });
+      continue;
+    }
+
+    try {
+      workingConfig = applyProposalToConfig(workingConfig, proposal);
+      applied.push(buildApplyReceipt(proposal, appliedAt, reviewedBy, sessionId));
+    } catch (err) {
+      skipped.push({ proposal, reason: err?.message || "apply threw" });
+    }
+  }
+
+  // Patch — collect every affected field from accepted proposals AND
+  // append the thread row update (so the user-visible Helper Threads object
+  // refreshes in the same atomic write as the proposed mutations).
+  const mutatingApplied = applied.filter((r) => r.type !== "explain.object");
+
+  // Upsert the thread row so audit history reflects this apply turn even
+  // when nothing mutated (all skipped / explain-only) and even when the
+  // CLI flow applies a proposals.json that carries a fresh threadId
+  // (no prior in-session query). Both query and apply land on the same
+  // governed object so the user sees one row per conversation.
+  //
+  // Apply outcomes are also appended to the row's messages[] as a
+  // `system` turn so the conversation captures both proposals and their
+  // governed apply receipts. The conversation tail stays under the cap
+  // (~40 entries) via upsertHelperThreadRow's slicing.
+  if (threadId) {
+    try {
+      const existingRows = (workingConfig?.dataModel?.objects || []).find((o) => o?.id === "helper-threads")?.rows || [];
+      const existingRow = existingRows.find((r) => r?.id === threadId) || {};
+      const firstProposal = body.proposals?.[0];
+      const seedTitle = existingRow.title
+        || (firstProposal?.rationale ? String(firstProposal.rationale).slice(0, 72) : "Helper thread");
+
+      // Build a short, plain-language system message describing the apply
+      // outcome. This is what the user sees in the conversation panel
+      // after their accepted proposals are written.
+      const applyLines = [];
+      if (applied.length > 0) {
+        const summary = applied
+          .map((a) => `${a.type}${a.affectedField ? ` → ${a.affectedField}` : ""}`)
+          .join(", ");
+        applyLines.push(`Applied ${applied.length} change${applied.length === 1 ? "" : "s"}: ${summary}.`);
+      }
+      if (skipped.length > 0) {
+        const skipSummary = skipped
+          .slice(0, 4)
+          .map((s) => `${s.proposal?.type || "unknown"} (${s.reason || "no reason"})`)
+          .join("; ");
+        applyLines.push(`Skipped ${skipped.length}: ${skipSummary}${skipped.length > 4 ? "; …" : ""}.`);
+      }
+      if (applyLines.length === 0) {
+        applyLines.push("Apply completed with no changes.");
+      }
+      const applySystemMessage = {
+        role: "system",
+        content: applyLines.join(" "),
+        ts: appliedAt,
+        kind: "apply-receipt",
+        appliedCount: applied.length,
+        skippedCount: skipped.length,
+      };
+      const priorMessages = Array.isArray(existingRow.messages) ? existingRow.messages : [];
+      // Effectively unlimited cap — keeps the full multi-turn dashboard
+      // construction history. The user explicitly removed the 40-turn
+      // arbitrary limit so the helper can do complex multi-step real-data
+      // builds without losing context.
+      const nextMessages = [...priorMessages, applySystemMessage].slice(-400);
+
+      // Intent fallback — affectedField is in the PATCH-allowlist vocabulary
+      // (dashboards | widgetTypes | canvas | dataModel) and is NOT a member
+      // of the 7-intent vocabulary. Never assign it as a thread intent.
+      // Walk the proposal type back to its intent only when it's safe.
+      const TYPE_TO_INTENT_HINT = {
+        "dashboard.create": "build_dashboard",
+        "dashboard.update": "edit_view",
+        "widgetType.bind": "create_widget",
+        "canvas.widget.add": "create_widget",
+        "canvas.tab.create": "edit_view",
+        "dataModel.object.create": "create_object",
+        "dataModel.object.update": "edit_view",
+        "dataModel.row.add": "create_object",
+        "repair.binding": "repair",
+        "explain.object": "explain",
+      };
+      const proposalIntent = firstProposal?.type ? TYPE_TO_INTENT_HINT[firstProposal.type] : null;
+      const safeIntent = existingRow.intent || proposalIntent || "explain";
+      workingConfig = upsertHelperThreadRow(workingConfig, {
+        id: threadId,
+        title: seedTitle,
+        intent: safeIntent,
+        prompt: existingRow.prompt || "",
+        summary: existingRow.summary || "",
+        proposals: existingRow.proposals || body.proposals || [],
+        warnings: existingRow.warnings || [],
+        receipts: existingRow.receipts || null,
+        model: existingRow.model || "external-apply",
+        applied: (existingRow.applied || 0) + applied.length,
+        skipped: (existingRow.skipped || 0) + skipped.length,
+        // Persist the full proposal payload alongside the receipt so the
+        // sidecar can rehydrate ToolCallCard rows (icon + title + JSON
+        // metadata + Open link) on page refresh — without this the
+        // chevron-accordion would show nothing useful after a reload.
+        lastApplied: applied.map((a, idx) => ({
+          type: a.type,
+          affectedField: a.affectedField,
+          rationale: a.rationale,
+          confidence: a.confidence,
+          payload: body.proposals?.[idx]?.payload ?? null,
+        })),
+        lastSkipped: skipped.map((s) => ({
+          type: s.proposal?.type,
+          affectedField: s.proposal?.affectedField,
+          reason: s.reason,
+          payload: s.proposal?.payload ?? null,
+        })),
+        turnCount: (existingRow.turnCount || 0) + 1,
+        messages: nextMessages,
+        updatedAt: appliedAt,
+      });
+    } catch {
+      // Non-fatal — thread row update failures do not block the apply response.
+    }
+  }
+
+  // Build PATCH from affected fields. If the thread row was updated above,
+  // dataModel will already reflect it. Otherwise only mutating proposals
+  // contribute fields.
+  const threadTouched = threadId && mutatingApplied.every((r) => r.affectedField !== "dataModel");
+  if (mutatingApplied.length > 0 || threadTouched) {
+    const patchFields = new Set(mutatingApplied.map((r) => r.affectedField));
+    if (threadId) patchFields.add("dataModel");
+    const patch = {};
+    for (const field of patchFields) {
+      patch[field] = workingConfig[field];
+    }
+
+    try {
+      const next = await writeWorkspaceConfig(patch);
+      workingConfig = next;
+    } catch (err) {
+      if (err.code === "WORKSPACE_PERSISTENCE_READ_ONLY") {
+        return NextResponse.json(
+          {
+            ok: false,
+            error: "workspace config is read-only in this runtime",
+            reason: err.message,
+            guidance:
+              err.guidance ||
+              "Edit growthub.config.json locally, or set WORKSPACE_CONFIG_ALLOW_FS_WRITE=true on a writable runtime.",
+          },
+          { status: 409 }
+        );
+      }
+      if (err.code === "INVALID_WORKSPACE_CONFIG") {
+        return NextResponse.json({ ok: false, error: err.message, details: err.details }, { status: 400 });
+      }
+      return NextResponse.json(
+        { ok: false, error: err?.message || "failed to write workspace config" },
+        { status: 500 }
+      );
+    }
+  }
+
+  // Persist receipts to source-records for fine-tune loop seeding
+  const persistence = describePersistenceMode();
+  if (persistence.canSave && applied.length > 0) {
+    try {
+      const existing = await readWorkspaceSourceRecords(HELPER_APPLY_SOURCE_KEY);
+      const priorRecords = Array.isArray(existing?.records) ? existing.records : [];
+      const newRecords = applied.map((receipt) => ({
+        ...receipt,
+        sessionId: sessionId || null,
+        reviewedBy,
+      }));
+      await writeWorkspaceSourceRecords(
+        HELPER_APPLY_SOURCE_KEY,
+        [...priorRecords, ...newRecords].slice(-200),
+        { integrationId: HELPER_APPLY_SOURCE_KEY, fetchedAt: appliedAt }
+      );
+    } catch {
+      // Non-fatal
+    }
+  }
+
+  // If we updated a thread row, return the new conversation tail so the
+  // sidecar can render the apply-receipt system message in-place without
+  // a separate fetch.
+  let messagesAfterApply;
+  if (threadId) {
+    const ht = (workingConfig?.dataModel?.objects || []).find((o) => o?.id === "helper-threads");
+    const row = ht?.rows?.find((r) => r?.id === threadId);
+    if (row && Array.isArray(row.messages)) messagesAfterApply = row.messages;
+  }
+
+  return NextResponse.json({
+    ok: true,
+    threadId,
+    applied,
+    skipped,
+    workspaceConfig: workingConfig,
+    messages: messagesAfterApply,
+  });
+}
+
+export { POST };

package/assets/worker-kits/growthub-custom-workspace-starter-v1/apps/workspace/app/api/workspace/helper/query/route.js

@@ -0,0 +1,372 @@
+/**
+ * POST /api/workspace/helper/query
+ *
+ * Workspace-native helper endpoint. Accepts a natural-language business brief
+ * and returns structured proposals valid against the workspace PATCH allowlist.
+ *
+ * This route is propose-only. No workspace config is mutated here. Accepted
+ * proposals are applied through POST /api/workspace/helper/apply, which
+ * validates each proposal against validateWorkspaceConfig before writing.
+ *
+ * Execution model:
+ *   1. Read and sanitize the live growthub.config.json (or accept a snapshot).
+ *   2. Build a workspace-grammar-injected system prompt via workspace-helper.js.
+ *   3. Dispatch through the local-intelligence sandbox adapter.
+ *   4. Parse the growthub-local-model-sandbox-v1 envelope.
+ *   5. Validate proposals, write a run record to source-records, return response.
+ *
+ * Request body (WorkspaceHelperQuery):
+ *   {
+ *     intent: "build_dashboard" | "create_widget" | "register_api" |
+ *             "create_object" | "edit_view" | "repair" | "explain",
+ *     workspaceSnapshot?: WorkspaceHelperSnapshot,  // optional — server reads live config if omitted
+ *     userPrompt: string,
+ *     mode?: "propose",
+ *     model?: string,
+ *     adapterMode?: string,
+ *     localEndpoint?: string,
+ *   }
+ *
+ * Response (WorkspaceHelperResponse):
+ *   {
+ *     ok: boolean,
+ *     summary: string,
+ *     proposals: WorkspaceHelperProposal[],
+ *     warnings: string[],
+ *     receipts: WorkspaceHelperReceipt,
+ *     error?: string,
+ *   }
+ */
+
+import { NextResponse } from "next/server";
+import {
+  readWorkspaceConfig,
+  writeWorkspaceConfig,
+  readWorkspaceSourceRecords,
+  writeWorkspaceSourceRecords,
+  describePersistenceMode,
+} from "@/lib/workspace-config";
+import {
+  sanitizeWorkspaceSnapshot,
+  buildChatMessages,
+  inferIntentFromPrompt,
+  parseHelperEnvelope,
+  validateProposals,
+} from "@/lib/workspace-helper";
+import {
+  ensureSandboxAdaptersLoaded,
+  getSandboxAdapter,
+} from "@/lib/adapters/sandboxes";
+import {
+  upsertHelperThreadRow,
+  nextThreadId,
+} from "@/lib/workspace-helper-apply";
+
+const VALID_INTENTS = [
+  "build_dashboard",
+  "create_widget",
+  "register_api",
+  "create_object",
+  "edit_view",
+  "repair",
+  "explain",
+];
+
+const HELPER_SOURCE_KEY_PREFIX = "helper";
+
+function helperSourceId(intent, runId) {
+  return `${HELPER_SOURCE_KEY_PREFIX}:${intent}:${runId}`;
+}
+
+async function POST(request) {
+  let body;
+  try {
+    body = await request.json();
+  } catch {
+    return NextResponse.json({ ok: false, error: "invalid JSON body" }, { status: 400 });
+  }
+
+  const intent = typeof body?.intent === "string" ? body.intent.trim() : "";
+  if (!intent || !VALID_INTENTS.includes(intent)) {
+    return NextResponse.json({
+      ok: false,
+      error: `intent must be one of: ${VALID_INTENTS.join(", ")}`,
+      proposals: [],
+      warnings: [],
+    });
+  }
+
+  const userPrompt = typeof body?.userPrompt === "string" ? body.userPrompt.trim() : "";
+  if (!userPrompt) {
+    return NextResponse.json({ ok: false, error: "userPrompt is required", proposals: [], warnings: [] });
+  }
+
+  const modelOverride = typeof body?.model === "string" ? body.model.trim() : "";
+  const adapterModeOverride = typeof body?.adapterMode === "string" ? body.adapterMode.trim() : "";
+  const localEndpointOverride = typeof body?.localEndpoint === "string" ? body.localEndpoint.trim() : "";
+
+  // Always sanitize the snapshot — even when supplied by the client — so
+  // envRefs values, credentials, and row data can never travel into the
+  // inference prompt regardless of how a caller frames the request.
+  let snapshot;
+  let liveConfigForThread = null;
+  if (body?.workspaceSnapshot && typeof body.workspaceSnapshot === "object") {
+    snapshot = sanitizeWorkspaceSnapshot(body.workspaceSnapshot);
+  } else {
+    const liveConfig = await readWorkspaceConfig();
+    snapshot = sanitizeWorkspaceSnapshot(liveConfig);
+    liveConfigForThread = liveConfig;
+  }
+
+  // Thread continuity — pull prior messages from the governed helper-threads
+  // row when the caller supplied a threadId so the chat completion gets the
+  // full conversation context.
+  const incomingThreadId = typeof body?.threadId === "string" ? body.threadId.trim() : "";
+  let priorMessages = [];
+  let priorThreadIntent = null;
+  if (incomingThreadId) {
+    try {
+      if (!liveConfigForThread) liveConfigForThread = await readWorkspaceConfig();
+      const ht = (liveConfigForThread?.dataModel?.objects || []).find((o) => o?.id === "helper-threads");
+      const row = ht?.rows?.find((r) => r?.id === incomingThreadId);
+      if (row) {
+        priorMessages = Array.isArray(row.messages) ? row.messages : [];
+        priorThreadIntent = typeof row.intent === "string" ? row.intent : null;
+      }
+    } catch {
+      // Non-fatal — fall through with no prior context.
+    }
+  }
+
+  // L3 heuristic intent routing.
+  //
+  // If the caller is continuing a thread, the original intent is locked
+  // for the rest of the thread (the UI surfaces it as the active mode).
+  // For a brand-new thread we only override the caller's chosen intent
+  // when the prompt produces a strong, unambiguous signal that conflicts.
+  let resolvedIntent = priorThreadIntent || intent;
+  let intentInference = null;
+  if (!priorThreadIntent) {
+    intentInference = inferIntentFromPrompt(userPrompt, intent);
+    if (
+      intentInference.confidence >= 2 &&
+      intentInference.intent !== intent &&
+      // Only override the safest defaults — never blow away a deliberate pick.
+      (intent === "create_object" || intent === "explain")
+    ) {
+      resolvedIntent = intentInference.intent;
+    }
+  }
+
+  const chatMessages = buildChatMessages({
+    snapshot,
+    intent: resolvedIntent,
+    priorMessages,
+    newUserPrompt: userPrompt,
+  });
+  // Keep the userIntent fallback populated for adapter compatibility — the
+  // adapter prefers `messages` when present and only reads `userIntent`
+  // when `messages` is empty.
+  const userIntent = userPrompt;
+
+  await ensureSandboxAdaptersLoaded();
+  const adapter = getSandboxAdapter("local-intelligence");
+  if (!adapter) {
+    return NextResponse.json(
+      {
+        ok: false,
+        error: "local-intelligence adapter not registered. Ensure sandbox adapters are loaded.",
+      },
+      { status: 503 }
+    );
+  }
+
+  const runId = `helper_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+  const ranAt = new Date().toISOString();
+
+  let adapterResult;
+  try {
+    adapterResult = await adapter.run({
+      runId,
+      name: `workspace-helper-${resolvedIntent}`,
+      runtime: "node",
+      agentHost: "",
+      command: userIntent,
+      timeoutMs: 90000,
+      networkAllow: true,
+      allowList: [],
+      env: {},
+      envRefSlugs: [],
+      envRefsMissing: [],
+      workdir: "/tmp",
+      ranAt,
+      intelligenceSandbox: {
+        // Structured multi-turn message array — the adapter passes this
+        // straight through to the chat completions endpoint so the model
+        // sees the full conversation history with stable system prefix
+        // (KV-cache friendly).
+        messages: chatMessages,
+        userIntent,
+        localModel: modelOverride || process.env.NATIVE_INTELLIGENCE_LOCAL_MODEL || process.env.OLLAMA_MODEL || "gemma3:4b",
+        localEndpoint: localEndpointOverride || "",
+        intelligenceAdapterMode: adapterModeOverride || "ollama",
+      },
+    });
+  } catch (err) {
+    return NextResponse.json(
+      {
+        ok: false,
+        error: err?.message || "adapter threw during helper query",
+      },
+      { status: 500 }
+    );
+  }
+
+  if (!adapterResult.ok) {
+    return NextResponse.json(
+      {
+        ok: false,
+        error: adapterResult.error || "local-intelligence adapter returned error",
+        receipts: {
+          model: "unknown",
+          adapterMode: adapterModeOverride || "ollama",
+          endpoint: "",
+          confidence: 0,
+          latencyMs: adapterResult.durationMs || 0,
+          ranAt,
+          runId,
+        },
+      },
+      { status: 502 }
+    );
+  }
+
+  const parsed = parseHelperEnvelope(adapterResult.stdout, intent);
+  const { valid: validProposals, errors: validationErrors } = validateProposals(parsed.proposals);
+
+  const warnings = [...parsed.warnings];
+  if (validationErrors.length > 0) {
+    warnings.push(...validationErrors);
+  }
+
+  const receipts = {
+    model: parsed.model,
+    adapterMode: parsed.adapterMode,
+    endpoint: parsed.endpoint,
+    confidence: parsed.confidence,
+    latencyMs: parsed.latencyMs,
+    ranAt,
+    runId,
+  };
+
+  // Thread row — every governed conversation turn lands here so the user
+  // can reopen it from /data-model → Helper Threads. Either continue an
+  // existing thread (when the caller supplies threadId) or start a new one.
+  const threadId = incomingThreadId || nextThreadId();
+  const turnCount = 1;
+
+  // Build the new messages tail — one user turn (raw prompt) and one
+  // assistant turn (the JSON envelope we just returned). This is the
+  // conversation history that gets replayed on the next turn.
+  const nowIso = new Date().toISOString();
+  const assistantEnvelope = JSON.stringify({
+    summary: parsed.summary,
+    proposals: validProposals,
+    warnings,
+  });
+  const newTurn = [
+    { role: "user", content: userPrompt, ts: nowIso },
+    { role: "assistant", content: assistantEnvelope, ts: nowIso, summary: parsed.summary, proposals: validProposals, warnings },
+  ];
+  const nextMessages = [...priorMessages, ...newTurn].slice(-40);
+
+  const response = {
+    ok: true,
+    threadId,
+    intent: resolvedIntent,
+    intentInference,
+    summary: parsed.summary,
+    proposals: validProposals,
+    warnings,
+    receipts,
+    messages: nextMessages,
+  };
+
+  const persistence = describePersistenceMode();
+  if (persistence.canSave) {
+    // Audit-trail (source-records) — preserved exactly as before for the
+    // distillation pipeline.
+    try {
+      const sourceId = helperSourceId(resolvedIntent, runId);
+      const existing = await readWorkspaceSourceRecords(sourceId);
+      const priorRecords = Array.isArray(existing?.records) ? existing.records : [];
+      const record = {
+        runId,
+        ranAt,
+        intent: resolvedIntent,
+        intentRequested: intent,
+        userPrompt,
+        summary: parsed.summary,
+        proposalCount: validProposals.length,
+        warningCount: warnings.length,
+        model: parsed.model,
+        adapterMode: parsed.adapterMode,
+        confidence: parsed.confidence,
+        latencyMs: parsed.latencyMs,
+        threadId,
+        turnIndex: priorMessages.filter((m) => m?.role === "user").length + 1,
+      };
+      await writeWorkspaceSourceRecords(sourceId, [...priorRecords, record].slice(-50), {
+        integrationId: sourceId,
+        fetchedAt: ranAt,
+      });
+    } catch {
+      // Non-fatal — source record write failure does not block the response
+    }
+
+    // Governed thread row — visible to the user as a Data Model row with a
+    // "Reopen" hyperlink that re-hydrates the sidecar. The row carries the
+    // full multi-turn message history; the assistant's latest turn is also
+    // surfaced as `summary` / `proposals` / `receipts` on the row for
+    // quick triage from the Data Model surface.
+    try {
+      const liveConfig = liveConfigForThread || (await readWorkspaceConfig());
+      const existingRows = (liveConfig?.dataModel?.objects || []).find((o) => o?.id === "helper-threads")?.rows || [];
+      const existingRow = existingRows.find((r) => r?.id === threadId) || {};
+      const merged = upsertHelperThreadRow(liveConfig, {
+        id: threadId,
+        title: existingRow.title || truncateRowTitle(userPrompt),
+        intent: resolvedIntent,
+        prompt: existingRow.prompt || userPrompt,
+        summary: parsed.summary,
+        proposals: validProposals,
+        warnings,
+        receipts,
+        model: parsed.model || "unknown",
+        applied: existingRow.applied || 0,
+        skipped: existingRow.skipped || 0,
+        turnCount: (existingRow.turnCount || 0) + turnCount,
+        messages: nextMessages,
+        updatedAt: ranAt,
+      });
+      await writeWorkspaceConfig({ dataModel: merged.dataModel });
+    } catch (err) {
+      // Non-fatal — the helper response is still returned even if the row
+      // write fails (e.g. read-only runtime). The audit trail above is
+      // unaffected.
+      if (err && err.code !== "WORKSPACE_PERSISTENCE_READ_ONLY") {
+        // swallow but do not propagate; users still receive the proposals
+      }
+    }
+  }
+
+  return NextResponse.json(response);
+}
+
+function truncateRowTitle(prompt, max = 72) {
+  const text = String(prompt || "").replace(/\s+/g, " ").trim();
+  if (text.length <= max) return text;
+  return `${text.slice(0, max - 1).trimEnd()}…`;
+}
+
+export { POST };