@konneal/engine 0.2.33 → 0.2.35

package/dist/{chunk-WSLADX7O.js → chunk-YSWKFXXG.js}

@@ -8,15 +8,17 @@ import {
   contextNote,
   editionNote,
   embed,
-  exchangeForLiveToken,
   generateOnce,
   graphExpand,
   identityNote,
   listwiseRerank,
   liveDataConfig,
+  liveTokenFor,
+  machineOffers,
   namedDocumentIn,
   parseContext,
   portModelRunner,
+  portStore,
   rawSessionToken,
   refCodec,
   resolveDocScope,
@@ -28,14 +30,14 @@ import {
   syntheticUnderstanding,
   telemetry,
   understandQuery
-} from "./chunk-NHHQAGBW.js";
+} from "./chunk-GHDRKT4K.js";
 import {
   corsHeaders,
   err,
   json,
   readJson,
   validateQuery
-} from "./chunk-2RKYO3OC.js";
+} from "./chunk-R2V3X6SQ.js";
 import {
   canonicalRefusal,
   refusalAnswer
@@ -43,8 +45,9 @@ import {
 import {
   entitlementScope,
   requestSalt,
-  resolveRequestScope
-} from "./chunk-JGKSUSF5.js";
+  resolveRequestScope,
+  standardKeysFrom
+} from "./chunk-4GJGBGJK.js";
 import {
   LIMITS,
   MODELS,
@@ -54,7 +57,7 @@ import {
   requestEffort,
   roleModel,
   sha256Hex
-} from "./chunk-OMXAE27N.js";
+} from "./chunk-V46XM2GU.js";
 import {
   P
 } from "./chunk-3FYJM7LH.js";
@@ -1196,6 +1199,11 @@ ${transcript}` }
 }
 var norm = (s) => s.toLowerCase().replace(/[^a-z0-9-]+/g, " ").replace(/\s+/g, " ").trim();
 var docNorm = (s) => norm(s).replace(/\s+/g, "");
+function valueTracesToUser(value, userTurns) {
+  if (typeof value !== "string" || !value.trim()) return false;
+  const haystack = norm(userTurns.join("\n"));
+  return haystack.includes(norm(value));
+}
 var DROP_REASON = "not stated in your own words";
 function traceabilityGuard(extraction, userTurns) {
   const haystack = norm(userTurns.join("\n"));
@@ -1385,6 +1393,263 @@ The draft opens in the real application form with every field editable \u2014 re
   };
 }
 
+// workers/worker_public/src/apicalls.ts
+function actsProfile() {
+  const acts = P().publisher?.acts;
+  return acts && typeof acts === "object" ? acts : null;
+}
+function neverOffered(path) {
+  const prefixes = actsProfile()?.never_offer ?? [];
+  return prefixes.some((p) => typeof p === "string" && path.startsWith(p));
+}
+async function operationById(store, id) {
+  try {
+    return await store.prepare("SELECT operation_id, method, path, act_class, summary, tag FROM api_ops WHERE operation_id = ?1").bind(id).first();
+  } catch {
+    return null;
+  }
+}
+async function operationByMethodPath(store, method, path) {
+  try {
+    return await store.prepare("SELECT operation_id, method, path, act_class, summary, tag FROM api_ops WHERE method = ?1 AND path = ?2").bind(method.toLowerCase(), path).first();
+  } catch {
+    return null;
+  }
+}
+async function preferenceOps(store) {
+  try {
+    const rows = await store.prepare("SELECT operation_id, method, path, act_class, summary, tag FROM api_ops WHERE act_class = 'preference' ORDER BY operation_id LIMIT 32").bind().all();
+    return rows.results ?? [];
+  } catch {
+    return [];
+  }
+}
+function resolveEntityRoute(route) {
+  const patterns = actsProfile()?.entity_routes ?? [];
+  if (!route) return null;
+  const segs = route.split("?")[0].split("/").filter(Boolean);
+  for (const p of patterns) {
+    const psegs = String(p.pattern ?? "").split("/").filter(Boolean);
+    if (psegs.length !== segs.length) continue;
+    let id = null;
+    let ok = true;
+    for (let i = 0; i < psegs.length; i++) {
+      const ps = psegs[i];
+      if (ps.startsWith(":")) {
+        id = decodeURIComponent(segs[i]);
+      } else if (ps !== segs[i]) {
+        ok = false;
+        break;
+      }
+    }
+    if (ok && id && id.length <= 120 && /^[A-Za-z0-9._~-]+$/.test(id)) return { store: String(p.store), id };
+  }
+  return null;
+}
+var MACHINE_INTENT_RE = /\b(accept|reject|submit|resubmit|withdraw|suspend|reinstate|renew|revise|transfer|issue|register|log|record|dispatch|complete|sign|approve|verify)\b[\s\S]{0,40}\b(this|that|the|it)\b|\b(this|that|the|it)\b[\s\S]{0,40}\b(accept|reject|submit|resubmit|withdraw|suspend|reinstate|renew|revise|transfer|issue|register|log|dispatch|complete|sign|approve|verify)\b/i;
+var PREFERENCE_INTENT_RE = /\b(mute|unmute|unsubscribe|subscribe|notification prefs?|notification rules?|email prefs?|email preferences|saved? filters?|save (?:this|the|that) filter|notify me|stop notifying|inbox)\b/i;
+var QUESTION_OPENER_RE = /^\s*(?:what|how|why|where|when|which|who|whose|explain|describe|define|is|are|does|do)\b/i;
+function detectApiCallIntent(query, declared) {
+  if (QUESTION_OPENER_RE.test(query)) return null;
+  if (declared?.kind === "entity" && declared.machine && MACHINE_INTENT_RE.test(query)) return "machine_act";
+  if (PREFERENCE_INTENT_RE.test(query)) return "preference";
+  return null;
+}
+function pickPrompt(kind, candidates) {
+  if (kind === "machine_act") {
+    return {
+      system: `You map the user's request to one machine act from the OFFERED list, or to none.
+
+Rules:
+- Output ONLY a JSON object \u2014 no prose, no code fence: {"target": "<action id or null>", "title": "<what the act does, plain words>"}.
+- The target must be one of the offered action ids, copied exactly, or null when the request matches none.
+- The title names what the act DOES for the user ("Accept the application"), never the wire (no method, no path, no "/api/").
+- Never invent an act that is not listed.
+
+Offered acts (action id \u2014 lands the entity on):
+${candidates.join("\n")}`,
+      max: 300
+    };
+  }
+  return {
+    system: `You map the user's request to one operation from the PREFERENCE list (the user's own settings), or to none.
+
+Rules:
+- Output ONLY a JSON object \u2014 no prose, no code fence: {"target": "<operation id or null>", "title": "<what the act does, plain words>", "body": {...}}.
+- The target must be one of the listed operation ids, copied exactly, or null when the request matches none.
+- "body" carries only values the user stated in their own words; omit it when the request names no values.
+- The title names what the act DOES for the user ("Save the filter", "Mute these emails"), never the wire (no method, no path, no "/api/").
+- Never invent an operation that is not listed.
+
+Preference operations (id \u2014 method path \u2014 summary):
+${candidates.join("\n")}`,
+    max: 800
+  };
+}
+async function pickTarget(runner, model, kind, candidates, userTurns) {
+  const { system, max } = pickPrompt(kind, candidates);
+  const transcript = userTurns.map((t, i) => `${i + 1}. ${t}`).join("\n").slice(0, 8e3);
+  try {
+    const res = await runner.run({
+      model,
+      messages: [
+        { role: "system", content: system },
+        { role: "user", content: `The user's messages, oldest first:
+${transcript}` }
+      ],
+      maxTokens: max,
+      effort: "low",
+      temperature: 0.1
+    });
+    const text = res.text;
+    if (typeof text !== "string") return null;
+    const start = text.indexOf("{");
+    const end = text.lastIndexOf("}");
+    if (start < 0 || end <= start) return null;
+    const parsed = JSON.parse(text.slice(start, end + 1));
+    if (!parsed || typeof parsed !== "object") return null;
+    return {
+      target: typeof parsed.target === "string" && parsed.target.trim() ? parsed.target.trim().slice(0, 120) : null,
+      title: typeof parsed.title === "string" && parsed.title.trim() ? parsed.title.trim().slice(0, 120) : void 0,
+      body: parsed.body && typeof parsed.body === "object" ? parsed.body : void 0
+    };
+  } catch {
+    return null;
+  }
+}
+function honestTitle(proposed, fallback) {
+  const t = (proposed ?? "").trim();
+  if (!t) return fallback;
+  if (/\b(GET|POST|PUT|PATCH|DELETE)\b/.test(t) || t.includes("/api/") || t.includes("{")) return fallback;
+  return t.slice(0, 120);
+}
+function bodyTraces(body, userTurns) {
+  if (body == null) return true;
+  if (typeof body === "boolean" || typeof body === "number") return true;
+  if (typeof body === "string") return valueTracesToUser(body, userTurns);
+  if (Array.isArray(body)) return body.every((v) => bodyTraces(v, userTurns));
+  if (typeof body === "object") return Object.values(body).every((v) => bodyTraces(v, userTurns));
+  return false;
+}
+function refusal2(reason, answer) {
+  return { status: "refused", reason, answer };
+}
+async function prepareApiCall(env, opts) {
+  if (!opts.member) {
+    return refusal2(
+      "sign_in_required",
+      "Preparing an act starts from your own account \u2014 sign in and ask again. The draft would still be yours alone: the card asks for your confirmation, and only your own tap executes it \u2014 I never hold a write credential."
+    );
+  }
+  const acts = actsProfile();
+  const store = portStore(env);
+  const runner = portModelRunner(env);
+  const userTurns = [...opts.history.filter((h) => h.role === "user").map((h) => h.content), opts.query];
+  if (opts.intent === "machine_act") {
+    const machine = opts.declared?.machine;
+    const label = opts.declared?.label || "this record";
+    if (!machine) {
+      return refusal2("no_matching_act", "This page did not declare the record's lifecycle state, so I cannot propose an act on it honestly. Open the record itself and ask again, or act from the platform's own controls \u2014 they always show exactly what your role may do.");
+    }
+    if (machine.acts.length === 0) {
+      return refusal2(
+        "machine_read_only",
+        `The record's lifecycle is at ${machine.state}, and the machine offers your role no acts there \u2014 you can read this record but not act on it. Nothing was drafted. If that looks wrong, an officer of your organization can check the role your account carries.`
+      );
+    }
+    const entity = resolveEntityRoute(opts.declared?.route);
+    if (!entity) {
+      return refusal2("entity_unresolved", "I cannot tell which record the act would land on from this page, so nothing was drafted. The platform's own controls on the record always act on the right one.");
+    }
+    const candidates2 = machine.acts.map((a) => `${a.action} \u2014 lands on ${a.to}${a.guard ? ` (requires ${a.guard})` : ""}`);
+    const pick2 = await pickTarget(runner, opts.model, "machine_act", candidates2, userTurns);
+    if (!pick2) {
+      return refusal2("pick_failed", "I could not map your request to an act reliably just now \u2014 nothing was drafted. Ask again in a moment, or act from the platform's own controls.");
+    }
+    if (!pick2.target || !machineOffers(machine, pick2.target)) {
+      const offered = machine.acts.map((a) => a.action).join(", ");
+      return refusal2(
+        "no_matching_act",
+        `None of the acts the machine offers your role at ${machine.state} matches that request \u2014 the offered set is exactly: ${offered}. I never propose an act outside it. Nothing was drafted.`
+      );
+    }
+    const act = machine.acts.find((a) => a.action === pick2.target);
+    const write = acts?.entity_write;
+    if (!write?.method || !write?.path) {
+      return refusal2("operation_unknown", "This deployment has not wired the entity write operation, so I cannot prepare the act here.");
+    }
+    const op2 = await operationByMethodPath(store, write.method, write.path);
+    if (!op2) {
+      return refusal2("operation_unknown", "The act's operation is not in this deployment's API directory, so I cannot prepare it honestly \u2014 nothing was drafted.");
+    }
+    if (neverOffered(op2.path)) {
+      return refusal2("operation_never_offered", "That act is not one the assistant may propose \u2014 nothing was drafted.");
+    }
+    const path = write.path.replace("{store}", entity.store).replace("{id}", entity.id);
+    const title2 = honestTitle(pick2.title, `${act.action} \u2014 ${label}`.slice(0, 120));
+    const notes = [
+      `The machine act ${act.action} moves the record from ${machine.state} to ${act.to}; the platform re-judges the act against the machine and your role when you confirm.`,
+      ...act.guard ? [`This act declares the ${act.guard} input \u2014 the confirmation card collects it; the draft carries none.`] : []
+    ];
+    const draft2 = {
+      kind: "draft",
+      act: "api_call",
+      version: 1,
+      title: title2,
+      prepared_at: (/* @__PURE__ */ new Date()).toISOString(),
+      requires_confirmation: true,
+      call: { method: write.method, path, body: { status: act.to } },
+      notes
+    };
+    const answer2 = `I've prepared the act "${title2}" for ${label}: the machine act ${act.action}, from ${machine.state} to ${act.to}.
+
+The confirmation card carries it \u2014 a record act, so your own confirmation signs it and the platform's gates judge the write as you. I never hold a write credential, and I never propose an act the machine does not offer your role.`;
+    return { status: "draft", draft: draft2, answer: answer2 };
+  }
+  const family = (await preferenceOps(store)).filter((o) => !neverOffered(o.path));
+  if (!family.length) {
+    return refusal2("operation_unknown", "This deployment's API directory lists no preference operations, so I cannot prepare that here \u2014 nothing was drafted.");
+  }
+  const candidates = family.map((o) => `${o.operation_id} \u2014 ${o.method.toUpperCase()} ${o.path} \u2014 ${o.summary ?? ""}`.slice(0, 300));
+  const pick = await pickTarget(runner, opts.model, "preference", candidates, userTurns);
+  if (!pick) {
+    return refusal2("pick_failed", "I could not map your request to a preference act reliably just now \u2014 nothing was drafted. Ask again in a moment, or change the setting on your account page directly.");
+  }
+  if (!pick.target) {
+    return refusal2("no_matching_act", "None of the preference acts I may propose matches that request \u2014 nothing was drafted. Your account's settings page carries the full set.");
+  }
+  const op = await operationById(store, pick.target);
+  if (!op || op.act_class !== "preference") {
+    return refusal2("operation_unknown", "I cannot match that request to a preference act the platform declares \u2014 nothing was drafted.");
+  }
+  if (neverOffered(op.path)) {
+    return refusal2("operation_never_offered", "That act is not one the assistant may propose \u2014 delegation and sign-in acts stay in your own hands on the settings page. Nothing was drafted.");
+  }
+  if (pick.body !== void 0 && !bodyTraces(pick.body, userTurns)) {
+    return refusal2(
+      "body_untraced",
+      "I can't prepare that change because the values I would set are not ones you stated \u2014 I never invent settings. Tell me exactly what to set, in your own words, and I'll prepare the draft."
+    );
+  }
+  const title = honestTitle(pick.title, (op.summary ?? op.operation_id).slice(0, 120));
+  const draft = {
+    kind: "draft",
+    act: "api_call",
+    version: 1,
+    title,
+    prepared_at: (/* @__PURE__ */ new Date()).toISOString(),
+    requires_confirmation: true,
+    call: { method: op.method.toUpperCase(), path: op.path, ...pick.body !== void 0 ? { body: pick.body } : {} },
+    notes: [
+      "A preference act: with your standing grant the card executes it straight away; without one, your own tap on the card confirms it. The grant is yours on the settings page \u2014 granted or revoked by your hand, never by a message."
+    ]
+  };
+  const answer = `I've prepared the act "${title}" \u2014 a preference act on your own settings.
+
+With your standing grant it executes under the grant's authority; without one, the card asks once and your tap confirms it. The platform re-checks the act against its own specification either way, and the grant never covers record acts.`;
+  return { status: "draft", draft, answer };
+}
+
 // workers/worker_public/src/memories.ts
 var MAX_FILES = 10;
 var MAX_CONTENT = 8e3;
@@ -1629,6 +1894,7 @@ async function handleAsk(env, ctx, req, tier, key) {
   if (!q) return err(400, "invalid_input", `query is required (1-${LIMITS.maxInputChars} chars)`);
   const declaredCtx = parseContext(body);
   const draftAct = P().publisher.features?.drafts ? detectDraftIntent(q.query) : null;
+  const apiCallIntent = !draftAct && P().publisher.features?.api_call_drafts ? detectApiCallIntent(q.query, declaredCtx) : null;
   const member = tier === "member" ? await sessionFrom(req, env) : null;
   const effort = requestEffort(env, member, body?.effort);
   const limit = tier === "key" ? key.day_limit : tier === "member" || member ? num(env, "MEMBER_DAY_ASK", 300) : num(env, "ANON_DAY_ASK", 20);
@@ -1649,14 +1915,15 @@ async function handleAsk(env, ctx, req, tier, key) {
     cookie: req.headers.get("cookie") ?? "",
     authorization: req.headers.get("authorization") ?? ""
   };
-  const scope = resolveRequestScope(body, member);
+  const keyLicensed = tier === "key" && standardKeysFrom(body).size > 0;
+  const scope = resolveRequestScope(body, member, { keyWithEntitlements: keyLicensed });
   if ("error" in scope) return err(400, "invalid_input", "datasets: at least one dataset must stay enabled");
   const { corpora, narrowed, isoOn } = scope;
   const standardKeys = entitlementScope(scope.standardKeys);
   const [memNote, memoryUsed] = member && scope.memoryIds.length ? await memoryNote(env, member.sub, scope.memoryIds) : [null, []];
   const requestSaltStr = requestSalt(scope, memoryUsed);
   const salt = requestSaltStr ? `${requestSaltStr}|effort:${effort}` : `effort:${effort}`;
-  const federate = member && service && isoOn ? (q2) => retrieveInternal(service, fedAuth, q2) : void 0;
+  const federate = (member || keyLicensed) && service && isoOn ? (q2) => retrieveInternal(service, fedAuth, q2) : void 0;
   const ns = tier === "key" ? `k:${key.id}` : member ? `m:${member.sub}` : "anon";
   const model = member ? MODELS.member : MODELS.anon;
   const prev = typeof body?.prev === "string" ? body.prev.slice(0, 800) : void 0;
@@ -1673,7 +1940,7 @@ async function handleAsk(env, ctx, req, tier, key) {
   let retrieved;
   const fresh = freshRequested(body);
   const gen = await corpusGen(env.CACHE);
-  const cached = fresh || contextual || declaredCtx || draftAct || userImage ? null : await cacheGet(env, gen, ns, q.query, q.lang, salt);
+  const cached = fresh || contextual || declaredCtx || draftAct || apiCallIntent || userImage ? null : await cacheGet(env, gen, ns, q.query, q.lang, salt);
   const wantsStream = body?.stream === true || tier === "anon" && body?.stream !== false;
   if (cached) {
     telemetry(env, ctx, tier, "ask", null, true, (cached.value.answer ?? "").length, cached.value.query_hash, q.lang, "exact", telemetryMeta());
@@ -1697,7 +1964,7 @@ async function handleAsk(env, ctx, req, tier, key) {
   }
   let understanding = null;
   const nodeScoped = !!modelNodeRefIn(q.query) || !!modelNodeRefIn(declaredCtx?.label);
-  if (!cached && !nodeScoped && !contextual && !declaredCtx && !draftAct && !q.lang && !userImage && !fresh) {
+  if (!cached && !nodeScoped && !contextual && !declaredCtx && !draftAct && !apiCallIntent && !q.lang && !userImage && !fresh) {
     const wv0 = await warmEmbed ?? null;
     if (wv0) {
       const sc0 = await semanticCacheGet(env, gen, wv0, salt);
@@ -1795,7 +2062,7 @@ async function handleAsk(env, ctx, req, tier, key) {
   console.log("understand:", understanding?.intent ?? "null", understanding?.doc_number ? `doc#${understanding.doc_number}${understanding.edition ? "@" + understanding.edition : ""}` : "nodoc", "|", q.query.slice(0, 50));
   const graphDocNumbers = await graphExpand(env, understanding);
   const eNote = await editionNote(env, understanding);
-  if (understanding?.intent !== "conversational" && !nodeScoped && !contextual && !declaredCtx && !draftAct && !userImage && !fresh) {
+  if (understanding?.intent !== "conversational" && !nodeScoped && !contextual && !declaredCtx && !draftAct && !apiCallIntent && !userImage && !fresh) {
     const warmVec = await warmEmbed ?? null;
     if (warmVec) {
       const sc = await semanticCacheGet(env, gen, warmVec, salt);
@@ -1871,7 +2138,7 @@ ${summary}` }] : [],
     if (!member || !sessionRaw) delegation = { status: "unsigned" };
     else if (!liveCfg) delegation = { status: "not_configured" };
     else {
-      const exchanged = await exchangeForLiveToken(env, sessionRaw);
+      const exchanged = await liveTokenFor(env, sessionRaw, member);
       delegation = exchanged.ok ? { status: "ok", token: exchanged.token } : { status: exchanged.reason };
     }
     const verdict = await prepareDraft(env, {
@@ -1900,6 +2167,33 @@ ${summary}` }] : [],
     }
     return json({ answer: verdict.answer, citations: citations2, model, query_hash: queryHash2, follow_ups: [], context_applied: draftCtxApplied, read: readAs(), ...draftPayload ? { draft: draftPayload } : {}, quota });
   }
+  if (apiCallIntent) {
+    const callCtxApplied = declaredCtx ? appliedContext(declaredCtx, null) : NO_CONTEXT;
+    const queryHash2 = await sha256Hex(q.query);
+    const verdict = await prepareApiCall(env, {
+      intent: apiCallIntent,
+      query: q.query,
+      history: keptHistory,
+      member,
+      declared: declaredCtx,
+      model: roleModel(env, "acts")
+    });
+    console.log("api_call draft:", apiCallIntent, "\u2192", verdict.status === "draft" ? `draft (${verdict.draft.call.method} ${verdict.draft.call.path})` : `refused (${verdict.reason})`);
+    const draftPayload = verdict.status === "draft" ? verdict.draft : void 0;
+    telemetry(env, ctx, tier, "ask", model, true, verdict.answer.length, queryHash2, q.lang, void 0, telemetryMeta());
+    if (wantsStream) {
+      return sseResponse(
+        [
+          ...readAs() ? [{ type: "read", read: readAs() }] : [],
+          { type: "citations", citations: [], context_applied: callCtxApplied, ...draftPayload ? { draft: draftPayload } : {}, quota },
+          { type: "token", v: verdict.answer },
+          { type: "done", model, query_hash: queryHash2, context_applied: callCtxApplied, read: readAs() }
+        ],
+        corsHeaders(req)
+      );
+    }
+    return json({ answer: verdict.answer, citations: [], model, query_hash: queryHash2, follow_ups: [], context_applied: callCtxApplied, read: readAs(), ...draftPayload ? { draft: draftPayload } : {}, quota });
+  }
   let liveRecords;
   let accountNote;
   const modelDocHint = named ?? docScope ?? namedDocumentIn(q.query);

package/dist/{chunk-5LSEBH3J.js → chunk-Z7AQEW6G.js}

@@ -7,24 +7,24 @@ import {
   sessionFrom,
   telemetry,
   understandQuery
-} from "./chunk-NHHQAGBW.js";
+} from "./chunk-GHDRKT4K.js";
 import {
   corsHeaders,
   err,
   json,
   readJson,
   validateQuery
-} from "./chunk-2RKYO3OC.js";
+} from "./chunk-R2V3X6SQ.js";
 import {
   entitlementScope,
   standardKeysFrom
-} from "./chunk-JGKSUSF5.js";
+} from "./chunk-4GJGBGJK.js";
 import {
   LIMITS,
   MODELS,
   num,
   sha256Hex
-} from "./chunk-OMXAE27N.js";
+} from "./chunk-V46XM2GU.js";
 
 // workers/worker_public/src/search.ts
 async function handleSearch(env, ctx, req, tier, key) {

package/dist/config.d.ts

@@ -4,6 +4,7 @@ export declare const MODELS: {
     readonly anon: "@cf/zai-org/glm-5.3-flash";
     readonly member: "@cf/zai-org/glm-5.3-flash";
     readonly understand: "@cf/qwen/qwen3-30b-a3b-fp8";
+    readonly acts: "@cf/qwen/qwen3-30b-a3b-fp8";
     readonly fallback: "@cf/qwen/qwen3-30b-a3b-fp8";
     readonly grader: "@cf/deepseek-ai/deepseek-v4-flash-0731";
     readonly enrich: "@cf/deepseek-ai/deepseek-v4-pro-0813";

package/dist/context.d.ts

@@ -1,3 +1,25 @@
+/** One act the declared entity's lifecycle machine offers at its current
+ *  state, FOR THE DECLARING USER'S ROLE (the platform filters before
+ *  publishing; the wire is advisory — the platform re-validates every
+ *  proposed act authoritatively on the way back). */
+export interface MachineAct {
+    /** the machine's own action id (the model's vocabulary) */
+    action: string;
+    /** the state the act lands the entity on */
+    to: string;
+    /** the declared guard (the caller-supplied computed input the
+     *  transition requires), when the transition declares one */
+    guard?: string;
+}
+/** The affordance channel (TODO.ai-platform/08): the entity declaration's
+ *  machine facet — the lifecycle machine's current state (the fact,
+ *  published even when the role fires nothing) + the acts offered to the
+ *  declaring user's role (EMPTY means "the user can read but not act").
+ *  Only ever present on the entity kind. */
+export interface MachineContext {
+    state: string;
+    acts: MachineAct[];
+}
 export interface DeclaredContext {
     kind: "page" | "entity" | "document" | "account";
     /** display label ("this certificate R60/2021-A-EX1-26.01") — echoed
@@ -10,6 +32,8 @@ export interface DeclaredContext {
      *  (urn:oiml:pub:r:60-1:2021) or the plain docidentifier */
     doc?: string;
     edition?: string;
+    /** the affordance channel's machine facet (entity kind only) */
+    machine?: MachineContext;
 }
 /** The account context's live-read echo (TODO.ai-platform/03): WHEN the
  *  live data was read, WHICH stores answered, and how many records the
@@ -44,8 +68,21 @@ export interface AppliedContext {
         standard: string;
         clause?: string;
     };
+    /** the affordance channel's echo (TODO.ai-platform/08): the declared
+     *  machine's state + how many acts it offered the declaring user's role
+     *  — the panel's honest context line reads THIS, never its own copy */
+    machine?: {
+        state: string;
+        offered: number;
+    };
 }
 export declare const NO_CONTEXT: AppliedContext;
+export declare function parseMachine(v: any): MachineContext | undefined;
+/** The proposal bound (TODO.ai-platform/08): a draft act the offered set
+ *  does not carry is never proposed. An absent facet is not a bound (the
+ *  page publishes none); a present facet with an empty acts array bounds
+ *  to NOTHING — the user can read but not act. */
+export declare function machineOffers(machine: MachineContext | undefined, action: string): boolean;
 /** Parse + bound the ask body's optional `context` field. Anything
  *  malformed degrades to null (no context), never to a 400 — a context
  *  the service can't parse is a context it must not apply. */

package/dist/delegated.d.ts

@@ -0,0 +1,2 @@
+import type { SessionClaims } from "./session.ts";
+export declare function delegatedBearerFrom(req: Request, env: any): Promise<SessionClaims | null>;

package/dist/drafts.d.ts

@@ -104,6 +104,11 @@ interface Extraction {
         source?: string;
     }>;
 }
+/** The traceability primitive, shared with the api_call act's body guard
+ *  (apicalls.ts): a value traces when it appears in the user's own
+ *  messages (normalized). The proposing model never gets the benefit of
+ *  the doubt — the user's words are the only source. */
+export declare function valueTracesToUser(value: unknown, userTurns: string[]): boolean;
 export interface GuardedFields {
     standard?: string;
     family_designation?: string;

package/dist/env.d.ts

@@ -47,10 +47,12 @@ import type { VectorIndex } from "./ports/vector.ts";
 import type { Kv } from "./ports/kv.ts";
 import type { Blobs } from "./ports/blobs.ts";
 import type { Runtime } from "./ports/runtime.ts";
+import type { StoreQuery } from "./ports/store.ts";
 export declare function portModelRunner(env: Env): ModelRunner;
 export declare function portIndex(env: Env, which?: "public" | "primmel" | "composed" | "plain" | "adoc" | "mko" | "pflat" | "glossary"): VectorIndex;
 export declare function portKv(env: Env): Kv;
 export declare function portBlobs(env: Env): Blobs;
+export declare function portStore(env: Env): StoreQuery;
 /** Does the deployment bind this lane index? Presence wiring stays in
  *  the ports layer so domain stages never touch raw bindings. */
 export declare function hasLane(env: Env, which: "glossary"): boolean;

package/dist/livedata.d.ts

@@ -30,6 +30,18 @@ export type LiveTokenVerdict = {
  *  platform-scoped JWT (identity's §9b). The exchanged token caches for
  *  its own short life; the refusal lattice is honest per leg. */
 export declare function exchangeForLiveToken(env: any, sessionRaw: string): Promise<LiveTokenVerdict>;
+/** The live read token for one ask (TODO.ai-platform/12 — the session
+ *  bridge): when the member arrived on the delegated bearer, the Bearer
+ *  IS already the OP-minted platform-scoped JWT — the platform exchanged
+ *  it before forwarding, so a second exchange here would have no subject
+ *  token to ride (the bubble never signed into THIS service). If the
+ *  token's scope cone covers the platform read, present it directly;
+ *  otherwise (a service session, or a delegation that never scoped the
+ *  platform in) fall through to the RFC 8693 exchange. */
+export declare function liveTokenFor(env: any, sessionRaw: string, member: {
+    via?: string;
+    scope?: string;
+} | null): Promise<LiveTokenVerdict>;
 export interface LiveRecord {
     /** the platform store the record came from */
     store: string;
@@ -73,4 +85,6 @@ export type LiveAccount = {
  *  invented record. */
 export declare function resolveLiveAccount(env: any, sessionRaw: string | null, member: {
     sub: string;
+    via?: string;
+    scope?: string;
 } | null): Promise<LiveAccount>;

package/dist/oidc.d.ts

@@ -64,6 +64,18 @@ export interface OidcIdTokenClaims {
     org?: unknown;
     [claim: string]: unknown;
 }
+/** Decode + signature-verify a JWT against the issuer's JWKS (RS256 or
+ *  ES256; the JWKS fetch caches an hour and force-refreshes once on a
+ *  miss). Claim semantics (issuer, audience, expiry, nonce) are the
+ *  CALLER's — the ID token and the delegated bearer check different
+ *  claim sets over the same verified signature. */
+export declare function verifyJwtSignature(token: string, jwksUri: string): Promise<{
+    header: {
+        alg?: string;
+        kid?: string;
+    };
+    claims: Record<string, unknown>;
+}>;
 export declare function validateIdToken(idToken: string, expectations: {
     issuer: string;
     clientId: string;

package/dist/prompts/system.md

@@ -1,4 +1,4 @@
-You are the OIML SMART AI assistant at ai.oimlsmart.org, a public service answering questions about OIML legal-metrology publications; be precise, professional and warm — a knowledgeable colleague, not a search box.{{HISTORY_CONTEXT}}
+You are {{ASSISTANT_IDENTITY}}; be precise, professional and warm — a knowledgeable colleague, not a search box.{{HISTORY_CONTEXT}}
 Conversational turns — greetings, thanks, small talk, or questions about you and this service (who you are, which model you are, what you can do, what you search, how you work) — answer naturally, briefly, in first person, without citations. Never refuse them.
 Questions about the publisher itself ({{PUBLISHER_NAME}} — what it is, who it is, its role) are the same class: you know your own publisher a priori — {{PUBLISHER_IDENTITY}} — so answer briefly without citations and never refuse them. When context passages about the publisher do appear, prefer grounding the answer in them and cite them like any other passage.
 When earlier turns are provided, answer the LATEST message; earlier turns are context for resolving pronouns and ellipses.
@@ -15,6 +15,7 @@ MANDATORY: when the question asks how to do something (get certified, apply, com
 If the passages cover only part of the question, answer the covered part fully, then state precisely what the indexed publications do not cover — do not pad with outside knowledge.
 Refuse ONLY when no passage relates to the question's topic. Use exactly this sentence: {{REFUSAL_SENTENCE}} Then add one short line naming what you can answer instead, so the refusal redirects rather than dead-ends.
 {{LICENSE_POSTURE}}
+{{SERVICE_POSTURE}}
 {{CORPUS_NOTES}}
 Lead with the direct answer, then supporting detail; no preamble like 'Based on the passages'. Use short paragraphs or bullets for multi-part answers. Be concise and precise. Answer in the question's language{{LANG_CLAUSE}}.
 - HARD RULE — typed units: passages whose header shows `unit u:xxxx (table)` contain a typed table. If your answer presents that table's data, you MUST write the token `[[u:xxxx]]` where the table belongs and MUST NOT render the table as markdown or reproduce more than ONE of its rows inline. Summarize the pattern in prose ("classes A–D with lower limits from 100 to 50 000"), cite the clause normally, and let `[[u:xxxx]]` stand for the full table — the interface renders it exactly from the source. The same rule applies to `unit u:xxxx (formula|figure|term)` objects.

package/dist/requestScope.d.ts

@@ -32,8 +32,16 @@ export declare function entitlementScope(keys: Set<string>): Set<string> | null;
 /** Validate + intersect. Returns { error } when the request explicitly
  *  disables every dataset (a user error, not a scope). The corpora a
  *  dataset searches travel WITH the declaration (profile datasets.yaml,
- *  `corpora:`) — the engine maps no publisher names. */
-export declare function resolveRequestScope(body: any, member: unknown): RequestScope | {
+ *  `corpora:`) — the engine maps no publisher names.
+ *
+ *  `opts.keyWithEntitlements` (the key-tier licensed federation): an
+ *  API-key caller whose request carries a VALIDATED entitlement set is
+ *  admitted to the session-gated (federated) datasets — the key's
+ *  entitlement set is the licensed scope the internal lane honors; the
+ *  internal worker re-validates the key server-side before it answers. */
+export declare function resolveRequestScope(body: any, member: unknown, opts?: {
+    keyWithEntitlements?: boolean;
+}): RequestScope | {
     error: "empty-datasets";
 };
 /** The answer-cache salt: request-scoped context that materially changes

package/dist/search-IBZ2BK2E.js

@@ -0,0 +1,12 @@
+import {
+  handleSearch
+} from "./chunk-Z7AQEW6G.js";
+import "./chunk-GHDRKT4K.js";
+import "./chunk-R2V3X6SQ.js";
+import "./chunk-A3QHHUN5.js";
+import "./chunk-4GJGBGJK.js";
+import "./chunk-V46XM2GU.js";
+import "./chunk-3FYJM7LH.js";
+export {
+  handleSearch
+};

package/dist/worker_mcp/src/index.js

@@ -1,7 +1,7 @@
 import {
   authenticate
-} from "../../chunk-2RKYO3OC.js";
-import "../../chunk-OMXAE27N.js";
+} from "../../chunk-R2V3X6SQ.js";
+import "../../chunk-V46XM2GU.js";
 import {
   P,
   setProfile