@burdenoff/microfe-bigconsole 2026.1006.1 → 2026.1007.10

package/dist/bigconsole/assistant/assistantApi.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"assistantApi.js","names":[],"sources":["../../../src/bigconsole/assistant/assistantApi.ts"],"sourcesContent":["/**\n * AI Assistant API service for BigConsole.\n *\n * All requests go through the wspace-public-gateway (GraphQL Federation):\n *   Frontend → wspace-public-gateway → wspace-sandbox-svc → ai-assistant (sandbox)\n *\n * This is a faithful port of microfe-vibecontrols' `services/assistantApi.ts`,\n * adapted for BigConsole: the only product-specific difference is\n * `AI_ASSISTANT_PRODUCT=bigconsole` in the sandbox container env (drives the\n * agent's per-product docs fetch + system prompt).\n */\n\nimport { print, type DocumentNode, Kind, type OperationDefinitionNode } from 'graphql';\nimport { graphqlFetch } from '@burdenoff/fe-libs/shared/graphql';\n// Deep import: images.js has no dependencies, so this does not pull the shared\n// assistant barrel into the consumer's chunk. fe-libs owns the registry (ECR\n// since the AWS cutover), the image tags, the auth strategy and the mode\n// resolution; this file used to carry byte-for-byte copies of them.\nimport {\n  ASSISTANT_API_AUTH_STRATEGY,\n  getImageForMode as getSharedImageForMode,\n  getImageTagForMode as getSharedImageTagForMode,\n  resolveSandboxAssistantMode,\n} from '@burdenoff/fe-libs/shared/assistant/images';\nimport type { AssistantMode, AssistantRawMessage, AssistantRawSession, AssistantSandboxAuthContext } from './types';\nimport type { PageContext } from './pageContext';\nimport { BIGCONSOLE_PRODUCT } from './product';\nimport {\n  CreateSandboxDocument,\n  GetSandboxDocument,\n  GetReusableAssistantSandboxDocument,\n  GetActiveSandboxesDocument,\n  ProxySandboxRequestDocument,\n  ExtendSandboxTtlDocument,\n} from '../../generated/wspace-operations';\n\n// ── Product, runtime and image ─────────────────────────────────────\n\n/**\n * The product this transport stamps on every assistant sandbox it creates\n * (`metadata.assistantProduct`) — the same key the shared fe-libs assistant\n * stamps for HealthyBowl and VibeControls, and FluidGrids stamps for itself — and\n * the ONLY product whose sandboxes it will reuse (BOFF-7331).\n *\n * ★ The VALUE now comes from `./product`, which is the one place the id is\n * spelled. This constant keeps its name because the stamp, the env var and the\n * reuse predicate below all read it — but a second literal spelled the same way\n * is exactly how `AI_ASSISTANT_PRODUCT` and `metadata.assistantProduct` drift\n * apart, and `assistantSeamWiring.test.ts` now forbids one.\n */\nexport const ASSISTANT_PRODUCT = BIGCONSOLE_PRODUCT;\n\nexport function isProdRuntime(): boolean {\n  if (typeof window === 'undefined') {\n    return import.meta.env.VITE_DEPLOY_ENV === 'prod' || import.meta.env.VITE_APP_ENV === 'prod';\n  }\n  const host = window.location.hostname.toLowerCase();\n  return host === 'app.bigconsole.com';\n}\n\n/**\n * Image tag recorded on the sandbox. It is metadata only: the sandbox\n * cf-proxy's AiAssistant pin decides which image actually runs (plan decision\n * D9), so the tag is NOT used to pick a sandbox for reuse — see\n * `isReusableAssistantSandbox`.\n */\nexport function getImageTagForMode(mode: AssistantMode, isProd: boolean = isProdRuntime()): string {\n  return getSharedImageTagForMode(mode, isProd);\n}\n\n/**\n * `assistant` reuses the api-calls image (mode is selected at runtime via\n * AI_ASSISTANT_MODE). The registry is fe-libs' — the Azure registry this used to\n * hardcode was decommissioned on 2026-08-15 and is not in wspace-sandbox-svc's\n * default ALLOWED_IMAGE_REGISTRIES.\n */\nexport function getImageForMode(mode: AssistantMode, isProd: boolean = isProdRuntime()): string {\n  return getSharedImageForMode(mode, isProd);\n}\n\nfunction getResourcesForMode(mode: AssistantMode): {\n  cpuRequest: string;\n  cpuLimit: string;\n  memoryRequest: string;\n  memoryLimit: string;\n} {\n  switch (mode) {\n    case 'general':\n      return {\n        cpuRequest: '100m',\n        cpuLimit: '500m',\n        memoryRequest: '256Mi',\n        memoryLimit: '1Gi',\n      };\n    case 'vibe-plugins':\n    case 'assistant':\n    case 'api-calls':\n      return {\n        cpuRequest: '150m',\n        cpuLimit: '750m',\n        memoryRequest: '384Mi',\n        memoryLimit: '1536Mi',\n      };\n  }\n}\n\n// ── Types ───────────────────────────────────────────────────────────\n\ninterface ProxyResponse {\n  proxySandboxRequest: {\n    status: number;\n    body: Record<string, unknown>;\n  };\n}\n\nfunction getOperationName(document: DocumentNode): string | undefined {\n  const operation = document.definitions.find(\n    (definition): definition is OperationDefinitionNode => definition.kind === Kind.OPERATION_DEFINITION\n  );\n  return operation?.name?.value;\n}\n\nfunction buildAssistantRequestId(): string {\n  try {\n    return `bc-assistant-${crypto.randomUUID()}`;\n  } catch {\n    return `bc-assistant-${Date.now()}-${Math.random().toString(36).slice(2)}`;\n  }\n}\n\nfunction buildSandboxContextInput(\n  workspaceId: string,\n  authContext?: AssistantSandboxAuthContext\n): Record<string, unknown> {\n  return {\n    workspaceId,\n    ...(authContext?.organizationId\n      ? {\n          custom: {\n            organizationId: authContext.organizationId,\n          },\n        }\n      : {}),\n  };\n}\n\nasync function executeSandboxGraphQL<TData>(params: {\n  document: DocumentNode;\n  variables: Record<string, unknown>;\n  workspaceId: string;\n  authContext?: AssistantSandboxAuthContext;\n}): Promise<TData> {\n  // Retry transient failures (network drops, CORS preflight rejections,\n  // gateway 524s, etc.) with bounded exponential backoff. The browser\n  // surfaces these as \"Failed to fetch\" via fetch() throwing TypeError\n  // before the runtime can inspect the response — so the only signal we\n  // have is the throw itself. Bounded retries mask the gateway's\n  // occasional CORS preflight races without papering over hard failures\n  // (unauth, validation) which the inner block below raises as typed\n  // errors that bubble up to the assistant's existing `isRecoverable`\n  // retry path.\n  const maxRetries = 3;\n  let lastError: unknown;\n  for (let attempt = 0; attempt < maxRetries; attempt++) {\n    try {\n      return await executeSandboxGraphQLOnce<TData>(params);\n    } catch (error) {\n      lastError = error;\n      const message = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();\n      // Only retry on transient network-level failures. Let domain errors\n      // (auth, validation, server 5xx with a body) bubble immediately so\n      // the outer `isRecoverable` logic can decide whether to drop the\n      // sandbox and try a clean runtime instead.\n      const isTransient =\n        message.includes('failed to fetch') ||\n        message.includes('networkerror') ||\n        message.includes('network request failed') ||\n        message.includes('aborted') ||\n        message.includes('load failed');\n      if (!isTransient || attempt === maxRetries - 1) {\n        throw error;\n      }\n      // 250ms, 500ms, 1000ms — bounded so we don't blow the 90s gateway\n      // execution timeout on a stuck connection.\n      const backoff = 250 * Math.pow(2, attempt);\n      console.warn('[BigConsole-Assistant] executeSandboxGraphQL transient failure, retrying', {\n        attempt: attempt + 1,\n        maxRetries,\n        backoffMs: backoff,\n        error: error instanceof Error ? error.message : String(error),\n      });\n      await new Promise((resolve) => setTimeout(resolve, backoff));\n    }\n  }\n  // Unreachable — the loop either returns or throws.\n  throw lastError;\n}\n\nasync function executeSandboxGraphQLOnce<TData>(params: {\n  document: DocumentNode;\n  variables: Record<string, unknown>;\n  workspaceId: string;\n  authContext?: AssistantSandboxAuthContext;\n}): Promise<TData> {\n  const operationName = getOperationName(params.document);\n  const result = await graphqlFetch<TData>({\n    gateway: 'workspace',\n    query: print(params.document),\n    variables: params.variables,\n    operationName,\n    authToken: params.authContext?.accessToken ?? undefined,\n    // Critical: always opt into workspace-token auto-minting here instead of\n    // passing through a cached token string from the shell. If we pass a stale\n    // string, graphqlFetch validates it for the current workspace/project and\n    // nulls it out, but it WILL NOT mint a replacement unless the caller used\n    // `workspaceToken: true`. That exact behavior caused proxySandboxRequest\n    // calls to fail with `Dual-token authentication failed` even though the\n    // browser had a login session and the workspace context was known.\n    workspaceToken: true,\n    workspaceId: params.workspaceId,\n    organizationId: params.authContext?.organizationId ?? true,\n    suppressGlobalErrorEvent: true,\n    // Give assistant calls a unique queue key so they never batch with the\n    // dashboard's burst of background widget requests. This avoids mixing\n    // long-lived assistant polls with unrelated queries in the shared\n    // graphqlFetch batching queue.\n    extraHeaders: {\n      'x-request-id': buildAssistantRequestId(),\n    },\n  });\n\n  if (!result) {\n    throw new Error('Sandbox GraphQL returned empty response');\n  }\n\n  if (result.errors?.length) {\n    console.error('[BigConsole-Assistant] executeSandboxGraphQL errors', {\n      operationName,\n      errors: result.errors,\n    });\n    throw new Error(result.errors.map((error: { message: string }) => error.message).join(', '));\n  }\n\n  if (!result.data) {\n    throw new Error('Sandbox GraphQL returned no data');\n  }\n\n  return result.data;\n}\n\n// ── Find existing sandbox for a mode ───────────────────────────────\n\nexport interface ActiveAssistantSandbox {\n  id: string;\n  name: string;\n  status: string;\n  metadata: Record<string, unknown> | null;\n  template: string;\n  createdBy: string;\n}\n\n/**\n * May this active sandbox be reused for `mode`?\n *\n * Every product's assistant runs as the same user in the same workspace, so\n * `getActiveSandboxes` returns HealthyBowl's, VibeControls' and FluidGrids'\n * assistant sandboxes too (BOFF-7331). Adopting one of those runs the wrong\n * product guide, and HB/VC `api-calls` sandboxes have CONFIRM_WRITES on, which\n * the legacy widget BigConsole mounts has no Approve UI for. So:\n *   - the sandbox must be stamped `assistantProduct: 'bigconsole'`. Unstamped\n *     sandboxes — every BigConsole sandbox created before this change — are NOT\n *     reused: their product cannot be proven. They lapse on their 600s TTL.\n *   - a sandbox recording `confirmWrites: true` is never reused, whoever\n *     stamped it: it waits for approvals this widget cannot give.\n *   - the image tag is NOT compared (D9). It never decided what runs.\n *   - ownership FAILS CLOSED: with no `userId` nothing is reusable. fe-libs'\n *     AuthTokenProvider starts with `userId` null, and a super_admin caller is\n *     handed every sandbox in the workspace, so skipping the owner check when\n *     the id is unknown would adopt another user's BigConsole sandbox. The\n *     caller creates a fresh sandbox instead.\n */\nexport function isReusableAssistantSandbox(\n  sandbox: ActiveAssistantSandbox,\n  mode: AssistantMode,\n  userId?: string | null\n): boolean {\n  return (\n    (sandbox.status === 'RUNNING' || sandbox.status === 'PROVISIONING' || sandbox.status === 'PENDING') &&\n    sandbox.template === 'AI_BUILDER' &&\n    resolveSandboxAssistantMode(sandbox) === mode &&\n    !!userId &&\n    sandbox.createdBy === userId &&\n    sandbox.metadata?.authStrategy === ASSISTANT_API_AUTH_STRATEGY &&\n    sandbox.metadata?.assistantProduct === ASSISTANT_PRODUCT &&\n    sandbox.metadata?.confirmWrites !== true\n  );\n}\n\n/**\n * May a sandbox id cached from an earlier page lifecycle (sessionStorage) be\n * adopted for `mode`?\n *\n * A cached id carries no proof of what it points at: a tab that adopted another\n * product's, an unstamped or another user's sandbox under an older build would\n * otherwise keep driving it. So the sandbox is fetched and held to exactly the\n * same predicate as a freshly listed one. A sandbox that no longer exists is not\n * reusable. Transport errors propagate; the caller treats them as \"not reusable\".\n */\nexport async function isCachedAssistantSandboxReusable(\n  sandboxId: string,\n  workspaceId: string,\n  mode: AssistantMode,\n  authContext?: AssistantSandboxAuthContext\n): Promise<boolean> {\n  // Checked before the call so a caller with no identity yet costs no round-trip.\n  if (!authContext?.userId) return false;\n  const data = await executeSandboxGraphQL<{ getSandbox: ActiveAssistantSandbox | null }>({\n    document: GetReusableAssistantSandboxDocument,\n    variables: { id: sandboxId, context: buildSandboxContextInput(workspaceId, authContext) },\n    workspaceId,\n    authContext,\n  });\n  const sandbox = data.getSandbox;\n  return !!sandbox && sandbox.id === sandboxId && isReusableAssistantSandbox(sandbox, mode, authContext.userId);\n}\n\nexport async function findExistingSandbox(\n  workspaceId: string,\n  mode: AssistantMode,\n  authContext?: AssistantSandboxAuthContext\n): Promise<string | null> {\n  const data = await executeSandboxGraphQL<{\n    getActiveSandboxes: ActiveAssistantSandbox[];\n  }>({\n    document: GetActiveSandboxesDocument,\n    variables: { context: buildSandboxContextInput(workspaceId, authContext) },\n    workspaceId,\n    authContext,\n  });\n  const sandboxes = data.getActiveSandboxes ?? [];\n\n  return sandboxes.find((s) => isReusableAssistantSandbox(s, mode, authContext?.userId))?.id ?? null;\n}\n\n// ── Sandbox lifecycle ──────────────────────────────────────────────\n\nexport async function createAssistantSandbox(\n  mode: AssistantMode,\n  workspaceId: string,\n  authContext?: AssistantSandboxAuthContext\n): Promise<string> {\n  const resources = getResourcesForMode(mode);\n  const env = [\n    { name: 'AI_ASSISTANT_MODE', value: mode },\n    { name: 'HOSTNAME', value: '0.0.0.0' },\n    { name: 'WORKSPACE_ID', value: workspaceId },\n    // Product the user is in — drives the agent's dynamic per-product docs fetch\n    // (the docs repo is `<product>-docs`) and personalizes its system prompt.\n    // This package is the BigConsole MFE, so the product is bigconsole.\n    { name: 'AI_ASSISTANT_PRODUCT', value: ASSISTANT_PRODUCT },\n  ];\n  // Resolved once so the image and its recorded tag can never disagree.\n  const isProd = isProdRuntime();\n\n  const data = await executeSandboxGraphQL<{ createSandbox: { id: string } }>({\n    document: CreateSandboxDocument,\n    variables: {\n      input: {\n        name: `ai-assistant-${mode}-${Date.now()}`,\n        description: `AI Assistant sandbox (${mode} mode)`,\n        template: 'AI_BUILDER',\n        mode: 'DEPLOYMENT',\n        containers: [\n          {\n            name: 'ai-assistant',\n            image: getImageForMode(mode, isProd),\n            // The agent (start-assistant.sh) binds :8080; the sandbox svc proxies\n            // to this declared containerPort, so it MUST be 8080.\n            ports: [{ containerPort: 8080, name: 'http' }],\n            env,\n          },\n        ],\n        resources: {\n          cpuRequest: resources.cpuRequest,\n          cpuLimit: resources.cpuLimit,\n          memoryRequest: resources.memoryRequest,\n          memoryLimit: resources.memoryLimit,\n        },\n        ttlSeconds: 600,\n        metadata: {\n          assistantMode: mode,\n          // Product stamp: the reuse filter only adopts sandboxes carrying it.\n          assistantProduct: ASSISTANT_PRODUCT,\n          assistantOwnerUserId: authContext?.userId ?? null,\n          assistantOrganizationId: authContext?.organizationId ?? null,\n          authStrategy: ASSISTANT_API_AUTH_STRATEGY,\n          imageTag: getImageTagForMode(mode, isProd),\n          // Recorded explicitly (as fe-libs does): the legacy widget has no\n          // Approve UI, so these sandboxes never run with\n          // AI_ASSISTANT_CONFIRM_WRITES.\n          confirmWrites: false,\n        },\n        context: buildSandboxContextInput(workspaceId, authContext),\n      },\n    },\n    workspaceId,\n    authContext,\n  });\n\n  if (!data?.createSandbox?.id) {\n    throw new Error('createSandbox returned empty response');\n  }\n  return data.createSandbox.id;\n}\n\nexport async function waitForSandboxReady(\n  sandboxId: string,\n  workspaceId: string,\n  authContext?: AssistantSandboxAuthContext,\n  maxWaitMs = 300_000\n): Promise<void> {\n  const start = Date.now();\n  while (Date.now() - start < maxWaitMs) {\n    const data = await executeSandboxGraphQL<{\n      getSandbox: { status?: string; errorMessage?: string } | null;\n    }>({\n      document: GetSandboxDocument,\n      variables: { id: sandboxId, context: buildSandboxContextInput(workspaceId, authContext) },\n      workspaceId,\n      authContext,\n    });\n    const status = data?.getSandbox?.status;\n    const errorMessage = data?.getSandbox?.errorMessage as string | undefined;\n    if (status === 'RUNNING') return;\n    if (status === 'FAILED' || status === 'STOPPED' || status === 'EXPIRED') {\n      throw new Error(\n        errorMessage ? `Sandbox ${status.toLowerCase()}: ${errorMessage}` : `Sandbox ${status.toLowerCase()}`\n      );\n    }\n    await new Promise((r) => setTimeout(r, 2000));\n  }\n  throw new Error('Sandbox startup timed out');\n}\n\n// ── Proxy calls to ai-assistant (via gateway → sandbox-svc) ───────\n\nasync function proxyToSandbox(\n  sandboxId: string,\n  workspaceId: string,\n  path: string,\n  method: string,\n  body?: unknown,\n  authContext?: AssistantSandboxAuthContext\n): Promise<Record<string, unknown>> {\n  console.log('[BigConsole-Assistant] proxyToSandbox REQUEST', {\n    sandboxId,\n    workspaceId,\n    path,\n    method,\n    hasBody: !!body,\n  });\n  const result = await executeSandboxGraphQL<ProxyResponse>({\n    document: ProxySandboxRequestDocument,\n    variables: {\n      input: {\n        sandboxId,\n        path,\n        method,\n        body,\n        context: buildSandboxContextInput(workspaceId, authContext),\n      },\n    },\n    workspaceId,\n    authContext,\n  });\n\n  const proxyResult = result.proxySandboxRequest;\n  console.log('[BigConsole-Assistant] proxyToSandbox RESPONSE', { sandboxId, path, status: proxyResult?.status });\n  if (!proxyResult || proxyResult.status >= 400) {\n    const errBody = proxyResult?.body as Record<string, unknown> | undefined;\n    console.error('[BigConsole-Assistant] proxyToSandbox ERROR', {\n      sandboxId,\n      path,\n      status: proxyResult?.status,\n      errBody,\n    });\n    throw new Error((errBody?.error as string) ?? `Proxy error: ${proxyResult?.status ?? 'unknown'}`);\n  }\n\n  return proxyResult.body;\n}\n\nexport async function waitForAssistantServiceReady(\n  sandboxId: string,\n  workspaceId: string,\n  mode: AssistantMode,\n  authContext?: AssistantSandboxAuthContext,\n  maxWaitMs = 90_000\n): Promise<void> {\n  const startedAt = Date.now();\n\n  while (Date.now() - startedAt < maxWaitMs) {\n    try {\n      // Use the documented assistant API contract itself as the readiness\n      // signal. The assistant image definitively supports POST /sessions,\n      // whereas /health is an implementation assumption and has proven to hang\n      // behind the Cloudflare sandbox proxy.\n      await proxyToSandbox(sandboxId, workspaceId, '/sessions', 'POST', { mode }, authContext);\n      return;\n    } catch (error) {\n      const message = error instanceof Error ? error.message : String(error);\n      if (!/proxy error: 502|proxy error: 503|proxy error: 404|service not available|timeout/i.test(message)) {\n        throw error;\n      }\n    }\n\n    await new Promise((resolve) => setTimeout(resolve, 2000));\n  }\n\n  throw new Error('Assistant service did not become ready before timeout');\n}\n\n// ── Session management ─────────────────────────────────────────────\n\nexport async function createAssistantSession(\n  sandboxId: string,\n  workspaceId: string,\n  mode: AssistantMode,\n  authContext?: AssistantSandboxAuthContext\n): Promise<{ sessionId: string }> {\n  const body = await proxyToSandbox(sandboxId, workspaceId, '/sessions', 'POST', { mode }, authContext);\n  const session = body.session as Record<string, unknown>;\n  return { sessionId: session.id as string };\n}\n\n/**\n * All conversations held by this sandbox, newest first.\n *\n * The sandbox is the source of truth for the transcript, so the History list is\n * built from it rather than from anything we cache client-side — what the user\n * can reopen is exactly what the agent still has.\n */\nexport async function listAssistantSessions(\n  sandboxId: string,\n  workspaceId: string,\n  authContext?: AssistantSandboxAuthContext\n): Promise<AssistantRawSession[]> {\n  const body = await proxyToSandbox(sandboxId, workspaceId, '/sessions', 'GET', undefined, authContext);\n  const sessions = body.sessions;\n  return Array.isArray(sessions) ? (sessions as AssistantRawSession[]) : [];\n}\n\nexport async function deleteAssistantSession(\n  sandboxId: string,\n  workspaceId: string,\n  sessionId: string,\n  authContext?: AssistantSandboxAuthContext\n): Promise<void> {\n  await proxyToSandbox(sandboxId, workspaceId, `/sessions/${sessionId}`, 'DELETE', undefined, authContext);\n}\n\n// ── Send prompt ────────────────────────────────────────────────────\n\nexport async function sendAssistantPromptAsync(\n  sandboxId: string,\n  workspaceId: string,\n  sessionId: string,\n  prompt: string,\n  mode: AssistantMode,\n  pageContext?: PageContext,\n  authContext?: AssistantSandboxAuthContext\n): Promise<void> {\n  const requestBody = {\n    mode,\n    prompt,\n    pageContext: pageContext ?? undefined,\n  };\n\n  await proxyToSandbox(sandboxId, workspaceId, `/sessions/${sessionId}/prompt-async`, 'POST', requestBody, authContext);\n}\n\nexport async function getAssistantMessages(\n  sandboxId: string,\n  workspaceId: string,\n  sessionId: string,\n  authContext?: AssistantSandboxAuthContext,\n  limit = 50\n): Promise<AssistantRawMessage[]> {\n  const body = await proxyToSandbox(\n    sandboxId,\n    workspaceId,\n    `/sessions/${sessionId}/messages?limit=${limit}`,\n    'GET',\n    undefined,\n    authContext\n  );\n\n  return (body.messages as AssistantRawMessage[] | undefined) ?? [];\n}\n\n// ── TTL extension (keep the sandbox warm across the turn) ──────────\n\nexport async function extendAssistantSandboxTTL(\n  sandboxId: string,\n  workspaceId: string,\n  additionalSeconds = 600,\n  authContext?: AssistantSandboxAuthContext\n): Promise<void> {\n  await executeSandboxGraphQL<{ extendSandboxTTL: { id: string } }>({\n    document: ExtendSandboxTtlDocument,\n    variables: {\n      id: sandboxId,\n      additionalSeconds,\n      context: buildSandboxContextInput(workspaceId, authContext),\n    },\n    workspaceId,\n    authContext,\n  });\n}\n"],"mappings":"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"}

package/dist/bigconsole/assistant/assistantProduct.d.ts

@@ -89,3 +89,4 @@ export type BigConsoleAssistantProduct = Required<Omit<AssistantProductProviderP
  * the preview controller, which the panel takes as `panelProps.preview`.
  */
 export declare const BIGCONSOLE_ASSISTANT_PRODUCT: BigConsoleAssistantProduct;
+//# sourceMappingURL=assistantProduct.d.ts.map

package/dist/bigconsole/assistant/assistantProduct.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assistantProduct.d.ts","sourceRoot":"","sources":["../../../src/bigconsole/assistant/assistantProduct.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,qDAAqD,CAAC;AACjG,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,4DAA4D,CAAC;AACvG,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,6CAA6C,CAAC;AAQjG;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,eAAe;;;CAGlB,CAAC;AAEX;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,aAAa,EAAE,SAAS,oBAAoB,EAoCxD,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,iBAAiB,EAAE,qBAmB/B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,MAAM,0BAA0B,GAAG,QAAQ,CAC/C,IAAI,CAAC,6BAA6B,EAAE,UAAU,GAAG,kBAAkB,GAAG,cAAc,CAAC,CACtF,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,4BAA4B,EAAE,0BA+B1C,CAAC"}

package/dist/bigconsole/assistant/assistantProduct.js

@@ -77,10 +77,13 @@ var o = {
 				}
 			}
 		],
-		records: i
+		records: i,
+		uiCatalogue: !0
 	},
 	reportTurnTimings: !0,
 	writeApproval: "proposal-v1"
 };
 //#endregion
 export { s as BIGCONSOLE_ASSISTANT_PRODUCT, o as STORAGE_FOLDERS };
+
+//# sourceMappingURL=assistantProduct.js.map

package/dist/bigconsole/assistant/assistantProduct.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"assistantProduct.js","names":[],"sources":["../../../src/bigconsole/assistant/assistantProduct.ts"],"sourcesContent":["/**\n * BigConsole's answers to the shared assistant's product seam, as one value.\n *\n * ★★ Every capability field on fe-libs' `AssistantProductProvider` is OPTIONAL,\n * and a missing one does not throw — it degrades SILENTLY. No `gatherPageContext`\n * sends every turn with no page context; no `buildPrompt` drops both the\n * confirm-before-mutate guardrail and the language directive; no\n * `storageFolders` starts a second folder beside the one holding every saved\n * attachment.\n *\n * So the value is typed `Required<…>` over the provider's own props: forgetting\n * a field, or fe-libs ADDING one, is a type error in this file rather than a\n * quiet regression in production.\n */\nimport type { LocalUiCommandOptions } from '@burdenoff/fe-libs/shared/assistant/localUiCommands';\nimport type { AssistantEntityRoute } from '@burdenoff/fe-libs/shared/assistant/uiActions/entityRoutes';\nimport type { AssistantProductProviderProps } from '@burdenoff/fe-libs/shared/assistant/product';\n\nimport { buildPromptForMode } from './assistantPrompt';\nimport { BIGCONSOLE_RECORD_ADAPTERS } from './recordAdapters';\nimport { BIGCONSOLE_ASSISTANT_MODES } from './modes';\nimport { describeCurrentPage, gatherPageContext } from './pageContext';\nimport { BIGCONSOLE_PRODUCT } from './product';\n\n/**\n * Where this product's assistant files land in the workspace file library.\n *\n * ★★ Capitalised as a DISPLAY name while the product id is `bigconsole`, which\n * is exactly why fe-libs cannot derive it: its fallback is\n * `/${product}/AI Assistant/…` → `/bigconsole/AI Assistant/…`.\n *\n * These strings become load-bearing the moment anything is saved. A wrong value\n * does not fail loudly — it quietly starts a SECOND folder beside the first and\n * orphans everything in the original. Today nothing can be orphaned: BigConsole's\n * legacy transport extracts uploaded files into the prompt and saves nothing to\n * the library, so no `/BigConsole/AI Assistant/*` path exists yet. That makes\n * this a free choice now and an expensive one the moment BC4 ships attachments.\n */\nexport const STORAGE_FOLDERS = {\n  attachments: '/BigConsole/AI Assistant/Attachments',\n  artifacts: '/BigConsole/AI Assistant/Artifacts',\n} as const;\n\n/**\n * The pages of ONE record that no sidebar entry names (BOFF-8060 N1b), so \"take me\n * there\" can open them from a link in the assistant's own reply.\n *\n * ★★ `exclude` lists the router's STATIC siblings of each `:id` segment\n * (`BigConsoleRoutes.tsx`): `datasinks/new` is the builder, not a data source.\n * `entityRoutes.test.ts` resolves every template through the real route table and\n * checks every static sibling against them, so the two lists cannot drift from the\n * router unnoticed.\n *\n * ★ A workflow's address is `workflows/workflow/<key>/<version>` (a slug key such\n * as `github_user_profile` or a UUID, plus `v1`); the version-less\n * `workflows/:workflowId` is a different page and is deliberately not declared.\n *\n * ★ `/integrations/connections` is the app shell's Connected Systems page, shown\n * to whoever can see the Integrations entry.\n */\nexport const ENTITY_ROUTES: readonly AssistantEntityRoute[] = [\n  {\n    id: 'bigconsole-datasink',\n    pattern: '/bigconsole/datasinks/:id',\n    params: { id: { kind: 'id', exclude: ['new'] } },\n    visibleWith: 'bigconsole-datasinks',\n    noun: { key: 'entity.datasink', fallback: 'data source' },\n  },\n  {\n    id: 'bigconsole-dashboard',\n    pattern: '/bigconsole/dashboards/:id',\n    params: { id: { kind: 'id' } },\n    visibleWith: 'bigconsole-dashboards',\n    noun: { key: 'entity.dashboard', fallback: 'dashboard' },\n  },\n  {\n    id: 'bigconsole-parser',\n    pattern: '/bigconsole/parsers/:id',\n    params: { id: { kind: 'id', exclude: ['new'] } },\n    visibleWith: 'bigconsole-parsers',\n    noun: { key: 'entity.parser', fallback: 'parser' },\n  },\n  {\n    id: 'bigconsole-workflow',\n    pattern: '/bigconsole/workflows/workflow/:key/:version',\n    params: { key: { kind: 'slug' }, version: { kind: 'slug' } },\n    visibleWith: 'bigconsole-workflows-list',\n    noun: { key: 'entity.workflow', fallback: 'workflow' },\n  },\n  {\n    id: 'bigconsole-connections',\n    pattern: '/integrations/connections',\n    params: {},\n    visibleWith: 'integrations',\n    noun: { key: 'entity.connections', fallback: 'Connected Systems' },\n  },\n];\n\n/**\n * How the panel reads a UI command it carries out itself (BOFF-7802), for\n * BigConsole.\n *\n * ★★ `mode-only` because BigConsole's CONTENT has themes of its own: a\n * dashboard has a theme, so \"use the dark theme\" in a dashboard builder is a\n * request about the dashboard, and must reach the model rather than flip the\n * app. fe-libs names this exact case (`LocalUiCommandOptions.themeWords`). Only\n * \"<name> mode\" (\"dark mode\") or a theme qualified as the app's (\"change the\n * app theme to dark\") still changes the app locally, with no turn.\n *\n * ★ Its own exported constant so the seam test can pin the field by identity,\n * like every other field on the seam value.\n */\nexport const LOCAL_UI_COMMANDS: LocalUiCommandOptions = {\n  themeWords: 'mode-only',\n  entityRoutes: ENTITY_ROUTES,\n  // BOFF-8060 N1b: \"open the Coffee Shop Sales dashboard\" / data source, by name.\n  records: BIGCONSOLE_RECORD_ADAPTERS,\n  /**\n   * ★ BOFF-8060 N2 (opt-in): each turn also offers the model the pages this\n   * person may be taken to (fe-libs `buildUiCatalogue`): built ONLY from the\n   * RBAC-filtered sidebar once its permissions have settled, never while they\n   * load, after a failed permission fetch, or for a simulated role; capped at\n   * 120 entries and 8 KB; labels and paths only, no record data.\n   *\n   * It is a body key on the sandbox prompt request. An AI runtime without N2\n   * ignores an unknown key (the `conversationId` / `writeReply` precedent), so\n   * this is inert on the prod runtime pinned today (2026.928.98) and active\n   * where the N2 runtime runs (alpha, 2026.1007.103). Turning it off is this\n   * one line.\n   */\n  uiCatalogue: true,\n};\n\n/**\n * Every seam field, required — the provider's props minus its children, and\n * minus the two answers BigConsole deliberately does not give.\n *\n * ★★ `reportTokenUsage` is omitted ON EVIDENCE, not by oversight, and this\n * `Omit` member is the only place that decision is expressed in the type system.\n * `wspace-bigconsole-svc` declares NO token-usage mutation at all, and nothing in\n * this MFE reports one today. The obvious \"fix\" — wiring fe-libs' shared\n * reporter — would bill VibeControls for BigConsole turns: `reportAiTokenUsage`\n * is declared only in `wspace-vibecontrols-svc`, against the\n * `vibecontrols.ai.credits` quota. Metering BigConsole is a backend change.\n *\n * Note that BigConsole's `bigconsole.*` quotas are a different mechanism —\n * they cap entity counts, not AI spend — so their presence is not evidence that\n * turns are metered.\n *\n * ★★ `confirmWrite` is omitted so a HIGH-risk write proposal is confirmed in\n * fe-libs' shared `AssistantWriteConfirmDialog` (BOFF-7803 5a). That is the\n * documented default when a product has no dialog of its own, and BigConsole\n * has none. A product dialog must meet the whole contract fe-libs sets for it\n * (readback, target count, consequences, the exact confirm label, sensitive\n * values masked, never `window.confirm`), and the shared one already does, so a\n * BigConsole copy would only be a second place for that to go wrong. The\n * bigconsole-app ambient declaration of this value mirrors this `Omit`.\n */\nexport type BigConsoleAssistantProduct = Required<\n  Omit<AssistantProductProviderProps, 'children' | 'reportTokenUsage' | 'confirmWrite'>\n>;\n\n/**\n * ★ Each field points at a product-owned implementation BY IDENTITY — no inline\n * arrow wrappers. The seam guard asserts `toBe`, because a wrapper is how a\n * function silently stops being the one the tests cover.\n *\n * ★ `writeAccess` is deliberately absent: it is a PROP on the shared panel, not\n * a seam field, so it belongs to BC4's panel mount rather than here. Same for\n * the preview controller, which the panel takes as `panelProps.preview`.\n */\nexport const BIGCONSOLE_ASSISTANT_PRODUCT: BigConsoleAssistantProduct = {\n  product: BIGCONSOLE_PRODUCT,\n  modes: BIGCONSOLE_ASSISTANT_MODES,\n  describeCurrentPage,\n  gatherPageContext,\n  buildPrompt: buildPromptForMode,\n  storageFolders: STORAGE_FOLDERS,\n  localUiCommands: LOCAL_UI_COMMANDS,\n  /**\n   * ★ On. That is fe-libs' own default (on unless `false`, BOFF-7801) and\n   * what BigConsole does today: this seam never set the field, so its turns\n   * have been reported by default. The reports carry timings and coarse\n   * dimensions only, and BigConsole is the first proposal-v1 product, so its\n   * latency is the measurement the rollout needs.\n   */\n  reportTurnTimings: true,\n  /**\n   * ★★★ BigConsole is the FIRST proposal-v1 product (BOFF-7803 5a). At\n   * `'proposal-v1'` fe-libs provisions Ask and Build (`api-calls`) through the\n   * `assistant:use`-gated `provisionAssistantSandbox`, requests the proposal\n   * flow for Build, and lets a spoken Build turn through when the sandbox's\n   * own `/health` also says v1. Every change then waits for the button on its\n   * card; the sandbox and wspace-sandbox-svc decide whether it runs.\n   *\n   * ★★ That provisioning path has NO `createSandbox` fallback: while\n   * wspace-sandbox-svc answers it with 503 (its session relay switched off),\n   * BigConsole's assistant cannot start at all. This flag reaches users only\n   * when bigconsole-app pins the microfe version that carries it, so the app\n   * bump is the release switch, and it waits for the relay.\n   */\n  writeApproval: 'proposal-v1',\n};\n"],"mappings":";;;;;;AAsCA,IAAa,IAAkB;CAC7B,aAAa;CACb,WAAW;CACZ,EAkIY,IAA2D;CACtE,SAAS;CACT,OAAO;CACP;CACA;CACA,aAAa;CACb,gBAAgB;CAChB,iBAlEsD;EACtD,YAAY;EACZ,cAtD4D;GAC5D;IACE,IAAI;IACJ,SAAS;IACT,QAAQ,EAAE,IAAI;KAAE,MAAM;KAAM,SAAS,CAAC,MAAM;KAAE,EAAE;IAChD,aAAa;IACb,MAAM;KAAE,KAAK;KAAmB,UAAU;KAAe;IAC1D;GACD;IACE,IAAI;IACJ,SAAS;IACT,QAAQ,EAAE,IAAI,EAAE,MAAM,MAAM,EAAE;IAC9B,aAAa;IACb,MAAM;KAAE,KAAK;KAAoB,UAAU;KAAa;IACzD;GACD;IACE,IAAI;IACJ,SAAS;IACT,QAAQ,EAAE,IAAI;KAAE,MAAM;KAAM,SAAS,CAAC,MAAM;KAAE,EAAE;IAChD,aAAa;IACb,MAAM;KAAE,KAAK;KAAiB,UAAU;KAAU;IACnD;GACD;IACE,IAAI;IACJ,SAAS;IACT,QAAQ;KAAE,KAAK,EAAE,MAAM,QAAQ;KAAE,SAAS,EAAE,MAAM,QAAQ;KAAE;IAC5D,aAAa;IACb,MAAM;KAAE,KAAK;KAAmB,UAAU;KAAY;IACvD;GACD;IACE,IAAI;IACJ,SAAS;IACT,QAAQ,EAAE;IACV,aAAa;IACb,MAAM;KAAE,KAAK;KAAsB,UAAU;KAAqB;IACnE;GACF;EAoBC,SAAS;EAcT,aAAa;EACd;CAuDC,mBAAmB;CAenB,eAAe;CAChB"}

package/dist/bigconsole/assistant/assistantPrompt.d.ts

@@ -45,3 +45,4 @@ export declare const API_CALLS_PROPOSAL_PREAMBLE: string;
  * confirmation preamble for it would be copy that lies about what the mode does.
  */
 export declare function buildPromptForMode(mode: AssistantMode, content: string, languageName?: string, isExplicitChoice?: boolean, dictated?: boolean, options?: AssistantPromptOptions): string;
+//# sourceMappingURL=assistantPrompt.d.ts.map

package/dist/bigconsole/assistant/assistantPrompt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assistantPrompt.d.ts","sourceRoot":"","sources":["../../../src/bigconsole/assistant/assistantPrompt.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,6CAA6C,CAAC;AAE1F,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2CAA2C,CAAC;AAE/E;;;GAGG;AACH,eAAO,MAAM,sBAAsB,yBAAyB,CAAC;AAE7D;;;GAGG;AACH,eAAO,MAAM,0BAA0B,QAQ3B,CAAC;AAEb;;;;;;;;;;GAUG;AACH,eAAO,MAAM,2BAA2B,QAAuE,CAAC;AAwEhH;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,aAAa,EACnB,OAAO,EAAE,MAAM,EACf,YAAY,CAAC,EAAE,MAAM,EACrB,gBAAgB,UAAQ,EACxB,QAAQ,UAAQ,EAChB,OAAO,CAAC,EAAE,sBAAsB,GAC/B,MAAM,CAWR"}

package/dist/bigconsole/assistant/assistantPrompt.js

@@ -34,3 +34,5 @@ function c(e, n, r, c = !1, l = !1, u) {
 }
 //#endregion
 export { n as API_CALLS_CONFIRM_PREAMBLE, r as API_CALLS_PROPOSAL_PREAMBLE, t as USER_REQUEST_DELIMITER, c as buildPromptForMode };
+
+//# sourceMappingURL=assistantPrompt.js.map

package/dist/bigconsole/assistant/assistantPrompt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"assistantPrompt.js","names":[],"sources":["../../../src/bigconsole/assistant/assistantPrompt.ts"],"sourcesContent":["/**\n * The write rules for the assistant's write mode, plus the language and\n * dictation instructions.\n *\n * The write rules depend on what the sandbox the turn goes to ENFORCES, which\n * fe-libs passes as `buildPrompt`'s sixth argument from that sandbox's own\n * `/health` (BOFF-7803 5a):\n *\n * - `legacy`: the in-sandbox agent executes mutations itself, so the turn asks\n *   it to describe each write and wait for the user's \"yes\". ADVISORY: the\n *   dependable guard is the host-side consent dialog plus the admin gate.\n * - `proposal-v1`: the helper only PROPOSES a mutation, and only the button on\n *   its card confirms it. Asking for a typed \"yes\" there would contradict the\n *   sandbox, so the turn carries fe-libs' `PROPOSAL_WRITE_RULES` instead.\n *\n * Either way the rules are prepended to the user's TURN, not to the session\n * system prompt. Sending them as `system` would REPLACE the whole mode prompt\n * and silently delete the agent's api-calls behaviour along with it.\n *\n * Ported from FluidGrids' `assistantPrompt.ts` (itself ported from\n * microfe-vibecontrols), with BigConsole nouns. The composition and the\n * delimiter discipline are unchanged on purpose — see `buildPromptForMode`.\n */\n\n/**\n * ★ The TRANSPORT's mode type, not BigConsole's narrower list. The shared panel\n * calls `buildPrompt` with whatever mode its store holds, which can be one this\n * product no longer offers (a restored conversation, or a build that dropped a\n * mode) until the panel resets it, so the parameter has to accept every mode the\n * panel can send.\n */\nimport type { AssistantPromptOptions } from '@burdenoff/fe-libs/shared/assistant/product';\nimport { PROPOSAL_WRITE_RULES } from '@burdenoff/fe-libs/shared/assistant/proposalWriteRules';\nimport type { AssistantMode } from '@burdenoff/fe-libs/shared/assistant/types';\n\n/**\n * Marks where our instructions stop and the user's words begin. Exactly one may\n * exist in a prompt, and it must be last — see `buildPromptForMode`.\n */\nexport const USER_REQUEST_DELIMITER = '--- User request ---';\n\n/**\n * The write rules for a Build turn to a LEGACY sandbox, which runs a mutation\n * itself. Unchanged by BOFF-7803 5a, byte for byte.\n */\nexport const API_CALLS_CONFIRM_PREAMBLE = [\n  'You are in api-calls mode for BigConsole and can run GraphQL queries and mutations on the user behalf.',\n  'Before performing ANY write (create, update, delete — any mutation):',\n  '1. State exactly what you are about to change (entity, fields, and values).',\n  '2. Ask the user to confirm, and WAIT for an explicit \"yes\"/\"confirm\" before executing it.',\n  'Read-only queries may run without confirmation. Confirm each write separately; never batch mutations behind a single confirmation.',\n  '',\n  USER_REQUEST_DELIMITER,\n].join('\\n');\n\n/**\n * The write rules for a Build turn to a PROPOSAL-V1 sandbox (BOFF-7803 5a),\n * composed exactly as fe-libs documents it: the shared rules, a blank line,\n * then this product's own delimiter.\n *\n * ★★ The rules are fe-libs' `PROPOSAL_WRITE_RULES`, not a BigConsole rewrite.\n * They are kept consistent with the sandbox's own proposal policy, so a local\n * copy would be a second text to keep in step with it. They carry no delimiter\n * of their own, so this one is the only one, and it is last, as after the\n * legacy preamble.\n */\nexport const API_CALLS_PROPOSAL_PREAMBLE = `${PROPOSAL_WRITE_RULES('BigConsole')}\\n\\n${USER_REQUEST_DELIMITER}`;\n\n/**\n * The write preamble for a Build turn, by what the receiving sandbox enforces.\n * Only exactly `proposal-v1` selects the proposal rules; anything else, or no\n * options at all, keeps the legacy text, which is what fe-libs sends for a\n * sandbox that has not reported the v1 protocol.\n */\nfunction writePreambleFor(options: AssistantPromptOptions | undefined): string {\n  return options?.writeApproval === 'proposal-v1' ? API_CALLS_PROPOSAL_PREAMBLE : API_CALLS_CONFIRM_PREAMBLE;\n}\n\n/**\n * Ask for the reply in the user's language.\n *\n * ★ Nothing else does. The sandbox system prompt carries no language\n * instruction and the grounding documentation is entirely in English, so every\n * force in the session pushes the answer towards English regardless of what the\n * user wrote. The model's tendency to mirror its input is the only thing\n * resisting that, and it loses.\n *\n * The second clause is the one that matters: **translate the docs, do not\n * switch to their language.** Without it a grounded answer drifts back to\n * English mid-reply simply because the source material is English.\n */\nfunction buildLanguagePreamble(languageName: string, isExplicitChoice: boolean): string {\n  return [\n    isExplicitChoice\n      ? `Reply in ${languageName}. The user has explicitly chosen this language, so use it even if they write to you in another one.`\n      : `Reply in ${languageName}, matching the language the user wrote in.`,\n    `Translate any English documentation you ground your answer in into ${languageName} rather than switching to English to quote it.`,\n    'Keep identifiers, code, CLI flags, API field names and product nouns in their original form — translating them would make them wrong.',\n  ].join('\\n');\n}\n\n/**\n * Told to the model when the turn was SPOKEN rather than typed.\n *\n * ★ Speech recognition does not fail uniformly — it fails on specific words,\n * and in BigConsole the ones it fails on are predictable: data sink names,\n * dashboard ids, parser names and column headers. A recogniser has no model for\n * a dashboard id read aloud, so a sentence comes back mostly right with the\n * load-bearing words wrong.\n *\n * ★ The refusal to guess is the important half. Charitable interpretation is\n * right for a mangled verb and wrong for a mangled IDENTIFIER: acting on a\n * misheard dashboard id edits somebody else's dashboard. One extra question\n * costs a few seconds.\n */\nconst DICTATION_PREAMBLE = [\n  'This turn was DICTATED, so treat unusual words as probable speech-recognition errors rather than as what the user meant.',\n  'Repair obvious mis-hearings of technical terms, product nouns, column names and command names using the surrounding context.',\n  'Do NOT guess at a mis-heard data sink name, dashboard id, parser name, widget id or column header — ask which one the user meant before acting on it.',\n].join('\\n');\n\n/**\n * A dictated turn is a SPOKEN conversation, so the reply is spoken too.\n *\n * ★★ In Build only against a PROPOSAL-V1 sandbox. From fe-libs 2026.920.x,\n * `writeModeSendRefusal` refuses a dictated send in any `writeCapable` mode\n * before a prompt is composed (\"Voice can't be used in a mode that can change\n * your data\"), and Build is write-capable. fe-libs 2026.929.1 lifts that only\n * when the turn is proposal-bound: this product's flag is `proposal-v1` AND the\n * sandbox's own `/health` says v1 (BOFF-7803 5a, FE9). Then nothing spoken can\n * run a change, only a card's button can. So `dictated` and `api-calls` occur\n * together only with the proposal rules, never with the legacy \"wait for yes\".\n */\nconst VOICE_REPLY_PREAMBLE = [\n  'Your reply will be read aloud. Write it to be heard, not scanned:',\n  'short sentences, no markdown syntax, no tables, and no code blocks unless the user asked for code.',\n].join('\\n');\n\n/**\n * Compose the turn actually sent to the agent.\n *\n * Ordering is deliberate. Dictation goes AFTER the language lines and before the\n * delimiter: it is an instruction about the user's text, so it belongs with the\n * instructions rather than inside them.\n *\n * ★★ `USER_REQUEST_DELIMITER` is emitted exactly once, here. Both api-calls\n * preambles end with their own copy, so it must not be added again — a second\n * one mid-prompt leaves the safety instructions sitting *after* a \"User request\"\n * marker, i.e. presented to the model as though the user had written them.\n *\n * ★★ `options` is fe-libs' sixth argument (BOFF-7803 5a): what the sandbox this\n * turn goes to enforces, from its own `/health` — never this product's flag,\n * which only says what BigConsole ASKS for. A proposal-v1 sandbox gets the\n * proposal rules; every other turn is composed exactly as before.\n *\n * ★ No branch for Ask (`assistant`). It is read-only — its sandbox boots with\n * `AI_ASSISTANT_READONLY=1` — so there is no write to confirm, and inventing a\n * confirmation preamble for it would be copy that lies about what the mode does.\n */\nexport function buildPromptForMode(\n  mode: AssistantMode,\n  content: string,\n  languageName?: string,\n  isExplicitChoice = false,\n  dictated = false,\n  options?: AssistantPromptOptions\n): string {\n  const preamble = [\n    languageName ? buildLanguagePreamble(languageName, isExplicitChoice) : '',\n    dictated ? DICTATION_PREAMBLE : '',\n    dictated ? VOICE_REPLY_PREAMBLE : '',\n  ]\n    .filter(Boolean)\n    .join('\\n\\n');\n  const language = preamble ? `${preamble}\\n\\n` : '';\n  if (mode === 'api-calls') return `${language}${writePreambleFor(options)}\\n${content}`;\n  return language ? `${language}${USER_REQUEST_DELIMITER}\\n${content}` : content;\n}\n"],"mappings":";;AAuCA,IAAa,IAAyB,wBAMzB,IAA6B;CACxC;CACA;CACA;CACA;CACA;CACA;CACA;CACD,CAAC,KAAK,KAAK,EAaC,IAA8B,GAAG,EAAqB,aAAa,CAAC,MAAM;AAQvF,SAAS,EAAiB,GAAqD;AAC7E,QAAO,GAAS,kBAAkB,gBAAgB,IAA8B;;AAgBlF,SAAS,EAAsB,GAAsB,GAAmC;AACtF,QAAO;EACL,IACI,YAAY,EAAa,uGACzB,YAAY,EAAa;EAC7B,sEAAsE,EAAa;EACnF;EACD,CAAC,KAAK,KAAK;;AAiBd,IAAM,IAAqB;CACzB;CACA;CACA;CACD,CAAC,KAAK,KAAK,EAcN,IAAuB,CAC3B,qEACA,qGACD,CAAC,KAAK,KAAK;AAuBZ,SAAgB,EACd,GACA,GACA,GACA,IAAmB,IACnB,IAAW,IACX,GACQ;CACR,IAAM,IAAW;EACf,IAAe,EAAsB,GAAc,EAAiB,GAAG;EACvE,IAAW,IAAqB;EAChC,IAAW,IAAuB;EACnC,CACE,OAAO,QAAQ,CACf,KAAK,OAAO,EACT,IAAW,IAAW,GAAG,EAAS,QAAQ;AAEhD,QADI,MAAS,cAAoB,GAAG,IAAW,EAAiB,EAAQ,CAAC,IAAI,MACtE,IAAW,GAAG,IAAW,EAAuB,IAAI,MAAY"}

package/dist/bigconsole/assistant/assistantRunPersistence.d.ts

@@ -27,3 +27,4 @@ export declare function readPersistedRun(workspaceId: string, actorId: string |
 export declare function writePersistedRun(workspaceId: string, actorId: string | null, run: PersistedRun): void;
 /** Forgets the run kept for this workspace. Best effort. */
 export declare function removePersistedRun(workspaceId: string): void;
+//# sourceMappingURL=assistantRunPersistence.d.ts.map

package/dist/bigconsole/assistant/assistantRunPersistence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assistantRunPersistence.d.ts","sourceRoot":"","sources":["../../../src/bigconsole/assistant/assistantRunPersistence.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,OAAO,KAAK,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAE7E,gEAAgE;AAChE,eAAO,MAAM,kBAAkB,wCAAwC,CAAC;AAExE,yDAAyD;AACzD,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,IAAI,CAAC;IACb,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,WAAW,EAAE,OAAO,CAAC;IACrB,KAAK,EAAE,MAAM,CAAC,cAAc,EAAE,iBAAiB,CAAC,CAAC;IACjD,SAAS,EAAE;QAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACtE,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B;AAmBD,wBAAgB,aAAa,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAEzD;AAiED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,GAAG,YAAY,GAAG,IAAI,CAgCjG;AAED,uEAAuE;AACvE,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,EAAE,GAAG,EAAE,YAAY,GAAG,IAAI,CAkBtG;AAED,4DAA4D;AAC5D,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAQ5D"}

package/dist/bigconsole/assistant/assistantRunPersistence.js

@@ -110,3 +110,5 @@ function d(e) {
 }
 //#endregion
 export { l as readPersistedRun, d as removePersistedRun, u as writePersistedRun };
+
+//# sourceMappingURL=assistantRunPersistence.js.map

package/dist/bigconsole/assistant/assistantRunPersistence.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"assistantRunPersistence.js","names":[],"sources":["../../../src/bigconsole/assistant/assistantRunPersistence.ts"],"sourcesContent":["/**\n * The build preview's run state, kept for the life of the TAB (BOFF-7799, A3).\n *\n * ★★★ WHY. BigConsole restores the conversation from the server\n * (`SERVER_HISTORY`), but the preview's run store lived only in memory. A\n * reload kept the chat and lost the page preview under the breadcrumb, so the\n * build a user had just watched was gone while the conversation that made it\n * was still on screen. This keeps the part the page preview draws, and nothing\n * else, in `sessionStorage`.\n *\n * ★★ WHAT IS KEPT, AND WHAT IS NOT. Kept: `hasRun`, whether the preview is\n * open, the four step statuses, the entity ids and the last-update time. None\n * of that is sensitive: the ids name workspace resources the server still\n * authorises on every fetch. NOT kept: the prompt (the user's own words), the\n * caption (the agent's narration) and the error text. `isRunning` is not kept\n * either: nothing can follow a turn across a reload, so a restored `running`\n * step drops back to `pending`, exactly as `finishRun` does.\n *\n * ★★ ONE ENTRY PER WORKSPACE, and it names its actor. The key carries the\n * workspace, so a reload in another workspace never reads this one. The record\n * carries the actor it was written for, because fe-libs found that the\n * workspace alone is not an identity: two accounts can share a workspace and a\n * tab (profile switching), and the second must not be shown the first one's\n * build (see fe-libs `AssistantPreviewRun.actorId`).\n *\n * ★ EVERY STORAGE ACCESS IS CONTAINED. `sessionStorage` can be missing (tests,\n * SSR), can throw on access (blocked site data, sandboxed frames) and can throw\n * on write (quota). Any of those means \"nothing kept\", never an exception in\n * the page surface or in the store action that triggered the write.\n */\nimport type { PreviewStepKey, PreviewStepStatus } from './assistantRunStore';\n\n/** `sessionStorage` key prefix; the workspace id follows it. */\nexport const RUN_STORAGE_PREFIX = 'bigconsole.assistant.previewRun.v1:';\n\n/** The slice of the run store that survives a reload. */\nexport interface PersistedRun {\n  hasRun: true;\n  conversationId?: string;\n  previewOpen: boolean;\n  steps: Record<PreviewStepKey, PreviewStepStatus>;\n  entityIds: { datasink?: string; dashboard?: string; parser?: string };\n  updatedAt: number | null;\n}\n\n/** What is actually written: the slice, its format version and its owner. */\ninterface StoredRun extends PersistedRun {\n  v: 1;\n  actorId: string | null;\n}\n\nconst STEP_KEYS: readonly PreviewStepKey[] = ['datasink', 'dashboard', 'parser', 'widget'];\nconst ENTITY_KEYS = ['datasink', 'dashboard', 'parser'] as const;\n\n/**\n * ★★ The id charset the store itself harvests (`ENTITY_LINK`, `JSON_ID_STEPS`).\n * Restored ids are interpolated into in-app paths (`/bigconsole/datasinks/<id>`),\n * so a value edited in devtools must not be able to smuggle `../` or a query\n * string into a navigation. Anything else is treated as a corrupt record.\n */\nconst ENTITY_ID = /^[A-Za-z0-9_-]{1,128}$/;\n\nexport function runStorageKey(workspaceId: string): string {\n  return `${RUN_STORAGE_PREFIX}${workspaceId}`;\n}\n\n/** The tab's `sessionStorage`, or null wherever it cannot be used. */\nfunction sessionStore(): Storage | null {\n  try {\n    // ★ Reading the property is itself the access that throws when site data\n    // is blocked, so the `typeof` guard sits inside the try, not before it.\n    return typeof globalThis.sessionStorage === 'undefined' ? null : globalThis.sessionStorage;\n  } catch {\n    return null;\n  }\n}\n\nfunction isRecord(value: unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null && !Array.isArray(value);\n}\n\nfunction isStepStatus(value: unknown): value is PreviewStepStatus {\n  return value === 'pending' || value === 'running' || value === 'done' || value === 'skipped';\n}\n\n/** Parses and validates one stored record. Any deviation reads as absent. */\nfunction parseStoredRun(raw: string): StoredRun | null {\n  let value: unknown;\n  try {\n    value = JSON.parse(raw);\n  } catch {\n    return null;\n  }\n  if (!isRecord(value) || value.v !== 1 || value.hasRun !== true) return null;\n\n  const { previewOpen, actorId, updatedAt, steps, entityIds, conversationId } = value;\n  if (conversationId !== undefined && (typeof conversationId !== 'string' || !ENTITY_ID.test(conversationId)))\n    return null;\n  if (typeof previewOpen !== 'boolean') return null;\n  if (actorId !== null && typeof actorId !== 'string') return null;\n  if (updatedAt !== null && (typeof updatedAt !== 'number' || !Number.isFinite(updatedAt))) return null;\n\n  if (!isRecord(steps)) return null;\n  const { datasink, dashboard, parser, widget } = steps;\n  if (!isStepStatus(datasink) || !isStepStatus(dashboard) || !isStepStatus(parser) || !isStepStatus(widget)) {\n    return null;\n  }\n\n  if (!isRecord(entityIds)) return null;\n  const ids: PersistedRun['entityIds'] = {};\n  for (const key of ENTITY_KEYS) {\n    const id = entityIds[key];\n    if (id === undefined) continue;\n    if (typeof id !== 'string' || !ENTITY_ID.test(id)) return null;\n    ids[key] = id;\n  }\n\n  return {\n    v: 1,\n    actorId,\n    hasRun: true,\n    ...(typeof conversationId === 'string' ? { conversationId } : {}),\n    previewOpen,\n    steps: { datasink, dashboard, parser, widget },\n    entityIds: ids,\n    updatedAt,\n  };\n}\n\n/**\n * The run kept for this workspace and actor, or null.\n *\n * ★ A record written for another actor is left in place, not deleted: it is\n * that actor's, and they may switch back. A corrupt record is removed.\n */\nexport function readPersistedRun(workspaceId: string, actorId: string | null): PersistedRun | null {\n  const storage = sessionStore();\n  if (!storage) return null;\n  let raw: string | null;\n  try {\n    raw = storage.getItem(runStorageKey(workspaceId));\n  } catch {\n    return null;\n  }\n  if (raw === null) return null;\n\n  const stored = parseStoredRun(raw);\n  if (!stored) {\n    removePersistedRun(workspaceId);\n    return null;\n  }\n  if (stored.actorId !== actorId) return null;\n\n  // Nothing follows a turn across a reload: a step that was in flight did not\n  // land, so it drops back to `pending` for a later prompt (as `finishRun` does).\n  const steps = { ...stored.steps };\n  for (const key of STEP_KEYS) {\n    if (steps[key] === 'running') steps[key] = 'pending';\n  }\n  return {\n    hasRun: true,\n    ...(stored.conversationId ? { conversationId: stored.conversationId } : {}),\n    previewOpen: stored.previewOpen,\n    steps,\n    entityIds: stored.entityIds,\n    updatedAt: stored.updatedAt,\n  };\n}\n\n/** Keeps `run` for this workspace, owned by `actorId`. Best effort. */\nexport function writePersistedRun(workspaceId: string, actorId: string | null, run: PersistedRun): void {\n  const storage = sessionStore();\n  if (!storage) return;\n  const stored: StoredRun = {\n    v: 1,\n    actorId,\n    hasRun: true,\n    ...(run.conversationId ? { conversationId: run.conversationId } : {}),\n    previewOpen: run.previewOpen,\n    steps: run.steps,\n    entityIds: run.entityIds,\n    updatedAt: run.updatedAt,\n  };\n  try {\n    storage.setItem(runStorageKey(workspaceId), JSON.stringify(stored));\n  } catch {\n    // Quota or blocked storage: the preview simply does not survive a reload.\n  }\n}\n\n/** Forgets the run kept for this workspace. Best effort. */\nexport function removePersistedRun(workspaceId: string): void {\n  const storage = sessionStore();\n  if (!storage) return;\n  try {\n    storage.removeItem(runStorageKey(workspaceId));\n  } catch {\n    // Blocked storage: there is nothing we could have read back either.\n  }\n}\n"],"mappings":"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"}

package/dist/bigconsole/assistant/assistantRunStore.d.ts

@@ -72,3 +72,4 @@ interface AssistantRunState {
 export declare function runBelongsToWorkspace(runWorkspaceId: string | null, boundWorkspaceId: string | null): boolean;
 export declare const useAssistantRunStore: import('zustand').UseBoundStore<import('zustand').StoreApi<AssistantRunState>>;
 export {};
+//# sourceMappingURL=assistantRunStore.d.ts.map

package/dist/bigconsole/assistant/assistantRunStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assistantRunStore.d.ts","sourceRoot":"","sources":["../../../src/bigconsole/assistant/assistantRunStore.ts"],"names":[],"mappings":"AA+BA,MAAM,MAAM,cAAc,GAAG,UAAU,GAAG,WAAW,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAC5E,MAAM,MAAM,iBAAiB,GAAG,SAAS,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAAC;AAE3E,eAAO,MAAM,aAAa,EAAE,SAAS,cAAc,EAAkD,CAAC;AAEtG,UAAU,iBAAiB;IACzB,2BAA2B;IAC3B,SAAS,EAAE,OAAO,CAAC;IACnB,oFAAoF;IACpF,WAAW,EAAE,OAAO,CAAC;IACrB,+DAA+D;IAC/D,MAAM,EAAE,OAAO,CAAC;IAChB;;;;;;OAMG;IACH,WAAW,EAAE,OAAO,CAAC;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC,cAAc,EAAE,iBAAiB,CAAC,CAAC;IACjD,6EAA6E;IAC7E,SAAS,EAAE;QAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACtE,uEAAuE;IACvE,OAAO,EAAE,MAAM,CAAC;IAChB,4EAA4E;IAC5E,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,8EAA8E;IAC9E,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB;;;OAGG;IACH,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,qFAAqF;IACrF,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAEvB,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,eAAe,EAAE,MAAM,CAAC;IACxB,kBAAkB,EAAE,MAAM,EAAE,CAAC;IAC7B,iBAAiB,EAAE,OAAO,CAAC,MAAM,CAAC,cAAc,EAAE,MAAM,CAAC,CAAC,CAAC;IAC3D,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,cAAc,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IAC5D,WAAW,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IAC1E,aAAa,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACzC,SAAS,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,CAAC;IAC1C,WAAW,EAAE,MAAM,IAAI,CAAC;IACxB,YAAY,EAAE,MAAM,IAAI,CAAC;IACzB,cAAc,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;IAC3C;;;;;OAKG;IACH,aAAa,EAAE,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,CAAC;CACrD;AA6ED;;;;;;;;;;;;GAYG;AACH,wBAAgB,qBAAqB,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI,EAAE,gBAAgB,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO,CAE7G;AAED,eAAO,MAAM,oBAAoB,gFAuJ9B,CAAC"}

package/dist/bigconsole/assistant/assistantRunStore.js

@@ -171,3 +171,5 @@ _.subscribe((e, t) => {
 });
 //#endregion
 export { o as PREVIEW_STEPS, g as runBelongsToWorkspace, _ as useAssistantRunStore };
+
+//# sourceMappingURL=assistantRunStore.js.map

package/dist/bigconsole/assistant/assistantRunStore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"assistantRunStore.js","names":[],"sources":["../../../src/bigconsole/assistant/assistantRunStore.ts"],"sourcesContent":["/**\n * What the assistant is building, right now.\n *\n * Confirmed write results and narration drive this store into a UI-visible\n * monotone DataSink → Dashboard → Parser → Widget rail, plus the id of each\n * entity as it appears.\n *\n * Three rules make the parsing survive a model that phrases things differently:\n *\n * 1. Read the id from BOTH the link path (`/bigconsole/datasinks/<id>`) AND the\n *    raw mutation JSON (`{ \"createDataSink\": { \"id\": \"<uuid>\", … } }`). The agent\n *    freely prints one, the other, or both — if we only watched for the link a\n *    turn that printed just JSON would leave the tab stuck on \"Waiting…\".\n * 2. Never regress. `progress.content` is REPLACED on every poll (not appended),\n *    so a shorter string arriving later must not rewind the rail.\n * 3. Accumulate across an incremental conversation. Each prompt builds one piece;\n *    a new prompt must NOT wipe the pieces already built, or the earlier tabs go\n *    blank. `startRun` preserves prior steps/ids and only lights up the next one.\n *\n * ★★ It belongs to ONE workspace (BOFF-7799). The page surfaces bind the active\n * workspace (`bindWorkspace`); switching clears the run, and the slice the page\n * preview draws is kept in `sessionStorage` per workspace, so a reload in the\n * same tab brings the preview back beside the restored conversation. See\n * `assistantRunPersistence.ts` for what is kept and why.\n */\nimport { getActorId } from '@burdenoff/fe-libs/shared/assistant/context';\nimport { create } from 'zustand';\nimport { previewMutationEntities } from './previewMutationResult';\n\nimport { readPersistedRun, removePersistedRun, writePersistedRun, type PersistedRun } from './assistantRunPersistence';\n\nexport type PreviewStepKey = 'datasink' | 'dashboard' | 'parser' | 'widget';\nexport type PreviewStepStatus = 'pending' | 'running' | 'done' | 'skipped';\n\nexport const PREVIEW_STEPS: readonly PreviewStepKey[] = ['datasink', 'dashboard', 'parser', 'widget'];\n\ninterface AssistantRunState {\n  /** A turn is in flight. */\n  isRunning: boolean;\n  /** The panel is on screen. Auto-opens when a turn starts; the user can close it. */\n  previewOpen: boolean;\n  /** True once any turn has run — gates the \"Preview\" button. */\n  hasRun: boolean;\n  /**\n   * The full, context-rich panel (mounted inside BigConsoleRoot, with live entity\n   * tabs) is on screen right now. The lightweight app-shell panel reads this and\n   * steps aside so the two never render at once. It flips false the instant you\n   * leave a /bigconsole page — that is what lets the mini panel take over and keep\n   * the build visible on whatever screen you moved to.\n   */\n  richMounted: boolean;\n  prompt: string;\n  steps: Record<PreviewStepKey, PreviewStepStatus>;\n  /** Ids harvested from the agent's links. A widget has no link of its own. */\n  entityIds: { datasink?: string; dashboard?: string; parser?: string };\n  /** Newest \"⏳ …\" line — what the agent says it is doing this second. */\n  caption: string;\n  /** Set when the turn fails, so the panel can stop pretending to be live. */\n  error: string | null;\n  /** Epoch ms of the last progress tick — drives the \"updated 3s ago\" strip. */\n  updatedAt: number | null;\n  /**\n   * The workspace this run belongs to, and the one its kept copy is filed\n   * under. Null until a page surface binds the active workspace.\n   */\n  workspaceId: string | null;\n  /** The actor the kept copy is written for, read once when the workspace is bound. */\n  actorId: string | null;\n\n  conversationId: string | null;\n  contentRevision: number;\n  completedResultIds: string[];\n  entityResultOrder: Partial<Record<PreviewStepKey, number>>;\n  startRun: (prompt: string, conversationId?: string) => void;\n  applyResult: (id: string, output: unknown, messageOrder?: number) => void;\n  applyProgress: (content: string) => void;\n  finishRun: (error: string | null) => void;\n  openPreview: () => void;\n  closePreview: () => void;\n  setRichMounted: (mounted: boolean) => void;\n  /**\n   * Point the store at the active workspace. A change CLEARS the run and forgets\n   * the previous workspace's kept copy, then restores this workspace's copy, if\n   * this tab kept one for this actor. Binding the same workspace is a no-op, so\n   * every surface may call it.\n   */\n  bindWorkspace: (workspaceId: string | null) => void;\n}\n\nconst IDLE_STEPS: Record<PreviewStepKey, PreviewStepStatus> = {\n  datasink: 'pending',\n  dashboard: 'pending',\n  parser: 'pending',\n  widget: 'pending',\n};\n\n/** `/bigconsole/datasinks/<id>` — the trustworthy part of the narration. */\nconst ENTITY_LINK = /\\/bigconsole\\/(datasinks|dashboards|parsers)\\/([A-Za-z0-9_-]+)/g;\n/** The widget links to its dashboard, so it can only be detected from the prose. */\nconst WIDGET_DONE = /widget\\s+(added|created)/i;\nconst RUNNING_LINE = /^⏳\\s*(.+?)…?$/;\n\nconst LINK_TO_STEP: Record<string, PreviewStepKey> = {\n  datasinks: 'datasink',\n  dashboards: 'dashboard',\n  parsers: 'parser',\n};\n\n/**\n * The id straight out of a raw mutation response the agent printed instead of\n * (or as well as) a link, e.g. `{ \"createDataSink\": { \"id\": \"<uuid>\", … } }`.\n * `[^{}]` keeps each match inside its own object so we grab that mutation's id,\n * not a neighbour's. This is what stops \"Waiting…\" when no link is narrated.\n */\nconst JSON_ID_STEPS: ReadonlyArray<{ step: Exclude<PreviewStepKey, 'widget'>; re: RegExp }> = [\n  { step: 'datasink', re: /\"createDataSink\"\\s*:\\s*\\{[^{}]*?\"id\"\\s*:\\s*\"([A-Za-z0-9_-]+)\"/ },\n  { step: 'dashboard', re: /\"createBigConsoleDashboard\"\\s*:\\s*\\{[^{}]*?\"id\"\\s*:\\s*\"([A-Za-z0-9_-]+)\"/ },\n  { step: 'parser', re: /\"createParser\"\\s*:\\s*\\{[^{}]*?\"id\"\\s*:\\s*\"([A-Za-z0-9_-]+)\"/ },\n];\n/** The widget has no page of its own; its create response is enough to mark it done. */\nconst WIDGET_CREATE_JSON = /\"createBigConsoleWidget\"\\s*:\\s*\\{/;\n\n/** Only ever moves a step forward. */\nfunction advance(current: PreviewStepStatus, next: PreviewStepStatus): PreviewStepStatus {\n  const rank: Record<PreviewStepStatus, number> = { pending: 0, running: 1, skipped: 2, done: 3 };\n  return rank[next] > rank[current] ? next : current;\n}\n\ntype RunFields = Pick<\n  AssistantRunState,\n  | 'isRunning'\n  | 'previewOpen'\n  | 'hasRun'\n  | 'prompt'\n  | 'steps'\n  | 'entityIds'\n  | 'caption'\n  | 'error'\n  | 'updatedAt'\n  | 'conversationId'\n  | 'contentRevision'\n  | 'completedResultIds'\n  | 'entityResultOrder'\n>;\n\n/** A run that has not started. `richMounted` is a mount flag, not run state, so it is not here. */\nfunction idleRun(): RunFields {\n  return {\n    conversationId: null,\n    contentRevision: 0,\n    completedResultIds: [],\n    entityResultOrder: {},\n    isRunning: false,\n    previewOpen: false,\n    hasRun: false,\n    prompt: '',\n    steps: { ...IDLE_STEPS },\n    entityIds: {},\n    caption: '',\n    error: null,\n    updatedAt: null,\n  };\n}\n\n/**\n * May a run that started in `runWorkspaceId` drive a store bound to\n * `boundWorkspaceId`?\n *\n * ★★ WHY IT EXISTS. A workspace switch clears the store, but a turn started in\n * the previous workspace keeps streaming. Without this its next snapshot would\n * refill the cleared store, and the refill would be kept under the NEW\n * workspace's key, which is the leak the switch exists to prevent.\n *\n * ★ Lenient on null, deliberately: fe-libs reports `null` when it cannot read\n * the workspace, and an unbound store has nothing to protect. Refusing either\n * would silently stop every preview rather than guard one.\n */\nexport function runBelongsToWorkspace(runWorkspaceId: string | null, boundWorkspaceId: string | null): boolean {\n  return runWorkspaceId === null || boundWorkspaceId === null || runWorkspaceId === boundWorkspaceId;\n}\n\nexport const useAssistantRunStore = create<AssistantRunState>()((set, get) => ({\n  ...idleRun(),\n  richMounted: false,\n  workspaceId: null,\n  actorId: null,\n\n  startRun: (prompt, conversationId) =>\n    set((previous) => {\n      const state =\n        conversationId && previous.hasRun && previous.conversationId !== conversationId\n          ? { ...previous, ...idleRun() }\n          : previous;\n      // A new prompt CONTINUES the same use case (incremental flow) — keep every\n      // step and id already built. Clear any stale spinner from the prior turn,\n      // then light up the earliest step that has not landed yet so the \"working\n      // on it\" indicator sits on the right tab.\n      const steps = { ...state.steps };\n      for (const key of PREVIEW_STEPS) {\n        if (steps[key] === 'running') steps[key] = 'pending';\n      }\n      const next = PREVIEW_STEPS.find((key) => steps[key] === 'pending');\n      if (next) steps[next] = 'running';\n      return {\n        ...state,\n        conversationId: conversationId ?? state.conversationId,\n        isRunning: true,\n        // Auto-open: the whole point is that you SEE the build happen without\n        // having to go looking for it.\n        previewOpen: true,\n        hasRun: true,\n        prompt,\n        steps,\n        // entityIds intentionally preserved (merged) so earlier tabs keep content.\n        caption: '',\n        error: null,\n        updatedAt: Date.now(),\n      };\n    }),\n\n  applyProgress: (content) =>\n    set((state) => {\n      const steps = { ...state.steps };\n      const entityIds = { ...state.entityIds };\n\n      const markDone = (step: PreviewStepKey, id?: string) => {\n        steps[step] = advance(steps[step], 'done');\n        // Always record the freshest id seen this turn (never \"first wins\"): an\n        // incremental prompt that rebuilds a piece must point the tab at the new\n        // one. `step !== 'widget'` narrows to the keys entityIds actually holds.\n        if (id && step !== 'widget') entityIds[step] = id;\n      };\n\n      // 1) Markdown link paths.\n      for (const match of content.matchAll(ENTITY_LINK)) {\n        const step = LINK_TO_STEP[match[1] ?? ''];\n        if (step && match[2]) markDone(step, match[2]);\n      }\n      // 2) Raw mutation JSON (the agent often prints this instead of a link).\n      for (const { step, re } of JSON_ID_STEPS) {\n        const match = re.exec(content);\n        if (match?.[1]) markDone(step, match[1]);\n      }\n\n      if (WIDGET_CREATE_JSON.test(content) || WIDGET_DONE.test(content)) {\n        steps.widget = advance(steps.widget, 'done');\n      }\n\n      // The first step that has not finished is the one being worked on.\n      const active = PREVIEW_STEPS.find((key) => steps[key] === 'pending' || steps[key] === 'running');\n      if (active) steps[active] = advance(steps[active], 'running');\n\n      const caption =\n        content\n          .split('\\n')\n          .map((line) => line.trim())\n          .reverse()\n          .map((line) => RUNNING_LINE.exec(line)?.[1])\n          .find((label): label is string => Boolean(label)) ?? state.caption;\n\n      return { steps, entityIds, caption, updatedAt: Date.now() };\n    }),\n\n  applyResult: (id, output, messageOrder) =>\n    set((state) => {\n      if (state.completedResultIds.includes(id)) return state;\n      const entities = previewMutationEntities(output);\n      if (entities.length === 0) return state;\n      const steps = { ...state.steps };\n      const entityIds = { ...state.entityIds };\n      const entityResultOrder = { ...state.entityResultOrder };\n      let applied = false;\n      const applyEntity = (step: PreviewStepKey, entityId: string) => {\n        const previousOrder = entityResultOrder[step];\n        // Separate issuing sessions are read concurrently. An older message's\n        // successful write must not replace the selected conversation's newer\n        // entity. Equal orders allow several approved actions in the same turn.\n        if (messageOrder !== undefined && previousOrder !== undefined && messageOrder < previousOrder) return;\n        if (messageOrder !== undefined) entityResultOrder[step] = messageOrder;\n        steps[step] = 'done';\n        if (step !== 'widget') entityIds[step] = entityId;\n        applied = true;\n      };\n      for (const entity of entities) {\n        applyEntity(entity.step, entity.id);\n        if (entity.dashboardId) applyEntity('dashboard', entity.dashboardId);\n        if (entity.parserId) applyEntity('parser', entity.parserId);\n      }\n      const completedResultIds = [...state.completedResultIds, id];\n      if (!applied) return { completedResultIds };\n      return {\n        steps,\n        entityIds,\n        entityResultOrder,\n        completedResultIds,\n        contentRevision: state.contentRevision + 1,\n        updatedAt: Date.now(),\n      };\n    }),\n\n  finishRun: (error) =>\n    set((state) => {\n      // The turn is over — stop the live spinner. A step still 'running' didn't\n      // land this turn, so drop it back to 'pending' (a later prompt can pick it\n      // up). NEVER blanket-skip pending steps: in the incremental flow the later\n      // steps simply have not been asked for yet, and 'done' steps must stay done.\n      const steps = { ...state.steps };\n      for (const key of PREVIEW_STEPS) {\n        if (steps[key] === 'running') steps[key] = 'pending';\n      }\n      return {\n        isRunning: false,\n        error,\n        steps,\n        caption: '',\n        contentRevision: state.contentRevision + 1,\n        updatedAt: Date.now(),\n      };\n    }),\n\n  openPreview: () => set({ previewOpen: true }),\n  closePreview: () => set({ previewOpen: false }),\n  setRichMounted: (mounted) => set({ richMounted: mounted }),\n\n  bindWorkspace: (workspaceId) => {\n    const previous = get().workspaceId;\n    const actorId = workspaceId === null ? null : getActorId();\n    if (previous === workspaceId && get().actorId === actorId) return;\n    if (previous !== null && previous !== workspaceId) removePersistedRun(previous);\n    const restored = workspaceId === null ? null : readPersistedRun(workspaceId, actorId);\n    set({ ...idleRun(), ...restored, workspaceId, actorId });\n  },\n}));\n\n/**\n * Keep the page preview's slice for the bound workspace on every change to it.\n *\n * ★ A subscription rather than a write in each action: five actions change the\n * slice, and a write missed in any one of them would restore a stale preview.\n * `bindWorkspace` also lands here, which is harmless: it rewrites what it read.\n */\nuseAssistantRunStore.subscribe((state, previous) => {\n  if (state.workspaceId === null) return;\n  if (\n    state.workspaceId === previous.workspaceId &&\n    state.actorId === previous.actorId &&\n    state.hasRun === previous.hasRun &&\n    state.previewOpen === previous.previewOpen &&\n    state.steps === previous.steps &&\n    state.entityIds === previous.entityIds &&\n    state.updatedAt === previous.updatedAt\n  ) {\n    return;\n  }\n  if (!state.hasRun) {\n    removePersistedRun(state.workspaceId);\n    return;\n  }\n  const run: PersistedRun = {\n    hasRun: true,\n    ...(state.conversationId ? { conversationId: state.conversationId } : {}),\n    previewOpen: state.previewOpen,\n    steps: state.steps,\n    entityIds: state.entityIds,\n    updatedAt: state.updatedAt,\n  };\n  writePersistedRun(state.workspaceId, state.actorId, run);\n});\n"],"mappings":"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"}

package/dist/bigconsole/assistant/assistantRuntime.d.ts

@@ -49,3 +49,4 @@ export declare function resolveAssistantRuntime(params: {
     sandboxId: string;
     sessionId: string;
 }>;
+//# sourceMappingURL=assistantRuntime.d.ts.map

package/dist/bigconsole/assistant/assistantRuntime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assistantRuntime.d.ts","sourceRoot":"","sources":["../../../src/bigconsole/assistant/assistantRuntime.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,2BAA2B,EAAE,MAAM,SAAS,CAAC;AAE1E;;;;;;GAMG;AACH,eAAO,MAAM,wBAAwB,+BAA+B,CAAC;AACrE,eAAO,MAAM,wBAAwB,+BAA+B,CAAC;AACrE,eAAO,MAAM,6BAA6B,EAAE,SAAS,MAAM,EAA2D,CAAC;AAEvH,sFAAsF;AACtF,MAAM,WAAW,mBAAmB;IAClC,gCAAgC,EAAE,CAChC,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,aAAa,EACnB,WAAW,CAAC,EAAE,2BAA2B,KACtC,OAAO,CAAC,OAAO,CAAC,CAAC;IACtB,mBAAmB,EAAE,CACnB,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,aAAa,EACnB,WAAW,CAAC,EAAE,2BAA2B,KACtC,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IAC5B,sBAAsB,EAAE,CACtB,IAAI,EAAE,aAAa,EACnB,WAAW,EAAE,MAAM,EACnB,WAAW,CAAC,EAAE,2BAA2B,KACtC,OAAO,CAAC,MAAM,CAAC,CAAC;IACrB,mBAAmB,EAAE,CACnB,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,MAAM,EACnB,WAAW,CAAC,EAAE,2BAA2B,KACtC,OAAO,CAAC,IAAI,CAAC,CAAC;IACnB,4BAA4B,EAAE,CAC5B,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,aAAa,EACnB,WAAW,CAAC,EAAE,2BAA2B,KACtC,OAAO,CAAC,IAAI,CAAC,CAAC;IACnB,sBAAsB,EAAE,CACtB,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,aAAa,EACnB,WAAW,CAAC,EAAE,2BAA2B,KACtC,OAAO,CAAC;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACrC;AAED,sFAAsF;AACtF,MAAM,WAAW,qBAAqB;IACpC,YAAY,EAAE,MAAM,MAAM,GAAG,IAAI,CAAC;IAClC,YAAY,EAAE,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,CAAC;IAC1C,YAAY,EAAE,MAAM,MAAM,GAAG,IAAI,CAAC;IAClC,YAAY,EAAE,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,CAAC;IAC1C,qBAAqB,EAAE,MAAM,MAAM,GAAG,IAAI,CAAC;IAC3C,qBAAqB,EAAE,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,CAAC;CACrD;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,CAE/F;AAID,wBAAsB,uBAAuB,CAAC,MAAM,EAAE;IACpD,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,aAAa,CAAC;IACpB,WAAW,EAAE,2BAA2B,CAAC;IACzC,KAAK,EAAE,qBAAqB,CAAC;IAC7B,GAAG,EAAE,mBAAmB,CAAC;IACzB,cAAc,EAAE,MAAM,OAAO,CAAC;CAC/B,GAAG,OAAO,CAAC;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC,CAsEpD"}

package/dist/bigconsole/assistant/assistantRuntime.js

@@ -41,3 +41,5 @@ async function a(e) {
 }
 //#endregion
 export { e as ASSISTANT_SANDBOX_ID_KEY, t as ASSISTANT_SESSION_ID_KEY, n as LEGACY_ASSISTANT_RUNTIME_KEYS, a as resolveAssistantRuntime };
+
+//# sourceMappingURL=assistantRuntime.js.map

package/dist/bigconsole/assistant/assistantRuntime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"assistantRuntime.js","names":[],"sources":["../../../src/bigconsole/assistant/assistantRuntime.ts"],"sourcesContent":["/**\n * Resolves the sandbox + agent session a BigConsole assistant turn runs on.\n *\n * Kept out of the React hook so the adoption rules are testable without a DOM:\n * the hook supplies the storage-backed refs and the sandbox API, this decides\n * which sandbox may be driven.\n *\n * The rule (BOFF-7331): a sandbox is only driven once it has been proven to be\n * this user's BigConsole assistant sandbox in THIS page lifecycle — by being\n * created here, by passing `isReusableAssistantSandbox` in the active list, or,\n * for an id rehydrated from sessionStorage, by being fetched and passing the\n * same predicate. A cached id is never trusted on its own: it may have been\n * adopted by an older build that reused other products' and unstamped sandboxes.\n */\n\nimport type { AssistantMode, AssistantSandboxAuthContext } from './types';\n\n/**\n * sessionStorage keys for the warm sandbox + agent session. Versioned: the\n * unversioned keys were written by builds that adopted foreign and unstamped\n * sandboxes, so they are ignored (and cleared) rather than read. Re-validation\n * below is what actually guards adoption; the rename just means a pre-rollout\n * cache never even gets that far.\n */\nexport const ASSISTANT_SANDBOX_ID_KEY = 'bc-assistant-sandbox-id-v2';\nexport const ASSISTANT_SESSION_ID_KEY = 'bc-assistant-session-id-v2';\nexport const LEGACY_ASSISTANT_RUNTIME_KEYS: readonly string[] = ['bc-assistant-sandbox-id', 'bc-assistant-session-id'];\n\n/** The sandbox operations runtime resolution needs (the `assistantApi` functions). */\nexport interface AssistantRuntimeApi {\n  isCachedAssistantSandboxReusable: (\n    sandboxId: string,\n    workspaceId: string,\n    mode: AssistantMode,\n    authContext?: AssistantSandboxAuthContext\n  ) => Promise<boolean>;\n  findExistingSandbox: (\n    workspaceId: string,\n    mode: AssistantMode,\n    authContext?: AssistantSandboxAuthContext\n  ) => Promise<string | null>;\n  createAssistantSandbox: (\n    mode: AssistantMode,\n    workspaceId: string,\n    authContext?: AssistantSandboxAuthContext\n  ) => Promise<string>;\n  waitForSandboxReady: (\n    sandboxId: string,\n    workspaceId: string,\n    authContext?: AssistantSandboxAuthContext\n  ) => Promise<void>;\n  waitForAssistantServiceReady: (\n    sandboxId: string,\n    workspaceId: string,\n    mode: AssistantMode,\n    authContext?: AssistantSandboxAuthContext\n  ) => Promise<void>;\n  createAssistantSession: (\n    sandboxId: string,\n    workspaceId: string,\n    mode: AssistantMode,\n    authContext?: AssistantSandboxAuthContext\n  ) => Promise<{ sessionId: string }>;\n}\n\n/** The hook's refs. Setters persist to sessionStorage; `verified*` is memory only. */\nexport interface AssistantRuntimeStore {\n  getSandboxId: () => string | null;\n  setSandboxId: (id: string | null) => void;\n  getSessionId: () => string | null;\n  setSessionId: (id: string | null) => void;\n  getVerifiedSandboxKey: () => string | null;\n  setVerifiedSandboxKey: (key: string | null) => void;\n}\n\n/**\n * Identity of a proof that `sandboxId` may be driven by `userId`. Keyed on the\n * user too, so an identity change in the same tab re-validates. A missing user\n * id is part of the key rather than a reason to skip the key: a sandbox created\n * in this lifecycle before the id loaded must not be re-validated (it would fail\n * the fail-closed owner check) and replaced on every turn.\n */\nexport function verifiedSandboxKey(sandboxId: string, userId: string | null | undefined): string {\n  return JSON.stringify([sandboxId, userId ?? null]);\n}\n\nconst LOG_PREFIX = '[BigConsole-Assistant]';\n\nexport async function resolveAssistantRuntime(params: {\n  workspaceId: string;\n  mode: AssistantMode;\n  authContext: AssistantSandboxAuthContext;\n  store: AssistantRuntimeStore;\n  api: AssistantRuntimeApi;\n  hasAccessToken: () => boolean;\n}): Promise<{ sandboxId: string; sessionId: string }> {\n  const { workspaceId, mode, authContext, store, api } = params;\n\n  let sandboxId = store.getSandboxId();\n  console.log(`${LOG_PREFIX} ensureRuntime start`, { sandboxId, workspaceId });\n\n  if (sandboxId && store.getVerifiedSandboxKey() !== verifiedSandboxKey(sandboxId, authContext.userId)) {\n    let reusable = false;\n    try {\n      reusable = await api.isCachedAssistantSandboxReusable(sandboxId, workspaceId, mode, authContext);\n    } catch (error) {\n      // Fail closed: an unverifiable sandbox is not driven.\n      console.warn(`${LOG_PREFIX} could not re-validate cached sandbox`, {\n        sandboxId,\n        error: error instanceof Error ? error.message : String(error),\n      });\n    }\n    if (reusable) {\n      store.setVerifiedSandboxKey(verifiedSandboxKey(sandboxId, authContext.userId));\n    } else {\n      console.warn(`${LOG_PREFIX} cached sandbox is not reusable, discarding it`, { sandboxId });\n      // The session lives inside that sandbox, so it goes with it.\n      store.setSandboxId(null);\n      store.setSessionId(null);\n      store.setVerifiedSandboxKey(null);\n      sandboxId = null;\n    }\n  }\n\n  if (!sandboxId) {\n    if (!params.hasAccessToken()) {\n      throw new Error('The assistant requires an authenticated session. Please sign in again.');\n    }\n    sandboxId = await api.findExistingSandbox(workspaceId, mode, authContext);\n    console.log(`${LOG_PREFIX} findExistingSandbox result`, { sandboxId });\n\n    if (sandboxId) {\n      try {\n        await api.waitForSandboxReady(sandboxId, workspaceId, authContext);\n        await api.waitForAssistantServiceReady(sandboxId, workspaceId, mode, authContext);\n      } catch (error) {\n        console.warn(`${LOG_PREFIX} existing sandbox unusable, falling back to fresh sandbox`, {\n          sandboxId,\n          error: error instanceof Error ? error.message : String(error),\n        });\n        sandboxId = null;\n      }\n    }\n\n    if (!sandboxId) {\n      sandboxId = await api.createAssistantSandbox(mode, workspaceId, authContext);\n      console.log(`${LOG_PREFIX} createAssistantSandbox result`, { sandboxId });\n      await api.waitForSandboxReady(sandboxId, workspaceId, authContext);\n      await api.waitForAssistantServiceReady(sandboxId, workspaceId, mode, authContext);\n    }\n\n    store.setSandboxId(sandboxId);\n    store.setVerifiedSandboxKey(verifiedSandboxKey(sandboxId, authContext.userId));\n    // Any session id held now belonged to a sandbox we no longer have.\n    store.setSessionId(null);\n  }\n\n  let sessionId = store.getSessionId();\n  if (!sessionId) {\n    const result = await api.createAssistantSession(sandboxId, workspaceId, mode, authContext);\n    sessionId = result.sessionId;\n    store.setSessionId(sessionId);\n  }\n\n  return { sandboxId, sessionId };\n}\n"],"mappings":";AAwBA,IAAa,IAA2B,8BAC3B,IAA2B,8BAC3B,IAAmD,CAAC,2BAA2B,0BAA0B;AAwDtH,SAAgB,EAAmB,GAAmB,GAA2C;AAC/F,QAAO,KAAK,UAAU,CAAC,GAAW,KAAU,KAAK,CAAC;;AAGpD,IAAM,IAAa;AAEnB,eAAsB,EAAwB,GAOQ;CACpD,IAAM,EAAE,gBAAa,SAAM,gBAAa,UAAO,WAAQ,GAEnD,IAAY,EAAM,cAAc;AAGpC,KAFA,QAAQ,IAAI,GAAG,EAAW,uBAAuB;EAAE;EAAW;EAAa,CAAC,EAExE,KAAa,EAAM,uBAAuB,KAAK,EAAmB,GAAW,EAAY,OAAO,EAAE;EACpG,IAAI,IAAW;AACf,MAAI;AACF,OAAW,MAAM,EAAI,iCAAiC,GAAW,GAAa,GAAM,EAAY;WACzF,GAAO;AAEd,WAAQ,KAAK,GAAG,EAAW,wCAAwC;IACjE;IACA,OAAO,aAAiB,QAAQ,EAAM,UAAU,OAAO,EAAM;IAC9D,CAAC;;AAEJ,EAAI,IACF,EAAM,sBAAsB,EAAmB,GAAW,EAAY,OAAO,CAAC,IAE9E,QAAQ,KAAK,GAAG,EAAW,iDAAiD,EAAE,cAAW,CAAC,EAE1F,EAAM,aAAa,KAAK,EACxB,EAAM,aAAa,KAAK,EACxB,EAAM,sBAAsB,KAAK,EACjC,IAAY;;AAIhB,KAAI,CAAC,GAAW;AACd,MAAI,CAAC,EAAO,gBAAgB,CAC1B,OAAU,MAAM,yEAAyE;AAK3F,MAHA,IAAY,MAAM,EAAI,oBAAoB,GAAa,GAAM,EAAY,EACzE,QAAQ,IAAI,GAAG,EAAW,8BAA8B,EAAE,cAAW,CAAC,EAElE,EACF,KAAI;AAEF,GADA,MAAM,EAAI,oBAAoB,GAAW,GAAa,EAAY,EAClE,MAAM,EAAI,6BAA6B,GAAW,GAAa,GAAM,EAAY;WAC1E,GAAO;AAKd,GAJA,QAAQ,KAAK,GAAG,EAAW,4DAA4D;IACrF;IACA,OAAO,aAAiB,QAAQ,EAAM,UAAU,OAAO,EAAM;IAC9D,CAAC,EACF,IAAY;;AAchB,EAVK,MACH,IAAY,MAAM,EAAI,uBAAuB,GAAM,GAAa,EAAY,EAC5E,QAAQ,IAAI,GAAG,EAAW,iCAAiC,EAAE,cAAW,CAAC,EACzE,MAAM,EAAI,oBAAoB,GAAW,GAAa,EAAY,EAClE,MAAM,EAAI,6BAA6B,GAAW,GAAa,GAAM,EAAY,GAGnF,EAAM,aAAa,EAAU,EAC7B,EAAM,sBAAsB,EAAmB,GAAW,EAAY,OAAO,CAAC,EAE9E,EAAM,aAAa,KAAK;;CAG1B,IAAI,IAAY,EAAM,cAAc;AAOpC,QANK,MAEH,KADe,MAAM,EAAI,uBAAuB,GAAW,GAAa,GAAM,EAAY,EACvE,WACnB,EAAM,aAAa,EAAU,GAGxB;EAAE;EAAW;EAAW"}

package/dist/bigconsole/assistant/attachmentExtract.d.ts

@@ -46,3 +46,4 @@ export declare const MAX_ROWS = 200;
  * (e.g. a scanned PDF) produce a short note rather than aborting the send.
  */
 export declare function buildAttachmentBlock(files: File[]): Promise<string>;
+//# sourceMappingURL=attachmentExtract.d.ts.map

package/dist/bigconsole/assistant/attachmentExtract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attachmentExtract.d.ts","sourceRoot":"","sources":["../../../src/bigconsole/assistant/attachmentExtract.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,yBAAyB,SAAU,CAAC;AAEjD;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,MAAM,CAAC;AAuE5B;;;;GAIG;AACH,wBAAsB,oBAAoB,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAqBzE"}

package/dist/bigconsole/assistant/attachmentExtract.js

@@ -46,3 +46,5 @@ async function i(t) {
 }
 //#endregion
 export { i as buildAttachmentBlock };
+
+//# sourceMappingURL=attachmentExtract.js.map

package/dist/bigconsole/assistant/attachmentExtract.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"attachmentExtract.js","names":[],"sources":["../../../src/bigconsole/assistant/attachmentExtract.ts"],"sourcesContent":["/**\n * Client-side extraction of an uploaded data file into a capped text/rows\n * preview that gets folded into the assistant prompt.\n *\n * Lives in the BigConsole product layer (not fe-libs) because it pulls in the\n * xlsx / pdfjs parsers — fe-libs stays parsing-free and only carries the raw\n * `File`s through `AssistantSendArgs.attachments`. Heavy parsers are loaded via\n * dynamic `import()` so they code-split and only download when a file is\n * actually attached.\n *\n * The agent receives a CAPPED preview — enough to design a DataSink schema from,\n * not the whole file — because the payload rides the `proxySandboxRequest`\n * gateway call (bounded execution budget) and the model has a context limit.\n */\n\n/**\n * Characters of ONE file's text this widget folds into the prompt: ~100 KB.\n *\n * ★★ A CEILING THAT ALMOST NEVER BINDS, and exported so the seam can say so\n * out loud. `MAX_ROWS` is applied FIRST and wins for anything row-oriented: a\n * 200-row slice of a CSV is a few KB, so what this widget has actually been\n * sending is nowhere near 100,000 characters. Only a file with very long lines\n * — one-line JSON, a wide log — ever reaches this number.\n *\n * ★★ So `modes.ts` DELIBERATELY DOES NOT MATCH IT. The shared panel has no row\n * cap, and fe-libs spends a turn's inline budget greedily in attachment order,\n * so asking for 100,000 a file there would let two files eat the whole turn and\n * drop the third (BOFF-7532). `Build` asks for 15,155 instead — derived from\n * the BYTE envelope fe-libs enforces, not from this ceiling — which still\n * delivers MORE rows of a CSV than `MAX_ROWS` below.\n * `tests/assistantSeam.test.ts` guards that direction in rows actually served,\n * measured against the installed fe-libs; when this legacy transport goes,\n * delete the guard with it.\n */\nexport const MAX_INLINE_CHARS_PER_FILE = 100_000;\n\n/**\n * Rows of ONE row-oriented file this widget folds into the prompt.\n *\n * ★★ THE CAP THAT ACTUALLY BOUND, which is why it is exported: it, not\n * `MAX_INLINE_CHARS_PER_FILE`, is what the seam's parity guard compares\n * against. 200 rows of a CSV is a few KB, nowhere near 100,000 characters.\n */\nexport const MAX_ROWS = 200;\n\nfunction isTextLike(file: File): boolean {\n  const name = file.name.toLowerCase();\n  return (\n    name.endsWith('.json') ||\n    name.endsWith('.csv') ||\n    name.endsWith('.txt') ||\n    file.type === 'application/json' ||\n    file.type === 'text/csv' ||\n    file.type.startsWith('text/')\n  );\n}\n\nasync function extractOne(file: File): Promise<string> {\n  const name = file.name.toLowerCase();\n\n  // JSON / CSV / plain text — native, no deps.\n  if (isTextLike(file)) {\n    return await file.text();\n  }\n\n  // Excel — SheetJS, dynamically imported. First sheet → CSV (compact + agent-friendly).\n  if (name.endsWith('.xlsx') || name.endsWith('.xls')) {\n    const XLSX = await import('@e965/xlsx');\n    const buf = await file.arrayBuffer();\n    const wb = XLSX.read(buf, { type: 'array' });\n    const first = wb.SheetNames[0];\n    if (!first) return '';\n    return XLSX.utils.sheet_to_csv(wb.Sheets[first]);\n  }\n\n  // PDF — best-effort text-layer extraction via pdfjs (dynamically imported).\n  // Unreliable for tabular data and useless for scanned PDFs; the caller shows a\n  // graceful note if this throws. NOTE: pdfjs worker setup is Vite-specific and\n  // must be verified against a running build.\n  if (name.endsWith('.pdf') || file.type === 'application/pdf') {\n    const pdfjs = await import('pdfjs-dist');\n    const buf = await file.arrayBuffer();\n    const doc = await pdfjs.getDocument({ data: new Uint8Array(buf) }).promise;\n    const parts: string[] = [];\n    const pages = Math.min(doc.numPages, 20);\n    for (let page = 1; page <= pages; page += 1) {\n      const content = await (await doc.getPage(page)).getTextContent();\n      parts.push(content.items.map((item) => ('str' in item ? item.str : '')).join(' '));\n    }\n    return parts.join('\\n');\n  }\n\n  // Unknown extension → best-effort text.\n  return await file.text();\n}\n\n/** Keep the first MAX_ROWS lines / MAX_INLINE_CHARS_PER_FILE chars so a huge\n *  file can't blow the prompt. Returns whether anything was dropped so the\n *  agent knows it's a sample. */\nfunction limit(text: string): { text: string; truncated: boolean } {\n  let out = text;\n  let truncated = false;\n  const lines = out.split(/\\r?\\n/);\n  if (lines.length > MAX_ROWS) {\n    out = lines.slice(0, MAX_ROWS).join('\\n');\n    truncated = true;\n  }\n  if (out.length > MAX_INLINE_CHARS_PER_FILE) {\n    out = out.slice(0, MAX_INLINE_CHARS_PER_FILE);\n    truncated = true;\n  }\n  return { text: out, truncated };\n}\n\n/**\n * Extract every attachment and format them as fenced \"Attached data source\"\n * blocks the agent can read and turn into a DataSink. Files that fail to parse\n * (e.g. a scanned PDF) produce a short note rather than aborting the send.\n */\nexport async function buildAttachmentBlock(files: File[]): Promise<string> {\n  const blocks: string[] = [];\n  for (const file of files) {\n    let raw: string;\n    try {\n      raw = await extractOne(file);\n    } catch (err) {\n      const reason = err instanceof Error ? err.message : 'unknown error';\n      blocks.push(\n        `--- Attached file \"${file.name}\" could not be auto-read (${reason}). ` +\n          `Please paste its rows here instead. ---`\n      );\n      continue;\n    }\n    const { text, truncated } = limit(raw.trim());\n    const note = truncated\n      ? ` (sample — first ${MAX_ROWS} rows / ~${Math.round(MAX_INLINE_CHARS_PER_FILE / 1000)}KB)`\n      : '';\n    blocks.push(`--- Attached data source: ${file.name}${note} ---\\n${text}\\n--- end ${file.name} ---`);\n  }\n  return blocks.join('\\n\\n');\n}\n"],"mappings":";AAkCA,IAAa,IAA4B;AAWzC,SAAS,EAAW,GAAqB;CACvC,IAAM,IAAO,EAAK,KAAK,aAAa;AACpC,QACE,EAAK,SAAS,QAAQ,IACtB,EAAK,SAAS,OAAO,IACrB,EAAK,SAAS,OAAO,IACrB,EAAK,SAAS,sBACd,EAAK,SAAS,cACd,EAAK,KAAK,WAAW,QAAQ;;AAIjC,eAAe,EAAW,GAA6B;CACrD,IAAM,IAAO,EAAK,KAAK,aAAa;AAGpC,KAAI,EAAW,EAAK,CAClB,QAAO,MAAM,EAAK,MAAM;AAI1B,KAAI,EAAK,SAAS,QAAQ,IAAI,EAAK,SAAS,OAAO,EAAE;EACnD,IAAM,IAAO,MAAM,OAAO,0CACpB,IAAM,MAAM,EAAK,aAAa,EAC9B,IAAK,EAAK,KAAK,GAAK,EAAE,MAAM,SAAS,CAAC,EACtC,IAAQ,EAAG,WAAW;AAE5B,SADK,IACE,EAAK,MAAM,aAAa,EAAG,OAAO,GAAO,GAD7B;;AAQrB,KAAI,EAAK,SAAS,OAAO,IAAI,EAAK,SAAS,mBAAmB;EAC5D,IAAM,IAAQ,MAAM,OAAO,+CACrB,IAAM,MAAM,EAAK,aAAa,EAC9B,IAAM,MAAM,EAAM,YAAY,EAAE,MAAM,IAAI,WAAW,EAAI,EAAE,CAAC,CAAC,SAC7D,IAAkB,EAAE,EACpB,IAAQ,KAAK,IAAI,EAAI,UAAU,GAAG;AACxC,OAAK,IAAI,IAAO,GAAG,KAAQ,GAAO,KAAQ,GAAG;GAC3C,IAAM,IAAU,OAAO,MAAM,EAAI,QAAQ,EAAK,EAAE,gBAAgB;AAChE,KAAM,KAAK,EAAQ,MAAM,KAAK,MAAU,SAAS,IAAO,EAAK,MAAM,GAAI,CAAC,KAAK,IAAI,CAAC;;AAEpF,SAAO,EAAM,KAAK,KAAK;;AAIzB,QAAO,MAAM,EAAK,MAAM;;AAM1B,SAAS,EAAM,GAAoD;CACjE,IAAI,IAAM,GACN,IAAY,IACV,IAAQ,EAAI,MAAM,QAAQ;AAShC,QARI,EAAM,SAAA,QACR,IAAM,EAAM,MAAM,GAAA,IAAY,CAAC,KAAK,KAAK,EACzC,IAAY,KAEV,EAAI,SAAA,QACN,IAAM,EAAI,MAAM,GAAG,EAA0B,EAC7C,IAAY,KAEP;EAAE,MAAM;EAAK;EAAW;;AAQjC,eAAsB,EAAqB,GAAgC;CACzE,IAAM,IAAmB,EAAE;AAC3B,MAAK,IAAM,KAAQ,GAAO;EACxB,IAAI;AACJ,MAAI;AACF,OAAM,MAAM,EAAW,EAAK;WACrB,GAAK;GACZ,IAAM,IAAS,aAAe,QAAQ,EAAI,UAAU;AACpD,KAAO,KACL,sBAAsB,EAAK,KAAK,4BAA4B,EAAO,4CAEpE;AACD;;EAEF,IAAM,EAAE,SAAM,iBAAc,EAAM,EAAI,MAAM,CAAC,EACvC,IAAO,IACT,gCAAwC,KAAK,MAAM,IAA4B,IAAK,CAAC,OACrF;AACJ,IAAO,KAAK,6BAA6B,EAAK,OAAO,EAAK,QAAQ,EAAK,YAAY,EAAK,KAAK,MAAM;;AAErG,QAAO,EAAO,KAAK,OAAO"}

package/dist/bigconsole/assistant/conversationHistoryApi.d.ts

@@ -35,3 +35,4 @@ export declare function saveAssistantTurn(params: {
     agentSessionId: string | null;
 }, workspaceId: string, authContext?: AssistantSandboxAuthContext): Promise<AssistantConversationSummary>;
 export declare function deleteAssistantConversation(conversationId: string, workspaceId: string, authContext?: AssistantSandboxAuthContext): Promise<void>;
+//# sourceMappingURL=conversationHistoryApi.d.ts.map

package/dist/bigconsole/assistant/conversationHistoryApi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conversationHistoryApi.d.ts","sourceRoot":"","sources":["../../../src/bigconsole/assistant/conversationHistoryApi.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAKH,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,SAAS,CAAC;AAE3D;;;;;;;;GAQG;AACH,eAAO,MAAM,oBAAoB,eAAqB,CAAC;AAEvD,MAAM,WAAW,4BAA4B;IAC3C,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,2BAA2B;IAC1C,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,GAAG,WAAW,CAAC;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;CACnB;AAsED,wBAAsB,0BAA0B,CAC9C,WAAW,EAAE,MAAM,EACnB,WAAW,CAAC,EAAE,2BAA2B,EACzC,KAAK,SAAK,GACT,OAAO,CAAC,4BAA4B,EAAE,CAAC,CASzC;AAED,wBAAsB,gCAAgC,CACpD,cAAc,EAAE,MAAM,EACtB,WAAW,EAAE,MAAM,EACnB,WAAW,CAAC,EAAE,2BAA2B,EACzC,KAAK,SAAM,GACV,OAAO,CAAC,2BAA2B,EAAE,CAAC,CAWxC;AAED;;;GAGG;AACH,wBAAsB,iBAAiB,CACrC,MAAM,EAAE;IACN,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B,EACD,WAAW,EAAE,MAAM,EACnB,WAAW,CAAC,EAAE,2BAA2B,GACxC,OAAO,CAAC,4BAA4B,CAAC,CAiBvC;AAED,wBAAsB,2BAA2B,CAC/C,cAAc,EAAE,MAAM,EACtB,WAAW,EAAE,MAAM,EACnB,WAAW,CAAC,EAAE,2BAA2B,GACxC,OAAO,CAAC,IAAI,CAAC,CAQf"}

package/dist/bigconsole/assistant/conversationHistoryApi.js

@@ -76,3 +76,5 @@ async function f(e, t, n) {
 }
 //#endregion
 export { f as deleteAssistantConversation, u as getAssistantConversationMessages, l as listAssistantConversations, d as saveAssistantTurn };
+
+//# sourceMappingURL=conversationHistoryApi.js.map

package/dist/bigconsole/assistant/conversationHistoryApi.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"conversationHistoryApi.js","names":[],"sources":["../../../src/bigconsole/assistant/conversationHistoryApi.ts"],"sourcesContent":["/**\n * Durable assistant history, stored in wspace-conversations.\n *\n * The agent's own session lives in a sandbox with a 10-minute TTL and no\n * persistent volume, so it cannot be the store of record for a transcript the\n * user expects to keep. Every completed turn is written here instead, tagged\n * with the product that owns it, so history is durable AND product-scoped —\n * a BigConsole chat can never appear in another product's panel.\n *\n * Raw operation strings rather than generated documents: these ops are only used\n * here, and `graphqlFetch` takes a query string, so there is nothing to gain\n * from putting them through codegen.\n */\n\nimport { graphqlFetch } from '@burdenoff/fe-libs/shared/graphql';\n\nimport { BIGCONSOLE_PRODUCT } from './product';\nimport type { AssistantSandboxAuthContext } from './types';\n\n/**\n * Every conversation written from here belongs to BigConsole.\n *\n * ★ Same value as `assistantApi`'s `ASSISTANT_PRODUCT`, and now literally the\n * same source. These were two independent string literals under two different\n * names — history rows are tagged with this one while sandboxes are stamped with\n * that one, so a divergence would have hidden a product's whole transcript from\n * its own panel without failing anything.\n */\nexport const ASSISTANT_PRODUCT_ID = BIGCONSOLE_PRODUCT;\n\nexport interface AssistantConversationSummary {\n  id: string;\n  title: string | null;\n  agentSessionId: string | null;\n  updatedAt: string;\n}\n\nexport interface AssistantHistoryTurnMessage {\n  id: string;\n  role: 'USER' | 'ASSISTANT';\n  content: string;\n  createdAt: string;\n}\n\nconst CONVERSATION_FIELDS = `\n  id\n  title\n  agentSessionId\n  updatedAt\n`;\n\nconst LIST_CONVERSATIONS = `\n  query AssistantConversations($productId: String!, $first: Int) {\n    assistantConversations(productId: $productId, first: $first) { ${CONVERSATION_FIELDS} }\n  }\n`;\n\nconst CONVERSATION_MESSAGES = `\n  query AssistantConversationMessages($conversationId: ID!, $first: Int) {\n    assistantConversationMessages(conversationId: $conversationId, first: $first) {\n      id\n      role\n      content\n      createdAt\n    }\n  }\n`;\n\nconst SAVE_TURN = `\n  mutation SaveAssistantTurn($input: SaveAssistantTurnInput!) {\n    saveAssistantTurn(input: $input) { ${CONVERSATION_FIELDS} }\n  }\n`;\n\nconst DELETE_CONVERSATION = `\n  mutation DeleteAssistantConversation($conversationId: ID!) {\n    deleteAssistantConversation(conversationId: $conversationId)\n  }\n`;\n\nasync function historyFetch<TData>(params: {\n  query: string;\n  operationName: string;\n  variables: Record<string, unknown>;\n  workspaceId: string;\n  authContext?: AssistantSandboxAuthContext;\n}): Promise<TData> {\n  const result = await graphqlFetch<TData>({\n    gateway: 'workspace',\n    query: params.query,\n    operationName: params.operationName,\n    variables: params.variables,\n    authToken: params.authContext?.accessToken ?? undefined,\n    // Mint the workspace token rather than passing a possibly-stale string —\n    // same reasoning as assistantApi: a stale token is nulled out and NOT\n    // replaced unless the caller opts in here.\n    workspaceToken: true,\n    workspaceId: params.workspaceId,\n    organizationId: params.authContext?.organizationId ?? true,\n    suppressGlobalErrorEvent: true,\n  });\n\n  if (result.errors?.length) {\n    throw new Error(result.errors.map((error) => error.message).join(', '));\n  }\n  if (!result.data) {\n    throw new Error(`${params.operationName} returned no data`);\n  }\n\n  return result.data;\n}\n\nexport async function listAssistantConversations(\n  workspaceId: string,\n  authContext?: AssistantSandboxAuthContext,\n  first = 25\n): Promise<AssistantConversationSummary[]> {\n  const data = await historyFetch<{ assistantConversations: AssistantConversationSummary[] }>({\n    query: LIST_CONVERSATIONS,\n    operationName: 'AssistantConversations',\n    variables: { productId: ASSISTANT_PRODUCT_ID, first },\n    workspaceId,\n    authContext,\n  });\n  return data.assistantConversations ?? [];\n}\n\nexport async function getAssistantConversationMessages(\n  conversationId: string,\n  workspaceId: string,\n  authContext?: AssistantSandboxAuthContext,\n  first = 200\n): Promise<AssistantHistoryTurnMessage[]> {\n  const data = await historyFetch<{\n    assistantConversationMessages: AssistantHistoryTurnMessage[];\n  }>({\n    query: CONVERSATION_MESSAGES,\n    operationName: 'AssistantConversationMessages',\n    variables: { conversationId, first },\n    workspaceId,\n    authContext,\n  });\n  return data.assistantConversationMessages ?? [];\n}\n\n/**\n * Persist one completed turn. Creates the conversation on the first turn and\n * returns it, so the caller can hold on to the id.\n */\nexport async function saveAssistantTurn(\n  params: {\n    conversationId: string | null;\n    prompt: string;\n    reply: string;\n    agentSessionId: string | null;\n  },\n  workspaceId: string,\n  authContext?: AssistantSandboxAuthContext\n): Promise<AssistantConversationSummary> {\n  const data = await historyFetch<{ saveAssistantTurn: AssistantConversationSummary }>({\n    query: SAVE_TURN,\n    operationName: 'SaveAssistantTurn',\n    variables: {\n      input: {\n        conversationId: params.conversationId,\n        productId: ASSISTANT_PRODUCT_ID,\n        prompt: params.prompt,\n        reply: params.reply,\n        agentSessionId: params.agentSessionId,\n      },\n    },\n    workspaceId,\n    authContext,\n  });\n  return data.saveAssistantTurn;\n}\n\nexport async function deleteAssistantConversation(\n  conversationId: string,\n  workspaceId: string,\n  authContext?: AssistantSandboxAuthContext\n): Promise<void> {\n  await historyFetch<{ deleteAssistantConversation: boolean }>({\n    query: DELETE_CONVERSATION,\n    operationName: 'DeleteAssistantConversation',\n    variables: { conversationId },\n    workspaceId,\n    authContext,\n  });\n}\n"],"mappings":";;;AA4BA,IAAa,IAAuB,GAgB9B,IAAsB,oDAOtB,IAAqB;;qEAE0C,EAAoB;;GAInF,IAAwB,yOAWxB,IAAY;;yCAEuB,EAAoB;;GAIvD,IAAsB;AAM5B,eAAe,EAAoB,GAMhB;CACjB,IAAM,IAAS,MAAM,EAAoB;EACvC,SAAS;EACT,OAAO,EAAO;EACd,eAAe,EAAO;EACtB,WAAW,EAAO;EAClB,WAAW,EAAO,aAAa,eAAe,KAAA;EAI9C,gBAAgB;EAChB,aAAa,EAAO;EACpB,gBAAgB,EAAO,aAAa,kBAAkB;EACtD,0BAA0B;EAC3B,CAAC;AAEF,KAAI,EAAO,QAAQ,OACjB,OAAU,MAAM,EAAO,OAAO,KAAK,MAAU,EAAM,QAAQ,CAAC,KAAK,KAAK,CAAC;AAEzE,KAAI,CAAC,EAAO,KACV,OAAU,MAAM,GAAG,EAAO,cAAc,mBAAmB;AAG7D,QAAO,EAAO;;AAGhB,eAAsB,EACpB,GACA,GACA,IAAQ,IACiC;AAQzC,SAPa,MAAM,EAAyE;EAC1F,OAAO;EACP,eAAe;EACf,WAAW;GAAE,WAAW;GAAsB;GAAO;EACrD;EACA;EACD,CAAC,EACU,0BAA0B,EAAE;;AAG1C,eAAsB,EACpB,GACA,GACA,GACA,IAAQ,KACgC;AAUxC,SATa,MAAM,EAEhB;EACD,OAAO;EACP,eAAe;EACf,WAAW;GAAE;GAAgB;GAAO;EACpC;EACA;EACD,CAAC,EACU,iCAAiC,EAAE;;AAOjD,eAAsB,EACpB,GAMA,GACA,GACuC;AAgBvC,SAfa,MAAM,EAAkE;EACnF,OAAO;EACP,eAAe;EACf,WAAW,EACT,OAAO;GACL,gBAAgB,EAAO;GACvB,WAAW;GACX,QAAQ,EAAO;GACf,OAAO,EAAO;GACd,gBAAgB,EAAO;GACxB,EACF;EACD;EACA;EACD,CAAC,EACU;;AAGd,eAAsB,EACpB,GACA,GACA,GACe;AACf,OAAM,EAAuD;EAC3D,OAAO;EACP,eAAe;EACf,WAAW,EAAE,mBAAgB;EAC7B;EACA;EACD,CAAC"}

package/dist/bigconsole/assistant/createSandboxAssistantTransport.d.ts

@@ -64,3 +64,4 @@ export interface AssistantTransport {
  */
 export declare function useSandboxAssistantTransport(): AssistantTransport;
 export {};
+//# sourceMappingURL=createSandboxAssistantTransport.d.ts.map

package/dist/bigconsole/assistant/createSandboxAssistantTransport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createSandboxAssistantTransport.d.ts","sourceRoot":"","sources":["../../../src/bigconsole/assistant/createSandboxAssistantTransport.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAmCH;;;;;;;;;GASG;AACH,UAAU,iBAAiB;IACzB,MAAM,EAAE,MAAM,CAAC;IACf;kFAC8E;IAC9E,WAAW,CAAC,EAAE,IAAI,EAAE,CAAC;IACrB,UAAU,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,IAAI,CAAC;IAC1C,MAAM,EAAE,WAAW,CAAC;CACrB;AAED,2EAA2E;AAC3E,UAAU,uBAAuB;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,GAAG,WAAW,CAAC;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,4EAA4E;AAC5E,UAAU,4BAA4B;IACpC,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,kBAAkB;IACjC,UAAU,EAAE,CAAC,IAAI,EAAE,iBAAiB,KAAK,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACnE,WAAW,EAAE,MAAM,OAAO,CAAC,uBAAuB,EAAE,CAAC,CAAC;IACtD,YAAY,EAAE,MAAM,OAAO,CAAC,4BAA4B,EAAE,CAAC,CAAC;IAC5D,UAAU,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAChC,aAAa,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACpD,aAAa,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,uBAAuB,EAAE,CAAC,CAAC;CAC1E;AAuVD;;;;GAIG;AACH,wBAAgB,4BAA4B,IAAI,kBAAkB,CAudjE"}

package/dist/bigconsole/assistant/createSandboxAssistantTransport.js

@@ -384,3 +384,5 @@ function V() {
 }
 //#endregion
 export { V as useSandboxAssistantTransport };
+
+//# sourceMappingURL=createSandboxAssistantTransport.js.map

package/dist/bigconsole/assistant/createSandboxAssistantTransport.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createSandboxAssistantTransport.js","names":[],"sources":["../../../src/bigconsole/assistant/createSandboxAssistantTransport.ts"],"sourcesContent":["/**\n * BigConsole adapter for the shared fe-libs AssistantWidget.\n *\n * The floating widget (fe-libs, Layer 1) is backend-agnostic — it calls an\n * injected `AssistantTransport`. This hook builds a transport that drives the\n * sandbox AI assistant (combined `assistant` mode = docs Q&A + api-calls): it\n * provisions/reuses a sandbox, opens a session, dispatches the prompt async,\n * then polls for the streamed answer. The agent introspects the GraphQL schema\n * and performs API calls on the user's behalf using their workspace token,\n * contextual to the current screen (via `gatherPageContext`).\n *\n * This is a faithful port of microfe-vibecontrols'\n * `services/createSandboxAssistantTransport.ts`; the only product-specific\n * difference lives in `assistantApi.createAssistantSandbox`\n * (`AI_ASSISTANT_PRODUCT=bigconsole`).\n */\n\nimport { useCallback, useMemo, useRef } from 'react';\nimport { useAuthToken } from '@burdenoff/fe-libs/shared/providers/shell';\nimport {\n  createAssistantSandbox,\n  createAssistantSession,\n  extendAssistantSandboxTTL,\n  findExistingSandbox,\n  getAssistantMessages,\n  isCachedAssistantSandboxReusable,\n  sendAssistantPromptAsync,\n  waitForAssistantServiceReady,\n  waitForSandboxReady,\n} from './assistantApi';\nimport {\n  ASSISTANT_SANDBOX_ID_KEY,\n  ASSISTANT_SESSION_ID_KEY,\n  type AssistantRuntimeApi,\n  LEGACY_ASSISTANT_RUNTIME_KEYS,\n  resolveAssistantRuntime,\n} from './assistantRuntime';\nimport { buildAttachmentBlock } from './attachmentExtract';\nimport { useAssistantRunStore } from './assistantRunStore';\nimport {\n  type AssistantConversationSummary,\n  type AssistantHistoryTurnMessage,\n  deleteAssistantConversation,\n  getAssistantConversationMessages,\n  listAssistantConversations,\n  saveAssistantTurn,\n} from './conversationHistoryApi';\nimport { gatherPageContext } from './pageContext';\nimport type { AssistantMode, AssistantRawMessage, AssistantRawMessagePart, AssistantSandboxAuthContext } from './types';\n\n/**\n * Locally-defined mirror of the fe-libs `AssistantTransport` contract.\n *\n * Intentionally NOT imported from `@burdenoff/fe-libs`: microfe's tsconfig maps\n * `@burdenoff/fe-libs/*` to fe-libs *source*, so vite-plugin-dts would rewrite a\n * cross-package type used in this hook's public signature to a broken\n * source-relative path in the emitted `.d.ts`. Structural typing makes this\n * shape assignable to fe-libs' `AssistantTransport` at the call site\n * (bigconsole-app's AppShell), which is where compatibility is enforced.\n */\ninterface AssistantSendArgs {\n  prompt: string;\n  /** Files attached via the widget's upload button (fe-libs carries the raw\n   *  File[]; we extract + fold a capped preview into the agent prompt here). */\n  attachments?: File[];\n  onProgress: (partialText: string) => void;\n  signal: AbortSignal;\n}\n\n/** Mirror of fe-libs' `AssistantWidgetMessage` (see note above on why). */\ninterface AssistantHistoryMessage {\n  id: string;\n  role: 'user' | 'assistant';\n  content: string;\n  pending?: boolean;\n  error?: boolean;\n}\n\n/** Mirror of fe-libs' `AssistantSessionSummary` (see note above on why). */\ninterface AssistantSessionSummaryLocal {\n  id: string;\n  title: string;\n  updatedAt?: number;\n  active?: boolean;\n}\n\nexport interface AssistantTransport {\n  sendPrompt: (args: AssistantSendArgs) => Promise<{ text: string }>;\n  loadHistory: () => Promise<AssistantHistoryMessage[]>;\n  listSessions: () => Promise<AssistantSessionSummaryLocal[]>;\n  newSession: () => Promise<void>;\n  deleteSession: (sessionId: string) => Promise<void>;\n  selectSession: (sessionId: string) => Promise<AssistantHistoryMessage[]>;\n}\n\n// BigConsole still boots the manually-tagged ACA image\n// `alpha-delegated-auth-v11` for the assistant sandbox. The historical\n// platform notes show that this image line reliably supports `api-calls`, while\n// the combined `assistant` mode depends on newer image contracts that are not\n// yet guaranteed on this tag. Use `api-calls` here so the assistant can execute\n// workspace GraphQL operations end-to-end right now. Once the underlying image\n// line is rebuilt and verified for combined mode, this can be switched back.\nconst MODE: AssistantMode = 'api-calls';\n// How long the UI will follow a single turn.\n//\n// This was 180s, which was SHORTER THAN THE WORK. A full \"create a school\n// attendance dashboard\" build — datasink → dashboard → parser → widget, each a\n// separate gateway call preceded by a model round-trip — measured 229s in prod.\n// So the agent finished, the dashboard genuinely existed, and the user was still\n// shown \"the assistant timed out\". That is worse than cosmetic: people retry and\n// end up with duplicate dashboards.\n//\n// 7 minutes covers the observed worst case with headroom. It costs nothing on\n// fast turns (we stop the moment the turn reports done), and the backend keeps\n// pace — the sandbox TTL is extended every TTL_EXTEND_INTERVAL_MS.\nconst STREAM_BUDGET_MS = 420_000;\nconst POLL_INTERVAL_MS = 1500;\nconst TTL_EXTEND_INTERVAL_MS = 30_000;\n// Raw agent messages per restore. The agent emits one message per internal\n// step, so a handful of turns is already dozens of messages — this is a cap on\n// the RAW fetch, not on the number of restored turns.\nconst HISTORY_MESSAGE_LIMIT = 200;\n/** Chats shown in History. Titles come from the store, so listing is one query. */\nconst SESSION_LIST_LIMIT = 25;\n/**\n * Cap on the transcript replayed into a resumed agent session. Long enough to\n * carry the ids and decisions that make \"that dashboard\" resolvable, short\n * enough not to crowd out the actual prompt.\n */\nconst REPLAY_MAX_CHARS = 6000;\n\n/**\n * The durable chat. This is the identity History lists. Unversioned on purpose:\n * it names a product-scoped wspace-conversations row, not a sandbox, so it was\n * never subject to the cross-product adoption the runtime keys were.\n */\nconst CONVERSATION_ID_KEY = 'bc-assistant-conversation-id';\n\nconst RUNTIME_API: AssistantRuntimeApi = {\n  isCachedAssistantSandboxReusable,\n  findExistingSandbox,\n  createAssistantSandbox,\n  waitForSandboxReady,\n  waitForAssistantServiceReady,\n  createAssistantSession,\n};\n\nfunction readStoredId(key: string): string | null {\n  try {\n    return window.sessionStorage.getItem(key);\n  } catch {\n    // sessionStorage unavailable (private mode) — degrade to a fresh session.\n    return null;\n  }\n}\n\nfunction writeStoredId(key: string, id: string | null): void {\n  try {\n    if (id) window.sessionStorage.setItem(key, id);\n    else window.sessionStorage.removeItem(key);\n  } catch {\n    // Non-fatal: we simply lose cross-reload continuity.\n  }\n}\n\n// ── Context helpers (mirror vibecontrols' resolution) ────────────────\n\nfunction getProfileContextValue(key: 'workspaceId' | 'organizationId'): string {\n  try {\n    const activeContextKey =\n      key === 'workspaceId' ? 'burdenoff-active-context-workspace' : 'burdenoff-active-context-organization';\n    const activeContextValue = localStorage.getItem(activeContextKey);\n    if (activeContextValue) return activeContextValue;\n\n    const activeProfileId = sessionStorage.getItem('bf-active-profile');\n    if (!activeProfileId) return '';\n    const raw = localStorage.getItem(`bf-p-${activeProfileId}-context`);\n    if (!raw) return '';\n    const context = JSON.parse(raw) as { workspaceId?: string; organizationId?: string };\n    return context[key] ?? '';\n  } catch {\n    return '';\n  }\n}\n\nfunction getWorkspaceId(fallback: string | null): string {\n  const params = new URLSearchParams(window.location.search);\n  return params.get('workspace') ?? getProfileContextValue('workspaceId') ?? fallback ?? '';\n}\n\nfunction getOrganizationId(): string {\n  const params = new URLSearchParams(window.location.search);\n  return params.get('org') ?? getProfileContextValue('organizationId');\n}\n\n// ── Message-progress helpers (pure; mirror vibecontrols) ─────────────\n\nfunction getMessageRole(message: AssistantRawMessage): string | undefined {\n  // Check nested format first, then flat format\n  return message.info?.role ?? message.role;\n}\n\nfunction getRawMessageCreatedAt(message: AssistantRawMessage): number {\n  // Check nested format first (epoch ms), then flat format (ISO string or epoch ms)\n  const nested = message.info?.time?.created;\n  if (nested !== undefined) return nested;\n  const flat = message.createdAt;\n  if (flat === undefined) return 0;\n  // If it's a string (ISO), parse it; otherwise treat as epoch ms\n  if (typeof flat === 'string') {\n    const parsed = Date.parse(flat);\n    return isNaN(parsed) ? 0 : parsed;\n  }\n  return flat;\n}\n\nfunction getMessageCompleted(message: AssistantRawMessage): number | undefined {\n  // Check nested format first, then flat format\n  const nested = message.info?.time?.completed;\n  if (nested !== undefined) return nested;\n  const flat = message.completedAt;\n  if (flat === undefined) return undefined;\n  if (typeof flat === 'string') {\n    const parsed = Date.parse(flat);\n    return isNaN(parsed) ? undefined : parsed;\n  }\n  return flat;\n}\n\nfunction getAssistantText(message: AssistantRawMessage): string {\n  // Check parts format first (nested), then flat content\n  const parts = message.parts ?? [];\n  const textFromParts = (parts ?? [])\n    .filter((part) => part.type === 'text' && typeof part.text === 'string')\n    .map((part) => part.text?.trim() ?? '')\n    .filter(Boolean)\n    .join('\\n');\n  if (textFromParts) return textFromParts;\n  // Fallback to flat content field\n  return typeof message.content === 'string' ? message.content.trim() : '';\n}\n\n// Friendly, human-readable labels for the agent's tools so the progress line\n// reads like \"Searching the schema…\" instead of \"Running: bash\". The agent sets\n// a `description` on every bash call (e.g. \"Search for sales-related types in\n// workspace schema\") and a todo list on todowrite — surface those directly.\nconst TOOL_LABELS: Record<string, string> = {\n  bash: 'Running a command',\n  webfetch: 'Fetching a page',\n  'file.read': 'Reading files',\n  'file.write': 'Writing files',\n  'file.edit': 'Editing files',\n  'file.find.text': 'Searching the code',\n  'file.find.file': 'Looking for files',\n  todowrite: 'Planning the steps',\n  todoread: 'Reviewing the plan',\n};\n\nfunction asRecord(value: unknown): Record<string, unknown> | undefined {\n  return typeof value === 'object' && value !== null ? (value as Record<string, unknown>) : undefined;\n}\n\n/** Best-effort human summary of what a single tool part is doing right now. */\nfunction describeToolPart(part: AssistantRawMessagePart): string {\n  const tool = part.tool ?? 'tool';\n  const input = asRecord(part.state?.input);\n\n  // bash carries a plain-English `description` of the step — the best signal.\n  const description = input?.description;\n  if (typeof description === 'string' && description.trim()) return description.trim();\n\n  // todowrite carries the todo list — surface the item being worked on.\n  const todos = input?.todos;\n  if (Array.isArray(todos)) {\n    const active = todos.find((todo) => asRecord(todo)?.status === 'in_progress') ?? todos[0];\n    const content = asRecord(active)?.content;\n    if (typeof content === 'string' && content.trim()) return content.trim();\n  }\n\n  return TOOL_LABELS[tool] ?? `Running ${tool}`;\n}\n\nfunction getToolProgress(message: AssistantRawMessage): string[] {\n  const parts = message.parts ?? [];\n  return parts\n    .filter((part) => part.type === 'tool' && part.tool)\n    .map((part) => {\n      const status = part.state?.status ?? 'running';\n      const label = describeToolPart(part);\n      if (status === 'completed') return `✓ ${label}`;\n      if (status === 'failed') return `⚠ ${label}`;\n      return `⏳ ${label}…`;\n    });\n}\n\nfunction buildProgress(\n  messages: AssistantRawMessage[],\n  sinceMs: number,\n  previousContent?: string,\n  previousContentAtMs?: number\n): { content: string; done: boolean } {\n  const relevant = messages\n    .filter((message) => getMessageRole(message) === 'assistant' && getRawMessageCreatedAt(message) >= sinceMs)\n    .sort((left, right) => getRawMessageCreatedAt(left) - getRawMessageCreatedAt(right));\n\n  // Debug: log message filtering when no relevant messages found\n  if (relevant.length === 0 && messages.length > 0) {\n    console.log('[BigConsole-Assistant] buildProgress: no relevant messages', {\n      totalMessages: messages.length,\n      sinceMs,\n      messageRoles: messages.map((m) => getMessageRole(m)),\n      messageTimestamps: messages.map((m) => getRawMessageCreatedAt(m)),\n    });\n  }\n\n  let content: string;\n  let done: boolean;\n\n  if (relevant.length === 0) {\n    content = '';\n    // No usable assistant content for THIS turn yet. Separate \"still thinking\"\n    // from \"responded but unreadable\", so a slow reasoning model is never\n    // mistaken for a dead runtime:\n    //\n    //  - No assistant message exists AT ALL: the agent is still starting up, or\n    //    gpt-5.6-terra (a reasoning model) is still thinking before its first\n    //    token. Time-to-first-message routinely exceeds the old 15s window,\n    //    especially with a large system prompt — which declared the turn\n    //    done-and-empty and surfaced \"the assistant runtime did not respond\"\n    //    even though the backend was healthy. NEVER give up here; let the outer\n    //    turn budget (STREAM_BUDGET_MS) decide, exactly like the running-tool\n    //    guard in the branch below.\n    //\n    //  - An assistant message exists but none maps to this turn (timestamp skew\n    //    / role mismatch): the turn may really be over but unreadable. Keep a\n    //    staleness fallback — but give reasoning models ample room (90s, not\n    //    15s) so a slow first token is never read as a stalled turn.\n    const anyAssistantMessage = messages.some((message) => getMessageRole(message) === 'assistant');\n    const emptyForMs =\n      previousContent === content && previousContentAtMs !== undefined ? Date.now() - previousContentAtMs : 0;\n    // Skew case (a message exists but is unreadable): 90s is plenty.\n    // Nothing-at-all case (slow reasoning first token): wait 150s before calling\n    // it a genuine no-show — a safe upper bound for time-to-first-token that\n    // still fails a truly dead runtime (unbooted sandbox / quota) in ~2.5 min\n    // instead of the old 15s that tripped healthy reasoning turns.\n    done = anyAssistantMessage ? emptyForMs >= 90_000 : emptyForMs >= 150_000;\n  } else {\n    const latest = relevant[relevant.length - 1]!;\n\n    // ACCUMULATE the run, don't just show its last line.\n    //\n    // The agent emits a message per step, and it now narrates each one and prints\n    // a link the moment a create lands (\"✅ Data sink created — [Open …](/…)\").\n    // Showing only the newest message threw all of that away a second later: the\n    // user saw a lone \"Thinking…\" and none of the links they were promised. Join\n    // the whole run instead, so the panel reads as a live account of what is\n    // happening and every link stays on screen.\n    const narration = relevant.map(getAssistantText).filter(Boolean);\n    const toolProgress = getToolProgress(latest);\n    content = [...narration, ...toolProgress].join('\\n\\n');\n\n    const officiallyDone = Boolean(getMessageCompleted(latest)) && content.length > 0;\n\n    // A tool that is still running is proof the turn is alive, so never let the\n    // staleness fallback fire underneath it. A single gateway call can sit on the\n    // same \"⏳ Creating the data sink…\" line for far longer than the old 15s\n    // window, which would have declared the turn finished mid-build.\n    const hasRunningTool = (latest.parts ?? []).some(\n      (part) => part.type === 'tool' && part.state?.status !== 'completed' && part.state?.status !== 'failed'\n    );\n\n    const staleDone =\n      !officiallyDone &&\n      !hasRunningTool &&\n      previousContent === content &&\n      previousContentAtMs !== undefined &&\n      Date.now() - previousContentAtMs >= 45_000;\n\n    done = officiallyDone || staleDone;\n  }\n\n  return { content, done };\n}\n\nfunction sanitize(response: string): string {\n  return response\n    .replace(/(Authorization\\s*:\\s*Bearer\\s+)[^\\s\\n]+/gi, '$1[REDACTED]')\n    .replace(/(X-Workspace-Authorization\\s*:\\s*Bearer\\s+)[^\\s\\n]+/gi, '$1[REDACTED]')\n    .replace(/\\beyJ[A-Za-z0-9_-]+\\.[A-Za-z0-9._-]+\\.[A-Za-z0-9._-]+\\b/g, '[REDACTED_JWT]')\n    .replace(/\\bsk-ant-[A-Za-z0-9-]+\\b/g, '[REDACTED_API_KEY]');\n}\n\nfunction isRecoverable(error: unknown): boolean {\n  const message = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();\n  if (\n    message.includes('rate limit exceeded') ||\n    message.includes('unauthorized') ||\n    message.includes('k8s api error 401')\n  ) {\n    return false;\n  }\n  return [\n    'sandbox not found',\n    'sandbox is not running',\n    'sandbox service not available yet',\n    'sandbox failed',\n    'sandbox startup timed out',\n    'assistant service did not become healthy',\n    'proxy error: 404',\n    'proxy error: 502',\n    'proxy error: 503',\n    'unable to connect',\n    'image pull',\n    'container failed',\n    'bootstrap failed',\n    // Transient network errors from the browser fetch — gateway CORS preflight\n    // failures, mid-stream resets, and Cloudflare 524s all surface as\n    // \"Failed to fetch\" via TypeError. They're worth retrying on a clean\n    // runtime since the underlying sandbox state is unaffected.\n    'failed to fetch',\n    'cf-proxy timeout',\n    // Subgraph returned 500 with a generic message — gateway returns this as\n    // a GraphQL error rather than an HTTP error. The actual underlying cause\n    // (e.g., transient Prisma timeout) is recoverable, but a fresh sandbox\n    // may be needed.\n    'unexpected error',\n    // An empty turn (\"the assistant runtime did not respond\") is most often a\n    // stale/dead session or sandbox reference — a prompt to a session whose\n    // sandbox has been recycled persists nothing rather than erroring. Treat it\n    // as recoverable so the retry drops the warm refs and mints a fresh\n    // sandbox+session; a genuinely down runtime simply empties again on attempt 2\n    // and then surfaces to the user. (attempt-gated to a single retry upstream.)\n    'the assistant runtime did not respond',\n  ].some((fragment) => message.includes(fragment));\n}\n\n/**\n * Returns a memoized `AssistantTransport` wired to the BigConsole sandbox\n * assistant agent. The sandbox + session are cached in refs so follow-up turns\n * reuse the warm environment for the lifetime of the host shell.\n */\nexport function useSandboxAssistantTransport(): AssistantTransport {\n  const { getAccessToken, getWorkspaceToken, userId, workspaceId: ctxWorkspaceId } = useAuthToken();\n\n  // Rehydrate the sandbox + session ids persisted by the previous page\n  // lifecycle. These were being WRITTEN to sessionStorage but never read back,\n  // so every reload silently opened a brand-new agent session: the chat looked\n  // empty AND the agent genuinely lost the conversation (it could no longer\n  // resolve \"that datasink\" / \"the dashboard you just made\").\n  //\n  // Restoring both together is what makes history real rather than cosmetic —\n  // the transcript we replay into the UI is the same session the agent will\n  // keep reasoning over. A rehydrated sandbox id is NOT trusted as-is: before its\n  // first use `resolveAssistantRuntime` re-fetches it and holds it to the reuse\n  // predicate (product stamp, owner, confirmWrites, status), discarding it — and\n  // its session — if it fails. A stale/expired sandbox is discarded the same way.\n  const [initialSandboxId, initialSessionId, initialConversationId] = useMemo(() => {\n    // Pre-BOFF-7331 builds wrote unversioned keys and may have cached another\n    // product's sandbox in them. Never read them; clear them.\n    for (const legacyKey of LEGACY_ASSISTANT_RUNTIME_KEYS) writeStoredId(legacyKey, null);\n    return [\n      readStoredId(ASSISTANT_SANDBOX_ID_KEY),\n      readStoredId(ASSISTANT_SESSION_ID_KEY),\n      readStoredId(CONVERSATION_ID_KEY),\n    ] as const;\n  }, []);\n\n  const sandboxIdRef = useRef<string | null>(initialSandboxId);\n  const sessionIdRef = useRef<string | null>(initialSessionId);\n  const conversationIdRef = useRef<string | null>(initialConversationId);\n  /** Memory only: which sandbox (for which user) this page lifecycle has proven drivable. */\n  const verifiedSandboxKeyRef = useRef<string | null>(null);\n  /**\n   * Transcript to feed the agent on its next prompt.\n   *\n   * A chat can outlive the agent that produced it: the transcript is durable,\n   * the sandbox session is not. Showing the messages while the agent silently\n   * remembers nothing is the worst of both worlds — ask it to \"add a widget to\n   * that dashboard\" and it has no idea what \"that\" is. So when a chat is\n   * resumed after its agent is gone, replay the conversation into its first\n   * prompt.\n   */\n  const replayRef = useRef<string | null>(null);\n\n  const persistSandboxId = useCallback((id: string | null) => {\n    sandboxIdRef.current = id;\n    writeStoredId(ASSISTANT_SANDBOX_ID_KEY, id);\n  }, []);\n\n  const persistSessionId = useCallback((id: string | null) => {\n    sessionIdRef.current = id;\n    writeStoredId(ASSISTANT_SESSION_ID_KEY, id);\n  }, []);\n\n  const persistConversationId = useCallback((id: string | null) => {\n    conversationIdRef.current = id;\n    writeStoredId(CONVERSATION_ID_KEY, id);\n  }, []);\n\n  const ensureRuntime = useCallback(\n    async (\n      workspaceId: string,\n      authContext: AssistantSandboxAuthContext\n    ): Promise<{ sandboxId: string; sessionId: string }> =>\n      resolveAssistantRuntime({\n        workspaceId,\n        mode: MODE,\n        authContext,\n        api: RUNTIME_API,\n        hasAccessToken: () => !!getAccessToken(),\n        store: {\n          getSandboxId: () => sandboxIdRef.current,\n          setSandboxId: persistSandboxId,\n          getSessionId: () => sessionIdRef.current,\n          setSessionId: persistSessionId,\n          getVerifiedSandboxKey: () => verifiedSandboxKeyRef.current,\n          setVerifiedSandboxKey: (key) => {\n            verifiedSandboxKeyRef.current = key;\n          },\n        },\n      }),\n    [getAccessToken, persistSandboxId, persistSessionId]\n  );\n\n  const sendPrompt = useCallback(\n    async ({\n      prompt,\n      attachments,\n      onProgress,\n      signal,\n    }: AssistantSendArgs): Promise<{\n      text: string;\n    }> => {\n      const workspaceId = getWorkspaceId(ctxWorkspaceId);\n      console.log('[BigConsole-Assistant] sendPrompt called', {\n        promptLength: prompt.length,\n        workspaceId,\n        hasCtxWorkspaceId: !!ctxWorkspaceId,\n        authContextKeys: {\n          hasAccessToken: !!getAccessToken(),\n          hasWorkspaceToken: !!getWorkspaceToken(),\n          hasUserId: !!userId,\n        },\n        locationSearch: window.location.search,\n      });\n      if (!workspaceId) {\n        throw new Error('The assistant needs an active workspace. Open a workspace and try again.');\n      }\n      const authContext: AssistantSandboxAuthContext = {\n        accessToken: getAccessToken(),\n        workspaceToken: getWorkspaceToken(),\n        userId,\n        organizationId: getOrganizationId(),\n      };\n      console.log('[BigConsole-Assistant] authContext prepared', {\n        hasAccessToken: !!authContext.accessToken,\n        hasWorkspaceToken: !!authContext.workspaceToken,\n        hasUserId: !!authContext.userId,\n        hasOrgId: !!authContext.organizationId,\n      });\n\n      // Drive the live preview panel. The agent has no event stream, so the\n      // narration IS the signal: the store parses it into a DataSink → Dashboard\n      // → Parser → Widget rail. Fed here rather than in the widget because the\n      // host owns this transport, so no fe-libs change is needed.\n      const runStore = useAssistantRunStore.getState();\n      runStore.startRun(prompt);\n      const reportProgress = (partial: string): void => {\n        onProgress(partial);\n        useAssistantRunStore.getState().applyProgress(partial);\n      };\n\n      const run = async (attempt: 1 | 2): Promise<{ text: string }> => {\n        try {\n          console.log('[BigConsole-Assistant] run attempt', attempt);\n          const { sandboxId, sessionId } = await ensureRuntime(workspaceId, authContext);\n          console.log('[BigConsole-Assistant] ensureRuntime resolved', { sandboxId, sessionId });\n\n          // Resuming a chat whose agent session is gone: hand the agent the\n          // earlier transcript once, on the first prompt of the resumed chat, so\n          // it answers with that context instead of from a blank slate. Consumed\n          // on success — never replayed twice into the same session.\n          const replay = replayRef.current;\n          // Extract any uploaded files (JSON/CSV/Excel/PDF) into a capped text\n          // block and fold it into the prompt the agent sees, so it can design a\n          // DataSink straight from the pasted rows. The user-facing `prompt`\n          // (preview narration, logs) stays clean.\n          const attachmentBlock = attachments && attachments.length > 0 ? await buildAttachmentBlock(attachments) : '';\n          const promptWithData = attachmentBlock ? `${prompt}\\n\\n${attachmentBlock}` : prompt;\n          const agentPrompt = replay ? `${replay}\\n\\n---\\n\\n${promptWithData}` : promptWithData;\n\n          const startedAt = Date.now();\n          console.log('[BigConsole-Assistant] calling sendAssistantPromptAsync', {\n            sandboxId,\n            workspaceId,\n            sessionId,\n            promptLength: agentPrompt.length,\n            replayed: Boolean(replay),\n          });\n          await sendAssistantPromptAsync(\n            sandboxId,\n            workspaceId,\n            sessionId,\n            agentPrompt,\n            MODE,\n            gatherPageContext(),\n            authContext\n          );\n\n          const timeoutAt = Date.now() + STREAM_BUDGET_MS;\n          let lastTtlExtensionAt = Date.now();\n          let lastContent = '';\n          let lastContentChangeAt = Date.now();\n          let progress = buildProgress([], startedAt);\n\n          while (Date.now() < timeoutAt) {\n            if (signal.aborted) throw new Error('Cancelled');\n\n            const messages = await getAssistantMessages(sandboxId, workspaceId, sessionId, authContext, 50);\n            console.log('[BigConsole-Assistant] poll', {\n              elapsedMs: Date.now() - startedAt,\n              messageCount: messages.length,\n              firstFewRoles: messages.slice(0, 3).map((m) => getMessageRole(m)),\n              firstFewTimestamps: messages.slice(0, 3).map((m) => getRawMessageCreatedAt(m)),\n            });\n            progress = buildProgress(messages, startedAt, lastContent, lastContentChangeAt);\n            console.log('[BigConsole-Assistant] progress', {\n              contentPreview: progress.content.slice(0, 100),\n              done: progress.done,\n              lastContentChangeAt: Date.now() - lastContentChangeAt,\n            });\n            if (progress.content !== lastContent) {\n              lastContent = progress.content;\n              lastContentChangeAt = Date.now();\n            }\n            reportProgress(sanitize(progress.content));\n            if (progress.done) {\n              console.log('[BigConsole-Assistant] progress.done=true, breaking poll loop');\n              break;\n            }\n\n            if (Date.now() - lastTtlExtensionAt > TTL_EXTEND_INTERVAL_MS) {\n              await extendAssistantSandboxTTL(sandboxId, workspaceId, 600, authContext).catch(() => undefined);\n              lastTtlExtensionAt = Date.now();\n            }\n\n            await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));\n          }\n\n          if (!progress.done) {\n            // Do NOT say \"please try again\". We stopped watching; the agent did\n            // not stop working, and anything it already created is real. Telling\n            // people to retry is how you get duplicate dashboards.\n            throw new Error(\n              'I stopped waiting for a reply, but I may still be working — anything I already created will be there. Check your dashboards and data sinks before asking again, so you do not end up with duplicates.'\n            );\n          }\n\n          const reply = sanitize(progress.content);\n\n          // An empty reply is a FAILED turn, not a successful one.\n          //\n          // `buildProgress` gives up and reports `done` when the agent has said\n          // nothing for 15s, which is what happens when the runtime cannot serve\n          // the turn at all (e.g. the sandbox quota is exhausted). Returning that\n          // as a success showed the user a blank assistant bubble and — once\n          // history became durable — wrote an empty transcript into it, leaving\n          // a titled chat with nothing inside. Fail loudly and save nothing.\n          if (!reply.trim()) {\n            throw new Error(\n              'I could not produce a reply — the assistant runtime did not respond. It may be out of capacity right now. Nothing was changed; please try again shortly.'\n            );\n          }\n\n          replayRef.current = null;\n\n          // Persist the completed turn. Failing to save must not fail the turn —\n          // the user got their answer, and the work the agent did is already real.\n          try {\n            const conversation = await saveAssistantTurn(\n              {\n                conversationId: conversationIdRef.current,\n                prompt,\n                reply,\n                agentSessionId: sessionId,\n              },\n              workspaceId,\n              authContext\n            );\n            persistConversationId(conversation.id);\n          } catch (error) {\n            console.warn('[BigConsole-Assistant] could not save turn to history', {\n              error: error instanceof Error ? error.message : String(error),\n            });\n          }\n\n          return { text: reply };\n        } catch (error) {\n          console.error('[BigConsole-Assistant] run error', {\n            attempt,\n            error: error instanceof Error ? error.message : String(error),\n            stack: error instanceof Error ? error.stack : undefined,\n            sandboxId: sandboxIdRef.current,\n            sessionId: sessionIdRef.current,\n          });\n          // A stale/expired sandbox or session is recoverable — drop the warm\n          // refs and retry once from a clean runtime.\n          if (attempt === 1 && isRecoverable(error)) {\n            persistSandboxId(null);\n            persistSessionId(null);\n            return run(2);\n          }\n          throw error;\n        }\n      };\n\n      try {\n        const result = await run(1);\n        useAssistantRunStore.getState().finishRun(null);\n        return result;\n      } catch (error) {\n        useAssistantRunStore.getState().finishRun(error instanceof Error ? error.message : String(error));\n        throw error;\n      }\n    },\n    [\n      ctxWorkspaceId,\n      ensureRuntime,\n      getAccessToken,\n      getWorkspaceToken,\n      userId,\n      persistSandboxId,\n      persistSessionId,\n      persistConversationId,\n    ]\n  );\n\n  // ── Durable history (wspace-conversations) ───────────────────────────────\n  //\n  // The agent's own session lives in a sandbox with a 10-minute TTL and no\n  // persistent volume, so it CANNOT be the store of record for a transcript the\n  // user expects to keep. Every completed turn is written to wspace-conversations\n  // instead, tagged with the product, so history is durable AND product-scoped —\n  // a BigConsole chat can never surface in another product's panel.\n  //\n  // Two ids, doing different jobs:\n  //   conversationId — the durable chat. What History lists, and what the widget\n  //                    treats as \"the session\".\n  //   sessionId      — the LIVE agent session inside the sandbox. Ephemeral; a\n  //                    hint stored on the conversation so a still-warm agent can\n  //                    be resumed.\n\n  const authFor = useCallback(\n    (): AssistantSandboxAuthContext => ({\n      accessToken: getAccessToken(),\n      workspaceToken: getWorkspaceToken(),\n      userId,\n      organizationId: getOrganizationId(),\n    }),\n    [getAccessToken, getWorkspaceToken, userId]\n  );\n\n  const buildReplay = useCallback((messages: AssistantHistoryMessage[]): string | null => {\n    if (messages.length === 0) return null;\n    const transcript = messages\n      .map((message) => `${message.role === 'user' ? 'User' : 'Assistant'}: ${message.content}`)\n      .join('\\n\\n')\n      .slice(-REPLAY_MAX_CHARS);\n\n    return [\n      'You are resuming an earlier conversation. What follows is what was said in it — treat it as your own memory and continue seamlessly. Do not mention this replay, and do not redo work that was already completed.',\n      '--- earlier in this conversation ---',\n      transcript,\n      '--- end ---',\n    ].join('\\n\\n');\n  }, []);\n\n  const mapConversationMessages = useCallback(\n    (messages: AssistantHistoryTurnMessage[]): AssistantHistoryMessage[] =>\n      messages.map((message) => ({\n        id: message.id,\n        role: message.role === 'ASSISTANT' ? ('assistant' as const) : ('user' as const),\n        content: sanitize(message.content),\n      })),\n    []\n  );\n\n  /**\n   * Adopt a conversation: show its transcript, and line the agent up to continue\n   * it — resuming the live session when one survives, replaying the transcript\n   * when it does not.\n   */\n  const adoptConversation = useCallback(\n    async (\n      conversation: AssistantConversationSummary,\n      workspaceId: string,\n      auth: AssistantSandboxAuthContext\n    ): Promise<AssistantHistoryMessage[]> => {\n      const raw = await getAssistantConversationMessages(conversation.id, workspaceId, auth, HISTORY_MESSAGE_LIMIT);\n      const messages = mapConversationMessages(raw);\n\n      persistConversationId(conversation.id);\n\n      // Do NOT adopt the stored agentSessionId. That session lives inside an\n      // ephemeral sandbox (~600s TTL) and is almost always gone by the time a\n      // past conversation is reopened — and a prompt to a dead session does not\n      // error, it silently persists nothing, which surfaces as \"the assistant\n      // runtime did not respond\". Always start a FRESH opencode session on the\n      // current sandbox and replay the transcript so the agent keeps its context.\n      // (A mass sandbox recycle — e.g. an image rollout — invalidates every\n      // stored session at once, which is exactly when adoption bites hardest.)\n      persistSessionId(null);\n      replayRef.current = buildReplay(messages);\n\n      return messages;\n    },\n    [mapConversationMessages, persistConversationId, persistSessionId, buildReplay]\n  );\n\n  const loadHistory = useCallback(async (): Promise<AssistantHistoryMessage[]> => {\n    const workspaceId = getWorkspaceId(ctxWorkspaceId);\n    if (!workspaceId || !getAccessToken()) return [];\n    const auth = authFor();\n\n    try {\n      const conversations = await listAssistantConversations(workspaceId, auth, SESSION_LIST_LIMIT);\n\n      // Reopen the chat the user was in; failing that, their most recent one, so\n      // a fresh login lands them back where they left off rather than in a blank\n      // chat with their history hidden behind a menu.\n      const current = conversationIdRef.current;\n      const target = conversations.find((conversation) => conversation.id === current) ?? conversations[0];\n      if (!target) return [];\n\n      return await adoptConversation(target, workspaceId, auth);\n    } catch (error) {\n      console.warn('[BigConsole-Assistant] could not restore history', {\n        error: error instanceof Error ? error.message : String(error),\n      });\n      return [];\n    }\n  }, [ctxWorkspaceId, getAccessToken, authFor, adoptConversation]);\n\n  const listSessions = useCallback(async (): Promise<AssistantSessionSummaryLocal[]> => {\n    const workspaceId = getWorkspaceId(ctxWorkspaceId);\n    if (!workspaceId || !getAccessToken()) return [];\n\n    try {\n      const conversations = await listAssistantConversations(workspaceId, authFor(), SESSION_LIST_LIMIT);\n      // Titles come from the store, so listing is ONE round-trip — no per-chat\n      // probing, which is what used to make opening History feel slow.\n      return conversations.map((conversation) => ({\n        id: conversation.id,\n        title: conversation.title?.trim() || 'New chat',\n        updatedAt: Date.parse(conversation.updatedAt) || undefined,\n        active: conversation.id === conversationIdRef.current,\n      }));\n    } catch {\n      return [];\n    }\n  }, [ctxWorkspaceId, getAccessToken, authFor]);\n\n  /**\n   * Start a new chat — instantly, and with no backend call.\n   *\n   * Both ids are simply detached: the agent session is created lazily on the next\n   * prompt, and the conversation row by the first saveAssistantTurn. Nothing to\n   * wait for, and no empty conversations left behind for chats nobody used.\n   */\n  const newSession = useCallback(async (): Promise<void> => {\n    persistConversationId(null);\n    persistSessionId(null);\n    replayRef.current = null;\n    return Promise.resolve();\n  }, [persistConversationId, persistSessionId]);\n\n  const deleteSession = useCallback(\n    async (conversationId: string): Promise<void> => {\n      const workspaceId = getWorkspaceId(ctxWorkspaceId);\n      if (!workspaceId) return;\n\n      await deleteAssistantConversation(conversationId, workspaceId, authFor());\n\n      // Deleting the chat you are looking at leaves you in a fresh one.\n      if (conversationIdRef.current === conversationId) {\n        persistConversationId(null);\n        persistSessionId(null);\n        replayRef.current = null;\n      }\n    },\n    [ctxWorkspaceId, authFor, persistConversationId, persistSessionId]\n  );\n\n  const selectSession = useCallback(\n    async (conversationId: string): Promise<AssistantHistoryMessage[]> => {\n      const workspaceId = getWorkspaceId(ctxWorkspaceId);\n      if (!workspaceId) return [];\n      const auth = authFor();\n\n      const conversations = await listAssistantConversations(workspaceId, auth, SESSION_LIST_LIMIT);\n      const target = conversations.find((conversation) => conversation.id === conversationId);\n      if (!target) return [];\n\n      return adoptConversation(target, workspaceId, auth);\n    },\n    [ctxWorkspaceId, authFor, adoptConversation]\n  );\n\n  return useMemo<AssistantTransport>(\n    () => ({ sendPrompt, loadHistory, listSessions, newSession, deleteSession, selectSession }),\n    [sendPrompt, loadHistory, listSessions, newSession, deleteSession, selectSession]\n  );\n}\n"],"mappings":"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"}

package/dist/bigconsole/assistant/index.d.ts

@@ -30,3 +30,4 @@ export { BIGCONSOLE_PRODUCT } from './product';
 export { API_CALLS_CONFIRM_PREAMBLE, API_CALLS_PROPOSAL_PREAMBLE, USER_REQUEST_DELIMITER, buildPromptForMode, } from './assistantPrompt';
 export { PROBE_RESOURCES, useWorkspaceWriteAccess, type WorkspaceWriteAccess } from './useWorkspaceWriteAccess';
 export { useBigConsoleAssistantPreview } from './previewController';
+//# sourceMappingURL=index.d.ts.map

package/dist/bigconsole/assistant/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/bigconsole/assistant/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,4BAA4B,EAAE,MAAM,mCAAmC,CAAC;AACjF,YAAY,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAC;AAG5E,OAAO,EAAE,kBAAkB,EAAE,MAAM,0CAA0C,CAAC;AAC9E,OAAO,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,oCAAoC,EAAE,MAAM,eAAe,CAAC;AAC7G,YAAY,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AACjD,YAAY,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAE7C;;;;;;;;;;;;;GAaG;AACH,OAAO,EAAE,4BAA4B,EAAE,eAAe,EAAE,KAAK,0BAA0B,EAAE,MAAM,oBAAoB,CAAC;AACpH,OAAO,EAAE,GAAG,EAAE,0BAA0B,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AACjE,OAAO,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,EACL,0BAA0B,EAC1B,2BAA2B,EAC3B,sBAAsB,EACtB,kBAAkB,GACnB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,eAAe,EAAE,uBAAuB,EAAE,KAAK,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AAChH,OAAO,EAAE,6BAA6B,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/bigconsole/assistant/modes.d.ts

@@ -252,3 +252,4 @@ declare const BUILD: {
  */
 export declare const BIGCONSOLE_ASSISTANT_MODES: readonly AssistantModeConfig[];
 export { ASK, BUILD };
+//# sourceMappingURL=modes.d.ts.map

package/dist/bigconsole/assistant/modes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"modes.d.ts","sourceRoot":"","sources":["../../../src/bigconsole/assistant/modes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kDAAkD,CAAC;AAE5F;;;;;;;;;;GAUG;AACH,QAAA,MAAM,GAAG;;;;;CAc+B,CAAC;AAEzC;;;;GAIG;AACH,QAAA,MAAM,KAAK;;;;;;IAqBT;;;;;;;;;;;;;;OAcG;;IAEH;;;;;;;;;;;;;;;;;;;;;;;OAuBG;;IAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA0GG;;IAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+DG;;CAEmC,CAAC;AAEzC;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B,EAAE,SAAS,mBAAmB,EAAiB,CAAC;AAEvF,OAAO,EAAE,GAAG,EAAE,KAAK,EAAE,CAAC"}