@noodleseed/one 0.154.0 → 0.156.0

package/node_modules/@noodle-borg/agent-kit/dist/skill-app-playbook-ref.js

@@ -29,14 +29,14 @@ export function renderBuildAnMcpAppReference() {
         '4. **Preserve fallback.** Every tool that launches a widget must still return useful text without the widget, so unsupported hosts and failed rendering remain usable.',
         '5. **Decide product-guide coverage.** Record the required product-guide decision and its reason, then use `references/product-agent-guides.md` as the canonical selection and authoring guidance.',
         '6. **Author and wire the App contract.** Follow `references/widgets-and-apps.md` for the canonical component guidance, view registration, hooks, state, CSP, tool visibility, and output shaping. Keep tool effects and confirmation semantics correct independently of the UI.',
-        '7. **Validate the local artifact.** Run `noodle validate --json`, `noodle test --json`, and `noodle check --json`. Repair failures at the layer that produced them.',
+        '7. **Validate the local artifact.** Run the generated/adapted `npm test`, `noodle validate --json` and `noodle check --json`. Prove a representative result and negative case, not just registration. Synthetic preference previews do not save; replace their backend seam and verify the authorized effect before showing success.',
         '8. **Inspect the experience.** Run `noodle devtools` and verify loading, empty, error, success, responsive layout, focus/keyboard behavior, and the text fallback.',
         '9. **Escalate evidence only on request.** Run a host test only when the user requested host verification. Run host-specific compliance only when preparing that host submission; select the exact host-testing or compliance entry from the router lookup catalog only after that evidence level is explicitly requested.',
         '',
         '## Verification evidence',
         '',
         '- **Product:** the design spec states the user benefit, UI fit decision, and product-guide decision with its reason.',
-        '- **Server:** `noodle validate --json` and `noodle test --json` succeeded.',
+        '- **Server:** compilation, a representative call and negative input/authorization cases passed; report whether fixtures or a real authorized backend were used.',
         '- **App contract:** `noodle check --json` succeeded.',
         '- **Local UX:** `noodle devtools` exercised the relevant states and the useful text fallback without the widget.',
         '- **Host/compliance:** report each requested host or compliance check with its evidence; report every unperformed higher level as not run.',

package/node_modules/@noodle-borg/agent-kit/dist/skill-authoring-refs.js

@@ -205,20 +205,14 @@ export function renderAuthoringWorkflowReference() {
         '',
         '## Tests',
         '',
-        'Use Vitest for app-local tests. The generated `npm test` command scans only the project-owned `test/` directory; skill-local example tests are reference material, not part of the app suite. Keep fixtures project-local; do not import from `examples/`. A minimum test suite imports the default server, checks the intended definitions compile, then lets `noodle test --json` perform the loopback MCP smoke.',
+        'Start from the generated `test/server.test.ts`, not a blank test file. `npm test` runs `vitest run --dir test` over the project-owned `test/` directory; skill-local example tests are reference material. The generated suite compiles the actual source/view, lists tools, asserts a representative result and rejects invalid input. It copies source into temporary fixture storage and uses synthetic configuration, never customer secrets or saved hosted targets. The HTTP profile proves one local backend read and zero extra calls for invalid input.',
         '',
-        '```ts',
-        "import { describe, expect, it } from 'vitest';",
-        "import app from '../src/server.js';",
-        '',
-        "describe('server', () => {",
-        "  it('declares the expected tool surface', () => {",
-        "    expect(app.name).toBe('support_assistant');",
-        '  });',
-        '});',
+        '```sh',
+        'npm test',
+        'npm run agent:check',
         '```',
         '',
-        'After focused tests pass, run `noodle validate --json`, `noodle test --json`, and then `noodle dev` for interactive local verification.',
+        'Adapt the representative arguments and assertions when business contracts change; keep invalid-input and authorization cases. A name/export assertion or `noodle test --json` without `--tool` proves no useful call. After fixture tests pass, bind the real local configuration, run an authorized representative read, and use `noodle dev` for interactive checks. Never use a production mutation or fixture success as customer-readiness evidence.',
         '',
         '## Secrets and variables',
         '',
@@ -568,7 +562,10 @@ const FLAGSHIP_EXAMPLES = [
         'customer-auth',
         'End-user OIDC, private customer API routing, route-bound confirmed actions, roles/scopes, and delegated credentials.',
     ],
-    ['stateful-draft', 'Durable, caller-scoped widget state handles with optimistic revisions.'],
+    [
+        'stateful-draft',
+        'Review and save a brief before signup; carry caller-scoped state into an account.',
+    ],
     ['perplexity', 'A real SaaS API with bearer auth and a managed `secret`.'],
     ['bitcoin', 'API-key HTTP connector, custom auth header, and compute normalization.'],
     [

package/node_modules/@noodle-borg/agent-kit/dist/skill-connect-refs.js

@@ -203,7 +203,7 @@ export function renderConnectAnApiReference() {
         '',
         '### Set the secret for local runs',
         '',
-        'Local `dev`, smoke commands, secrets, and variables resolve one effective target: explicit flags, then the project link, then the saved CLI target, then local defaults. Set the secret through that same target:',
+        'Local authoring resolves explicit coordinates, then the complete project link, then deterministic local defaults; saved global coordinates do not redirect an unlinked project. Follow the diagnostic’s exact-target commands from the project directory for every missing secret and variable:',
         '',
         '```sh',
         '# Canonical: writes to the effective local environment used by dev/test/devtools:',
@@ -220,7 +220,7 @@ export function renderConnectAnApiReference() {
         '',
         '### Prove real output',
         '',
-        '`noodle validate` / `noodle test` prove a connector tool *compiles and registers* — not that its',
+        '`noodle validate` / `noodle test` without `--tool` prove a connector tool *compiles and registers* — not that its',
         'mapping returns data. With the secret set, run a live read: `noodle tools call <read_tool> --args',
         "'{…}'` executes the connector against the real API in-process. Confirm the mapped fields are populated,",
         'not `undefined`; if they are empty, distinguish a legitimate empty result from a missing or incorrect mapping, fix `${response…}` paths against the real payload when needed, and re-run.',

package/node_modules/@noodle-borg/agent-kit/dist/skill-embedded-assistant-operations-ref.js

@@ -11,7 +11,7 @@ export function renderEmbeddedAssistantOperationsReference() {
         'noodle assistant embed --check --json --require-env EXAMPLE_DELEG_CLIENT_SECRET',
         '```',
         '',
-        'The check reports only required and missing environment names, never their values. Pass `--surface public|mixed|authenticated` to match the deployment: `public` drops the backend client id/secret requirement (a public embed has neither), and `public`/`mixed` additionally require `script-src` — the one directive whose failure runs no widget code at all, so nothing can report it from inside the page. CSP directives verify against the service origin exactly, via the env placeholder, or through a covering wildcard (`https://*.example.com`); a dynamic expression is marked unverified instead of guessed. Additional `--require-env` names are application-owned; `--env-alias NAME=HOST_NAME` follows a host repo that names an env var differently.',
+        'The check reports required and missing environment names, never their values. Use the exact command in an installed NOODLE-INTEGRATION.md, including its aliases and additional names, with the host environment exported; the CLI does not load application dotenv files. Pass `--surface public|mixed|authenticated` to match the deployment: `public` needs no backend client credentials. Public script-tag mounts need the service in `script-src`; the generated bundled React mount needs only `connect-src` and `frame-src` for that service. Unknown public mounts retain the conservative script check. CSP verifies an exact service origin, an env placeholder or a covering wildcard; dynamic expressions stay unverified. `--require-env` adds application-owned names and `--env-alias NAME=HOST_NAME` follows existing host naming.',
         '',
         'Read `evidence.levels` in order and stop at `evidence.firstUnproven`:',
         '',

package/node_modules/@noodle-borg/agent-kit/dist/skill-embedded-assistant-ref.js

@@ -9,6 +9,7 @@ export function renderEmbeddedAssistantReference() {
         '',
         '- Architecture',
         '- Select the architecture before code',
+        '- Install into the existing application',
         '- Author and validate',
         '- Product workflow guidance',
         '- Customize the presentation',
@@ -68,6 +69,20 @@ export function renderEmbeddedAssistantReference() {
         '',
         'The architecture brief must state the selected topology, why it fits the named user and job, the two code owners and two local processes, credential and identity flow, routing authority, model owner, files expected to change, and the first requested evidence boundary. If identity/session ownership, exact origin, tenant-routing authority, model ownership, or evidence target is unavailable, return a blocked architecture brief naming the missing owner or decision and do not edit either codebase.',
         '',
+        '## Install into the existing application',
+        '',
+        'Configure or reuse an existing capability before generating files. Public embedding uses the existing script or embed ID and needs no customer backend session/config route. Reuse application APIs and business functions; generate a thin handler only where the approved architecture identifies a missing stable boundary.',
+        '',
+        'For a supported host, first run `noodle assistant embed --framework nextjs --surface public --dry-run --json` in the customer application, substituting `authenticated` or `mixed` only for the selected surface. Read the returned recipe applicability, applicationSeams, generated contents/hashes, skipped conflicts and nextSteps. The output is an installation plan, not permission to change the repository.',
+        '',
+        'For the documented non-Node backend/static-frontend authenticated profile, discover the framework choice through `noodle commands --json` and follow the linked framework guide below. The installer supplies a session view, a fail-closed identity seam, real CSRF-enforced request tests, a browser wrapper and exact-destination CSRF transport tests. Keep the existing package managers, authentication middleware and same-origin proxy. Pass the existing CSRF token and user/tenant principalKey to the wrapper; the managed element supports injected fetch, so preserving CSRF does not require a custom renderer or Node production server. Unsupported combinations use the neutral contract, not a claimed qualified profile.',
+        '',
+        'Once local changes are authorized, rerun without `--dry-run`; never add `--force` to resolve a conflict automatically. Read the installed `NOODLE-INTEGRATION.md` and newly installed project skill before editing. Implement only the named session/business/mount seams and preserve the host framework, package manager, login and authorization. Mixed mode also requires an application-owned login transaction; the generated callback does not implement or verify that transaction.',
+        '',
+        'Use generated tests and independently maintained acceptance cases at the actual customer boundary. A static host check, a mock test or installed files cannot prove application authorization or production browser behavior. Missing identities, sandbox access, customer approval or a reachable service remain unverified. Record the exact application/Noodle revisions, package versions and environment for observed evidence; rerun affected checks after changes.',
+        '',
+        'Unsupported hosts use the framework-neutral integration contract below; do not claim they received a generated, qualified framework profile. Keep direct MCP and headless projections on the same TypeScript source, and preserve their separate identity requirements.',
+        '',
         '## Author and validate',
         '',
         '`noodle init` and `noodle init --template widget` deliberately produce credential-free MCP Apps. Add an assistant declaration only when the product explicitly includes a customer-hosted assistant; do not make ordinary external-host widgets depend on model-provider settings.',
@@ -148,6 +163,16 @@ export function renderEmbeddedAssistantReference() {
         '',
         '#### Complete mixed-mode handoff',
         '',
+        'For a small SaaS onboarding flow, first read the bundled [stateful-draft example](../examples/stateful-draft/README.md). Compose the existing capabilities; do not introduce an onboarding platform API, workflow engine, research pipeline, or second identity provider.',
+        '',
+        'Start from one useful result the visitor can see before signup. Ask only for missing information, one short question at a time. Show an editable preview, and offer an account only when it unlocks a meaningful next step. Keep the ordinary signup route available. Research and document parsing are optional enrichment, never required because the flow is conversational.',
+        '',
+        'Use a finite-TTL caller state handle only if the draft needs server persistence. Opt it into `claimOnAuthentication` when it should move to the verified account. An explicit typed read tool supplies the current revision; a typed patch tool sends that revision and the complete reviewed value. Widget state is a display cache, never proof of a save. A failed or missing result must not increment the revision, mark the draft saved, or silently retry a conflicting write.',
+        '',
+        'Keep the final business action in the customer API. Map the reviewed draft to its existing create/update operation after authentication, with confirmation and the backend’s existing authorization and idempotency. Ticket adoption transfers temporary state, not a CRM record or completed onboarding.',
+        '',
+        'Prove this journey before calling it ready: useful anonymous preview; actual saved state; cancelled/expired signup; verified signup with the same draft; a destination conflict without an automatic merge; and no business write merely because login succeeded. A synthetic login demonstrates the integration shape but is not evidence that the customer identity system is connected.',
+        '',
         '1. **Capture the ticket.** The widget raises `assistant-sign-in-requested` with a single-use `signInTicket`. POST it to the host application same-origin backend and bind it to the short-lived login transaction; keep it out of query strings, logs, analytics, and durable browser storage.',
         '2. **Use the existing login.** Send the visitor through the host application full-page redirect for sign-in or sign-up. Noodle never becomes the customer identity provider.',
         '3. **Elevate on the backend.** After authentication, recover the bound ticket and call `createAssistantSession({ ..., signInTicket })` with the verified user, server-owned routing, backend client credentials, and the exact **origin the conversation will continue on**. The allowed destination may differ from the anonymous marketing origin; successful elevation rebinds the session to it.',
@@ -202,6 +227,8 @@ export function renderEmbeddedAssistantReference() {
         '',
         "Set `webmcp: { enabled: true }` on the assistant to let a browser agent reach this session's tools through the page's WebMCP API, and set it on an individual access surface to override that default in either direction — a marketing surface can opt in while a signed-in one opts out, or the reverse. Off unless set, and inert in browsers without `document.modelContext`. It governs discovery: whether the embed registers the tools this session already projects, narrowed to those that are both app-callable and model-visible. Every call executes over the same apps-bridge path the assistant's own calls take, so a browser agent gets the session's authority and nothing more, and a `confirm: true` tool still stops for a human in the panel rather than being accepted on the agent's behalf. It is not a second authorization boundary — the session is the only one. Bridge calls spend their own per-session and per-day budgets instead of model turns, and the surface's daily kill switch stops them too. Prefer this over hand-registering page-local tools that borrow the visitor's session: those carry no scoped authority, policy, or audit trail.",
         '',
+        'Set `continuity: { enabled: true }` on a public or mixed access surface to let an anonymous visitor keep the conversation they can see when they navigate to another page of the same site. Off unless set, and refused on an authenticated surface, which reattaches through a backend-verified sign-in instead. It restores the visible text on a fresh session and never the old one: no tool authority, no share of a spent turn budget, and no pending confirmation carried across, so an unanswered confirmation stays unanswered. `windowSeconds` defaults to 300 with a 600 ceiling, `maxRestores` to 3 with a ceiling of 10, and 0 for either disables continuity outright; an operator may lower what you declare and can never raise it. The handle lives in `sessionStorage` so it dies with the tab, is single-use, and is valid only for the embed, origin, and visitor it was issued to. Declare it when a marketing site spreads one conversation across several pages; leave it off when anonymous conversation text should not survive a navigation at all.',
+        '',
         'Give every business action a portable `tool(..., { title: "Complete task", description: "This will mark the task complete for everyone.", input: z.object({ task: z.string().meta({ title: "Task" }) }) })` title. The standard confirmation uses the tool title/description plus schema field `title`, `description`, and `format`; it shows Confirm and Don\'t proceed and keeps technical action details secondary. `behavior.showConfirmationDetails` defaults to `true`; set it to `false` to remove only the built-in card\'s Additional details disclosure and connector mechanics. The business review and decisions remain, `confirm: true` still suspends until acceptance, and headless/BYO `data-confirmation` stays unchanged. Do not put JSON or implementation names in business-facing copy.',
         '',
         '## Configure and deploy',
@@ -249,39 +276,20 @@ export function renderEmbeddedAssistantReference() {
         '',
         'Read the customer repository lockfile or `packageManager` field and install `@noodleseed/assistant` with that existing package manager; never introduce a second lockfile.',
         '',
-        'Create an authenticated same-origin backend route:',
+        'Use the installed same-origin route and `createAssistantSessionHandler` from `@noodleseed/assistant/server`; do not regenerate guards, JSON parsing or token-exchange infrastructure. The only identity seam is `authenticateAssistantRequest` in `lib/noodle-assistant-auth.ts`.',
         '',
-        'The route must return a JSON `401` for a signed-out caller rather than an HTML login redirect, require JSON, and compare the request against the exact configured Origin before exchange. The managed renderer sends same-origin cookies but does not invent an application CSRF token. Treat JSON plus exact Origin as the minimum cookie/CSRF boundary; when the host keeps token-based CSRF middleware, use the DOM-free client with an injected `fetch` that supplies the token instead of exempting the route. Resolve claims and connector routes from the authenticated user and server-owned membership only.',
+        'The route must return a JSON `401` for a signed-out caller rather than an HTML login redirect, require JSON, and compare the request against the exact configured Origin before exchange. The managed renderer sends same-origin cookies but does not invent an application CSRF token. Preserve the host token-based CSRF middleware: inject a same-origin-only token fetch into the managed element before mounting, as the Django/Vue profile does; a custom renderer is not required. Invalid CSRF may correctly fail before authentication. Resolve claims and connector routes from the authenticated user and server-owned membership only.',
         '',
         'For the complete framework-neutral server-to-server HTTP exchange in a non-Node host, link to the [Django and Vue guide](https://docs.noodleseed.dev/docs/guides/embedded-assistant-django-vue); keep its framework-specific middleware and mounting mechanics there rather than copying them into agent instructions.',
         '',
-        '```ts',
-        'import { createAssistantSession } from "@noodleseed/assistant/server";',
-        '',
-        'export async function POST(request: Request) {',
-        '  const user = await requireCurrentUser(request);',
-        '  const { context } = await request.json();',
-        '  const session = await createAssistantSession({',
-        '    serviceUrl: process.env.NOODLE_SERVICE_URL!,',
-        '    clientId: process.env.NOODLE_ASSISTANT_CLIENT_ID!,',
-        '    clientSecret: process.env.NOODLE_ASSISTANT_CLIENT_SECRET!,',
-        '    origin: process.env.PUBLIC_APP_ORIGIN!,',
-        '    user: {',
-        '      id: user.id,',
-        '      email: user.email,',
-        '      roles: user.roles,',
-        '      scopes: user.scopes,',
-        '    },',
-        '    context,',
-        '    // Saved, backend-verified user preferences outrank browser hints.',
-        '    preferences: { locale: user.locale, timeZone: user.timeZone },',
-        '  });',
-        '  return Response.json(session);',
-        '}',
-        '```',
+        'Return `AssistantSessionIdentity | null` from the adapter. Null means signed out; service failure must throw rather than masquerade as signed out. Derive `user`, claims, preferences and routes from the existing verified session/membership. The maintained handler owns exact-Origin/JSON checks, bounded flat context, no-store JSON failures, a 15-second deadline, no redirects and no exchange retries. For mixed-mode continuation, return a `signInTicket` only from the backend-bound login transaction; never take it directly from browser JSON.',
+        '',
+        'For saved presentation preferences, return `preferences: { locale: user.locale, timeZone: user.timeZone }` beside the verified `user`. Omit unknown values; browser hints are not verified account preferences.',
         '',
         'Authenticate before exchange. Pass backend-verified `user.roles` and OAuth-style `user.scopes` separately; they govern the same per-tool authorization rules as verified MCP bearer claims. Source `origin` from trusted server configuration or strictly match the request origin against the same exact allowlist; never accept an arbitrary request header. Treat page context as untrusted model context, never authorization. Forward the helper response unchanged.',
         '',
+        "Run the generated `test/noodle-assistant.test.ts` with the application's Vitest runner (add the dev dependency using its existing package manager if absent). It tests the real generated route with synthetic identities. Separately exercise the real session function with signed-out, tenant-A, tenant-B and authorized fixtures before claiming integration proof. A green mock suite does not prove customer authorization.",
+        '',
         '`serviceUrl` is the Noodle Seed control-plane base URL: the value `noodle assistant clients create` prints, also stored as `serviceUrl` in `deployment.json`. It is NOT the deployment MCP endpoint (`url`, which ends in `/v1/mcp` and rejects session exchange). Never probe or guess endpoints with real credentials.',
         '',
         '### Route customer endpoints from the backend',

package/node_modules/@noodle-borg/agent-kit/dist/skill-server-playbook-ref.js

@@ -30,7 +30,7 @@ export function renderBuildAnMcpServerReference() {
         '5. **Author in TypeScript.** Follow `references/authoring-workflow.md` for connector and flow patterns, `references/tool-design.md` for the model-facing tool surface, and `references/sdk-surface.md` for exact builders. These are this route’s complete canonical support set; use the router lookup catalog only when observed evidence names a different concern.',
         '   MCP protocol versions are platform-owned and negotiated automatically at the serving endpoint. Do not add protocol-version settings to server options, `noodle.json`, app manifests, or deployment configuration.',
         '6. **Validate and repair.** Run `noodle validate --json`. Parse `error.errors[]`, repair the cited `path`, and rerun validation. Consult the lookup catalog only for the specific reported error code; do not open another reference speculatively.',
-        '7. **Run the local smoke.** After validation succeeds, run `noodle test --json` and repair any failure at that evidence layer.',
+        '7. **Run local behavior.** Start from the generated tests and run `npm test`: compile, tools/list, representative result and invalid-input rejection. `noodle test --json` without `--tool` is registration-only; repair failures before claiming a working capability.',
         '8. **Prove external behavior.** For connector-backed reads, set credentials through the effective local target and run a safe representative `noodle tools call`. Confirm populated mapped fields from real output, not merely successful registration.',
         '9. **Stop at the requested boundary.** Do not add an App, host test, hosted environment, publication work, or deployment unless the user requested that outcome. Deploy only when the selected route or the user explicitly requires it.',
         '',
@@ -40,7 +40,7 @@ export function renderBuildAnMcpServerReference() {
         '',
         '- **Authoring:** the requested TypeScript behavior exists with typed inputs and outputs, and the product-guide decision and reason are recorded.',
         '- **Compilation:** `noodle validate --json` returned success.',
-        '- **Local smoke:** `noodle test --json` returned success.',
+        '- **Local behavior:** the generated/adapted suite passed a representative call and a negative case. Synthetic fixtures prove only their configured behavior.',
         '- **Connector reality:** a representative safe read via `noodle tools call` returned populated mapped fields. This is required for connector-backed work.',
         '- **Higher levels:** explicitly report host, deployment, and production checks as not run unless they were separately requested and evidenced.',
         '',

package/node_modules/@noodle-borg/agent-kit/dist/skill-verification-ref.js

@@ -27,6 +27,7 @@ export function renderVerifyAndRecoverReference() {
         '1. **Compile** — the TypeScript build and authoring import surface are valid.',
         '2. **Validate** — `noodle validate --json` accepts the Noodle contract.',
         '3. **Local smoke** — `noodle test --json` starts the local runtime. Open apps exercise MCP registration; customer-auth apps must instead pass the anonymous 401 plus exact protected-resource metadata boundary and report `interactiveRequired: true`.',
+        '   To prove a safe read, explicitly supply `--tool <read_tool> --args <json>` or use `noodle tools call <read_tool> --args <json> --json`. These commands fail on protocol/tool errors, missing or incomplete results, and a declared output-schema mismatch. `input_required` is not completion: use Devtools for interactive input, never fabricate approval or retry an uncertain write.',
         '4. **Customer auth** — when customer auth is declared, run `noodle auth doctor src/server.ts --json` for metadata and JWKS readiness, then run `noodle devtools src/server.ts`, complete sign-in, and make one authenticated `tools/list` request or representative safe read. The doctor does not prove that registration or token issuance succeeds; the authenticated request proves issuer, signature, stable audience, and exact-resource binding together.',
         '5. **Real API** — a representative safe `noodle tools call` proves connector credentials, transport, observed mapping, and populated data.',
         '6. **App compliance** — `noodle check --json` and local devtools prove the App contract and intended states.',
@@ -57,7 +58,7 @@ export function renderVerifyAndRecoverReference() {
         '## Recovery paths',
         '',
         '- Compile/validation: repair the exact import, schema, or reported path, then rerun that command without freeform changes.',
-        '- Local boot/smoke: use the structured startup error to correct the effective target, config, or entrypoint before retrying.',
+        '- Local boot/smoke: use all reported missing variable and secret names and the exact-target recovery commands together. Values stay outside the diagnostic. `error.detail.reason` identifies incomplete/failed operation evidence; RPC message/data and continuation state are deliberately not copied. A failed response does not prove a write was rolled back.',
         '- Real API: distinguish authentication, reachability, legitimate empty results, and broken response mappings before changing code.',
         '- App: repair the cited contract or state in `noodle check --json`, then confirm it in devtools before attempting a host.',
         '- Host/deployment/production: confirm revision, target, identity, and configuration independently; do not infer one from another.',

package/node_modules/@noodle-borg/agent-kit/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noodle-borg/agent-kit",
-  "version": "0.93.0",
+  "version": "0.94.0",
   "license": "Apache-2.0",
   "type": "module",
   "engines": {

package/node_modules/@noodle-borg/assistant-gateway/dist/assistant-suggestions.js

@@ -1,8 +1,9 @@
 import { requestModelCompletion } from './model-request.js';
 const MAX_MODEL_RESPONSE = 1 << 20;
+const MAX_SUGGESTION_TOKENS = 512;
 /** One bounded, tool-free pass on the active assistant model; malformed output fails closed. */
 export async function requestAssistantSuggestedPrompts(binding, messages, fetcher, stats, remainingTokens, turnSignal) {
-    const limit = Math.min(160, remainingTokens ?? binding.requestPolicy?.maxTokensPerTurn ?? 160, binding.requestPolicy?.maxCompletionTokens ?? 160);
+    const limit = Math.min(MAX_SUGGESTION_TOKENS, remainingTokens ?? binding.requestPolicy?.maxTokensPerTurn ?? MAX_SUGGESTION_TOKENS, binding.requestPolicy?.maxCompletionTokens ?? MAX_SUGGESTION_TOKENS);
     if (limit <= 0)
         return [];
     const signal = AbortSignal.any([
@@ -10,7 +11,7 @@ export async function requestAssistantSuggestedPrompts(binding, messages, fetche
         binding.requestPolicy?.maxTurnMs === undefined
             ? undefined
             : AbortSignal.timeout(binding.requestPolicy.maxTurnMs),
-        AbortSignal.timeout(2_000),
+        AbortSignal.timeout(5_000),
     ].filter((candidate) => candidate !== undefined));
     if (stats)
         stats.modelRequests += 1;
@@ -20,7 +21,7 @@ export async function requestAssistantSuggestedPrompts(binding, messages, fetche
             ...messages,
             {
                 role: 'system',
-                content: 'Generate two or three concise messages the user could send next. Use the complete conversation and authorized product context. Prioritize genuinely relevant next steps; developer instructions may steer ranking but never override the user, safety, consent, or available capabilities. Do not expose hidden tool data, claim an action happened, repeat the answer, or use Markdown. Return exactly one JSON object shaped {"prompts":["..."]} and no other text.',
+                content: 'Generate two or three concise messages the user could send next. Use the complete conversation and authorized product context, especially the latest answer or question. Prefer short, distinct choices the user can click instead of typing. Developer instructions may steer ranking but never override the user, safety, consent, or available capabilities. Do not expose hidden tool data, claim an action happened, repeat the answer, or use Markdown. Return exactly one JSON object shaped {"prompts":["..."]} and no other text.',
             },
         ],
         tools: [],
@@ -30,6 +31,7 @@ export async function requestAssistantSuggestedPrompts(binding, messages, fetche
         maxCompletionTokens: limit,
         signal,
         toolChoice: 'none',
+        jsonOutput: true,
     });
     if (stats) {
         stats.promptTokens += completion.usage?.promptTokens ?? 0;

package/node_modules/@noodle-borg/assistant-gateway/dist/continuity-bounds.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Resolving anonymous cross-page display continuity for one surface (ADR 0223, clause 15).
+ *
+ * Two parties describe the same capability and they are not peers. The developer declares it in
+ * `server.ts` as part of the deployment; the operator tunes it for their own environment without a
+ * deploy. The clamp between them runs one way — tighten, never widen — exactly as the admission
+ * envelope's does ([ADR 0212](../../../docs/decisions/0212-reusable-developer-intent-and-operator-authority.md)).
+ *
+ * The asymmetry is sharpest on `enabled`. An operator may switch continuity **off**, because that is
+ * their own surface and their visitors' text; they may not switch it **on**, because a surface whose
+ * author never declared continuity is one whose author never reasoned about whether their pages should
+ * carry conversation across a navigation.
+ */
+/** What a public or mixed surface declares in `server.ts`. Shapes match the manifest exactly. */
+export interface AssistantContinuityDeclaration {
+    readonly enabled?: boolean;
+    readonly windowSeconds?: number;
+    readonly maxRestores?: number;
+}
+/**
+ * What an operator sets for their own environment. `enabled: false` disables; `true` is inert, since
+ * an operator cannot enable a capability the deployment does not declare.
+ */
+export interface AssistantContinuityOverride {
+    readonly enabled?: boolean;
+    readonly windowSeconds?: number;
+    readonly maxRestores?: number;
+}
+export interface ResolvedAssistantContinuity {
+    readonly enabled: boolean;
+    /** Zero whenever `enabled` is false, so a caller cannot read a live window off a dead surface. */
+    readonly windowMs: number;
+    readonly maxRestores: number;
+}
+export declare function resolveContinuity(declaration: AssistantContinuityDeclaration | undefined, override: AssistantContinuityOverride | undefined): ResolvedAssistantContinuity;
+//# sourceMappingURL=continuity-bounds.d.ts.map

package/node_modules/@noodle-borg/assistant-gateway/dist/continuity-bounds.js

@@ -0,0 +1,52 @@
+import { ASSISTANT_CONTINUITY_MAX_RESTORES, ASSISTANT_CONTINUITY_RESTORE_CEILING, ASSISTANT_CONTINUITY_WINDOW_CEILING_MS, ASSISTANT_CONTINUITY_WINDOW_MS, continuityMaxRestores, continuityWindowMs, } from './continuity-store.js';
+const OFF = { enabled: false, windowMs: 0, maxRestores: 0 };
+/**
+ * A declared bound that is not a non-negative integer fails the surface closed rather than falling back
+ * to the shipped default.
+ *
+ * This is deliberately the opposite of the spend ladder's malformed-allowance rule, which fails to
+ * *absent* because an outage costs more than a day of unbudgeted spend. The thing configured here is a
+ * capability, and the safe failure for a capability is not to exist: a typo that silently grants a
+ * 300-second window nobody asked for is worse than a typo that grants nothing.
+ */
+function boundedInteger(value) {
+    if (value === undefined)
+        return undefined;
+    return Number.isInteger(value) && value >= 0 ? value : 'invalid';
+}
+export function resolveContinuity(declaration, override) {
+    if (declaration?.enabled !== true)
+        return OFF;
+    if (override?.enabled === false)
+        return OFF;
+    const declaredWindow = boundedInteger(declaration.windowSeconds);
+    const declaredRestores = boundedInteger(declaration.maxRestores);
+    const overriddenWindow = boundedInteger(override?.windowSeconds);
+    const overriddenRestores = boundedInteger(override?.maxRestores);
+    if (declaredWindow === 'invalid' ||
+        declaredRestores === 'invalid' ||
+        overriddenWindow === 'invalid' ||
+        overriddenRestores === 'invalid') {
+        return OFF;
+    }
+    // Each side is clamped to the structural ceiling first, then the tighter of the two wins. Clamping
+    // before the `Math.min` means an over-eager operator value degrades to the ceiling rather than
+    // becoming one, which is the same shape `surfaceEnvelope` uses for daily budgets.
+    const windowMs = Math.min(declaredWindow === undefined
+        ? ASSISTANT_CONTINUITY_WINDOW_MS
+        : continuityWindowMs(declaredWindow * 1000), overriddenWindow === undefined
+        ? ASSISTANT_CONTINUITY_WINDOW_CEILING_MS
+        : continuityWindowMs(overriddenWindow * 1000));
+    const maxRestores = Math.min(declaredRestores === undefined
+        ? ASSISTANT_CONTINUITY_MAX_RESTORES
+        : continuityMaxRestores(declaredRestores), overriddenRestores === undefined
+        ? ASSISTANT_CONTINUITY_RESTORE_CEILING
+        : continuityMaxRestores(overriddenRestores));
+    // Zero from either party is a real value and is the kill switch, so it must not read as "unset".
+    // Collapsing it to `OFF` here keeps every caller from having to remember that a zero-length window
+    // and a disabled surface are the same thing.
+    if (windowMs === 0 || maxRestores === 0)
+        return OFF;
+    return { enabled: true, windowMs, maxRestores };
+}
+//# sourceMappingURL=continuity-bounds.js.map

package/node_modules/@noodle-borg/assistant-gateway/dist/continuity-store.d.ts

@@ -0,0 +1,115 @@
+import type { TenantRef } from './tenant-ref.js';
+/**
+ * Anonymous cross-page display continuity (ADR 0223, clauses 11-16).
+ *
+ * **A display handle, not a session.** Claiming one returns the conversation's visible text for
+ * rendering and mints a fresh session; it never revives the original, and grants no tool authority, no
+ * share of a spent turn budget, and no bound surface. Deliberately unlike the authenticated reattach in
+ * clause 7, it restores no view descriptor and no pending interaction — a capability that survives a
+ * navigation is exactly what this design refuses to create.
+ *
+ * **Its bounds are shaped by one asymmetry.** A sign-in ticket is safe partly because possession alone
+ * is worthless: spending one also requires the customer's client credentials, held server-side. An
+ * anonymous visitor has no such credential and no server-side counterpart, so possession of a handle is
+ * *sufficient by itself*. Hence four independent bounds — single use, a short window, binding to the
+ * context it was issued to, and a chain that ends — rather than any one of them carrying the weight.
+ */
+/** What a handle is bound to. All three are hashes; no raw origin or visitor id is ever stored. */
+export interface AssistantContinuityContext {
+    readonly embedId: string;
+    readonly originHash: string;
+    readonly visitorHash: string;
+}
+export interface AssistantContinuityRecord {
+    readonly id: string;
+    readonly sessionId: string;
+    readonly tenant: TenantRef;
+    readonly context: AssistantContinuityContext;
+    readonly handleHash: string;
+    /** Restores already spent on this conversation, carried across every rotation. */
+    readonly restoreCount: number;
+    /** Clamped at issue time and stored, so a record describes its own limit rather than trusting a caller. */
+    readonly maxRestores: number;
+    readonly createdAt: string;
+    readonly expiresAt: string;
+    readonly claimedAt?: string;
+}
+export type AssistantContinuityClaim = {
+    readonly ok: true;
+    readonly record: AssistantContinuityRecord;
+    /**
+     * The rotated handle for the next navigation, or `undefined` once the chain is spent. Withholding
+     * it is how continuity ends: the visitor still sees the text they were promised, and the next page
+     * simply has nothing to present, so no refusal code is needed for an ordinary ending.
+     */
+    readonly handle?: string;
+} | {
+    readonly ok: false;
+    /**
+     * One code per refusal, because they are operationally different: `unknown` is a bad or already
+     * spent handle, `expired` is a visitor who took too long, and `context_mismatch` is a handle
+     * presented from an embed, origin, or visitor it was not issued to — the exfiltration signal, and
+     * the one worth alerting on, so it must not collapse into the first.
+     */
+    readonly reason: 'unknown' | 'expired' | 'context_mismatch';
+};
+/** Five minutes: long enough to read a page before clicking through, short enough to bound a leak. */
+export declare const ASSISTANT_CONTINUITY_WINDOW_MS: number;
+/**
+ * Ten minutes, the sign-in ticket's own TTL: an anonymous display handle must never outlive the
+ * authenticated capability it is modelled on, whatever a developer or operator asks for.
+ */
+export declare const ASSISTANT_CONTINUITY_WINDOW_CEILING_MS: number;
+/** Three restores covers the engaged visitor's page depth without letting a chain run indefinitely. */
+export declare const ASSISTANT_CONTINUITY_MAX_RESTORES = 3;
+/** Past ten, chain length stops being a meaningful control, so no configuration may exceed it. */
+export declare const ASSISTANT_CONTINUITY_RESTORE_CEILING = 10;
+export declare function continuityWindowMs(requested?: number): number;
+export declare function continuityMaxRestores(requested?: number): number;
+export interface AssistantContinuityStore {
+    /**
+     * Issue this session's handle for the next navigation, superseding any unclaimed one so a
+     * conversation never accumulates one live key per turn.
+     *
+     * Returns `undefined` when the effective window or chain clamps to zero. The kill switch is enforced
+     * here rather than at the call site, so a caller that forgets to check cannot hand out a handle the
+     * operator has switched off.
+     */
+    issue(input: {
+        readonly sessionId: string;
+        readonly tenant: TenantRef;
+        readonly context: AssistantContinuityContext;
+        readonly windowMs?: number;
+        readonly maxRestores?: number;
+        readonly now: Date;
+    }): Promise<{
+        readonly record: AssistantContinuityRecord;
+        readonly handle: string;
+    } | undefined>;
+    /**
+     * Spend a handle exactly once, rotating to a fresh one until the chain is spent. Atomic: two backends
+     * racing the same value must not both win, which is why this is one store seam rather than a
+     * read-then-write in the route.
+     */
+    claim(input: {
+        readonly handle: string;
+        readonly context: AssistantContinuityContext;
+        readonly now: Date;
+    }): Promise<AssistantContinuityClaim>;
+    /**
+     * Drop spent and expired rows, returning how many went.
+     *
+     * Retention belongs to this store rather than to a caller that may forget: handles are short-lived and
+     * must be swept, not accumulated. Cleanup may lag expiry safely, because `claim` already refuses a
+     * stale handle — the sweep bounds the table, it does not enforce the window.
+     */
+    sweepExpired(input: {
+        readonly now: Date;
+    }): Promise<number>;
+}
+export declare function continuityHandle(): string;
+export declare function continuityDigest(value: string): string;
+export declare function continuityHashesEqual(left: string, right: string): boolean;
+/** Every leg must match: a handle is only valid for the embed, origin, and visitor it was issued to. */
+export declare function sameContinuityContext(left: AssistantContinuityContext, right: AssistantContinuityContext): boolean;
+//# sourceMappingURL=continuity-store.d.ts.map

package/node_modules/@noodle-borg/assistant-gateway/dist/continuity-store.js

@@ -0,0 +1,51 @@
+import { createHash, randomBytes, timingSafeEqual } from 'node:crypto';
+/** Five minutes: long enough to read a page before clicking through, short enough to bound a leak. */
+export const ASSISTANT_CONTINUITY_WINDOW_MS = 5 * 60 * 1000;
+/**
+ * Ten minutes, the sign-in ticket's own TTL: an anonymous display handle must never outlive the
+ * authenticated capability it is modelled on, whatever a developer or operator asks for.
+ */
+export const ASSISTANT_CONTINUITY_WINDOW_CEILING_MS = 10 * 60 * 1000;
+/** Three restores covers the engaged visitor's page depth without letting a chain run indefinitely. */
+export const ASSISTANT_CONTINUITY_MAX_RESTORES = 3;
+/** Past ten, chain length stops being a meaningful control, so no configuration may exceed it. */
+export const ASSISTANT_CONTINUITY_RESTORE_CEILING = 10;
+/**
+ * Clamp a requested bound the way the admission envelope does: one direction only.
+ *
+ * Zero is the deploy-free kill switch, and anything malformed — negative, fractional, NaN — collapses to
+ * zero rather than to the default. A typo must fail closed here: unlike a spend allowance, where an
+ * outage is worse than a day of unbudgeted cost, a continuity handle is a capability, and the safe
+ * failure for a capability is not to exist.
+ */
+function clampBound(requested, fallback, ceiling) {
+    if (requested === undefined)
+        return fallback;
+    if (!Number.isInteger(requested) || requested < 0)
+        return 0;
+    return Math.min(requested, ceiling);
+}
+export function continuityWindowMs(requested) {
+    return clampBound(requested, ASSISTANT_CONTINUITY_WINDOW_MS, ASSISTANT_CONTINUITY_WINDOW_CEILING_MS);
+}
+export function continuityMaxRestores(requested) {
+    return clampBound(requested, ASSISTANT_CONTINUITY_MAX_RESTORES, ASSISTANT_CONTINUITY_RESTORE_CEILING);
+}
+export function continuityHandle() {
+    return `cnt_${randomBytes(24).toString('base64url')}`;
+}
+export function continuityDigest(value) {
+    return createHash('sha256').update(value).digest('hex');
+}
+export function continuityHashesEqual(left, right) {
+    const a = Buffer.from(left, 'utf8');
+    const b = Buffer.from(right, 'utf8');
+    return a.length === b.length && timingSafeEqual(a, b);
+}
+/** Every leg must match: a handle is only valid for the embed, origin, and visitor it was issued to. */
+export function sameContinuityContext(left, right) {
+    return (left.embedId === right.embedId &&
+        left.originHash === right.originHash &&
+        left.visitorHash === right.visitorHash);
+}
+//# sourceMappingURL=continuity-store.js.map

package/node_modules/@noodle-borg/assistant-gateway/dist/in-memory-continuity-store.d.ts

@@ -0,0 +1,26 @@
+import { type AssistantContinuityClaim, type AssistantContinuityContext, type AssistantContinuityRecord, type AssistantContinuityStore } from './continuity-store.js';
+import type { TenantRef } from './tenant-ref.js';
+/** The in-memory half of the pair. Both run the shared parity suite; neither is the only proof. */
+export declare class InMemoryAssistantContinuityStore implements AssistantContinuityStore {
+    #private;
+    issue(input: {
+        readonly sessionId: string;
+        readonly tenant: TenantRef;
+        readonly context: AssistantContinuityContext;
+        readonly windowMs?: number;
+        readonly maxRestores?: number;
+        readonly now: Date;
+    }): Promise<{
+        readonly record: AssistantContinuityRecord;
+        readonly handle: string;
+    } | undefined>;
+    claim(input: {
+        readonly handle: string;
+        readonly context: AssistantContinuityContext;
+        readonly now: Date;
+    }): Promise<AssistantContinuityClaim>;
+    sweepExpired(input: {
+        readonly now: Date;
+    }): Promise<number>;
+}
+//# sourceMappingURL=in-memory-continuity-store.d.ts.map