@opengeni/runtime 2.6.0-canary.0 → 2.6.0-canary.2

package/src/bundled_default_skills/opengeni-visualize/assets/helpers.html

@@ -0,0 +1,349 @@
+<!--__INLINE_VISUALIZATION_FRAGMENT__-->
+<script src="https://unpkg.com/@floating-ui/core@1.7.3/dist/floating-ui.core.umd.min.js"></script>
+<script src="https://unpkg.com/@floating-ui/dom@1.7.4/dist/floating-ui.dom.umd.min.js"></script>
+<script>
+  (() => {
+    if (window.FloatingUIDOM == null) {
+      return;
+    }
+    const { autoUpdate, computePosition, flip, offset, shift, size } = window.FloatingUIDOM;
+    const tooltipPlacements = new Set(["top", "right", "bottom", "left"]);
+    const tooltipId = `codex-visualization-tooltip-${
+      window.crypto?.randomUUID?.() ?? Date.now().toString(36)
+    }`;
+    const tooltipGap = 5;
+    const hoverDelay = 700;
+    const skipDelay = 300;
+    let activeTrigger = null;
+    let pendingTrigger = null;
+    let tooltip = null;
+    let openTimeout = null;
+    let autoUpdateCleanup = null;
+    let positionRequest = 0;
+    let skipDelayUntil = 0;
+    let lastPointerWasTouch = false;
+    let pinnedByTouch = false;
+
+    const getTrigger = (target) =>
+      target?.nodeType === Node.ELEMENT_NODE ? target.closest("[data-tooltip]") : null;
+    const containsTarget = (trigger, target) =>
+      target?.nodeType != null && trigger.contains(target);
+    const getContent = (trigger) => trigger.getAttribute("data-tooltip")?.trim() ?? "";
+    const getPlacement = (trigger) => {
+      const placement = trigger.getAttribute("data-tooltip-placement");
+      return tooltipPlacements.has(placement) ? placement : "top";
+    };
+    const getTooltip = () => {
+      if (tooltip == null) {
+        tooltip = document.createElement("div");
+        tooltip.id = tooltipId;
+        tooltip.className = "tooltip";
+        tooltip.setAttribute("role", "tooltip");
+      }
+      return tooltip;
+    };
+    const setDescribedBy = (trigger, described) => {
+      const ids = new Set(
+        (trigger.getAttribute("aria-describedby") ?? "").split(/\s+/).filter(Boolean),
+      );
+      if (described) {
+        ids.add(tooltipId);
+      } else {
+        ids.delete(tooltipId);
+      }
+      if (ids.size === 0) {
+        trigger.removeAttribute("aria-describedby");
+      } else {
+        trigger.setAttribute("aria-describedby", [...ids].join(" "));
+      }
+    };
+    const clearOpenTimeout = () => {
+      if (openTimeout != null) {
+        window.clearTimeout(openTimeout);
+        openTimeout = null;
+      }
+      pendingTrigger = null;
+    };
+    const closeTooltip = (activateSkipDelay = true) => {
+      clearOpenTimeout();
+      pinnedByTouch = false;
+      positionRequest += 1;
+      autoUpdateCleanup?.();
+      autoUpdateCleanup = null;
+      if (activeTrigger == null) {
+        return;
+      }
+      setDescribedBy(activeTrigger, false);
+      activeTrigger = null;
+      tooltip?.remove();
+      if (activateSkipDelay) {
+        skipDelayUntil = Date.now() + skipDelay;
+      }
+    };
+    const updatePosition = (trigger, floating) => {
+      const request = ++positionRequest;
+      void computePosition(trigger, floating, {
+        middleware: [
+          offset(tooltipGap),
+          flip({ padding: tooltipGap }),
+          shift({ padding: tooltipGap }),
+          size({
+            padding: tooltipGap,
+            apply({ availableHeight, availableWidth, elements }) {
+              elements.floating.style.setProperty(
+                "--tooltip-available-width",
+                `${Math.max(0, availableWidth)}px`,
+              );
+              elements.floating.style.setProperty(
+                "--tooltip-available-height",
+                `${Math.max(0, availableHeight)}px`,
+              );
+            },
+          }),
+        ],
+        placement: getPlacement(trigger),
+        strategy: "fixed",
+      })
+        .then(({ x, y }) => {
+          if (activeTrigger !== trigger || request !== positionRequest) {
+            return;
+          }
+          const scale = window.devicePixelRatio || 1;
+          floating.style.transform = `translate(${Math.round(x * scale) / scale}px, ${Math.round(y * scale) / scale}px)`;
+          floating.style.visibility = "visible";
+        })
+        .catch(() => {
+          if (activeTrigger === trigger && request === positionRequest) {
+            closeTooltip(false);
+          }
+        });
+    };
+    const openTooltip = (trigger) => {
+      const content = getContent(trigger);
+      if (!trigger.isConnected || content.length === 0) {
+        return;
+      }
+      clearOpenTimeout();
+      if (activeTrigger === trigger) {
+        return;
+      }
+      closeTooltip();
+      const floating = getTooltip();
+      floating.textContent = content;
+      floating.style.visibility = "hidden";
+      floating.style.transform = "translate(0, 0)";
+      document.body.appendChild(floating);
+      activeTrigger = trigger;
+      setDescribedBy(trigger, true);
+      autoUpdateCleanup = autoUpdate(trigger, floating, () => {
+        updatePosition(trigger, floating);
+      });
+    };
+    const requestOpen = (trigger, immediate = false) => {
+      if (
+        getContent(trigger).length === 0 ||
+        activeTrigger === trigger ||
+        pendingTrigger === trigger
+      ) {
+        return;
+      }
+      clearOpenTimeout();
+      pendingTrigger = trigger;
+      const delay =
+        immediate || activeTrigger != null || Date.now() < skipDelayUntil ? 0 : hoverDelay;
+      if (delay === 0) {
+        openTooltip(trigger);
+        return;
+      }
+      openTimeout = window.setTimeout(() => {
+        openTimeout = null;
+        pendingTrigger = null;
+        openTooltip(trigger);
+      }, delay);
+    };
+    const handlePointerOpen = (event) => {
+      if (event.pointerType === "touch") {
+        return;
+      }
+      const trigger = getTrigger(event.target);
+      if (trigger == null || containsTarget(trigger, event.relatedTarget)) {
+        return;
+      }
+      requestOpen(trigger);
+    };
+    const handlePointer = (event) => {
+      lastPointerWasTouch = event.type === "pointerdown" && event.pointerType === "touch";
+    };
+    const handleTouchClick = (event) => {
+      const isTouch = event.pointerType === "touch" || lastPointerWasTouch;
+      lastPointerWasTouch = false;
+      if (!isTouch || event.detail === 0) {
+        return;
+      }
+      const trigger = getTrigger(event.target);
+      if (
+        trigger == null ||
+        !trigger.isConnected ||
+        getContent(trigger).length === 0 ||
+        (pinnedByTouch && activeTrigger === trigger)
+      ) {
+        if (pinnedByTouch) {
+          closeTooltip();
+        }
+        return;
+      }
+      openTooltip(trigger);
+      pinnedByTouch = activeTrigger === trigger;
+      window.setTimeout(() => {
+        if (activeTrigger === trigger && !trigger.isConnected) {
+          closeTooltip(false);
+        }
+      }, 0);
+    };
+    const handleLeave = (event) => {
+      if (pinnedByTouch) {
+        return;
+      }
+      const trigger = getTrigger(event.target);
+      if (trigger == null || containsTarget(trigger, event.relatedTarget)) {
+        return;
+      }
+      if (activeTrigger === trigger || pendingTrigger === trigger) {
+        closeTooltip();
+      }
+    };
+    const handleFocusIn = (event) => {
+      const trigger = getTrigger(event.target);
+      if (trigger?.matches(":focus-visible")) {
+        requestOpen(trigger, true);
+      }
+    };
+    const handleKeyDown = (event) => {
+      if (event.key === "Escape") {
+        closeTooltip();
+      }
+    };
+    const handleContextMenu = (event) => {
+      lastPointerWasTouch = false;
+      const trigger = getTrigger(event.target);
+      if (activeTrigger === trigger || pendingTrigger === trigger) {
+        closeTooltip();
+      }
+    };
+    const destroy = () => {
+      closeTooltip(false);
+      lastPointerWasTouch = false;
+      document.removeEventListener("pointerover", handlePointerOpen);
+      document.removeEventListener("pointerdown", handlePointer);
+      document.removeEventListener("pointercancel", handlePointer);
+      document.removeEventListener("click", handleTouchClick);
+      document.removeEventListener("pointerout", handleLeave);
+      document.removeEventListener("focusin", handleFocusIn);
+      document.removeEventListener("focusout", handleLeave);
+      document.removeEventListener("keydown", handleKeyDown);
+      document.removeEventListener("contextmenu", handleContextMenu);
+      tooltip = null;
+    };
+
+    document.addEventListener("pointerover", handlePointerOpen);
+    document.addEventListener("pointerdown", handlePointer);
+    document.addEventListener("pointercancel", handlePointer);
+    document.addEventListener("click", handleTouchClick);
+    document.addEventListener("pointerout", handleLeave);
+    document.addEventListener("focusin", handleFocusIn);
+    document.addEventListener("focusout", handleLeave);
+    document.addEventListener("keydown", handleKeyDown);
+    document.addEventListener("contextmenu", handleContextMenu);
+    window.addEventListener("pagehide", destroy, { once: true });
+  })();
+</script>
+<script id="codex-visualization-tabs">
+  (() => {
+    const selector = '.nav[role="tablist"] [role="tab"]';
+    const disabled = ':disabled,[aria-disabled="true"]';
+    const selectTab = (selected) => {
+      const panelId = selected.getAttribute("aria-controls");
+      for (const tab of selected.closest('[role="tablist"]').querySelectorAll('[role="tab"]')) {
+        const active = tab === selected;
+        tab.classList.toggle("active", active);
+        tab.setAttribute("aria-selected", String(active));
+        const id = tab.getAttribute("aria-controls");
+        const panel = id && document.getElementById(id);
+        if (panel != null) {
+          panel.hidden = id !== panelId;
+          if (!panel.hidden && selected.id) {
+            panel.setAttribute("aria-labelledby", selected.id);
+          }
+        }
+      }
+    };
+    const interact = (event) => {
+      const tab = event.target?.closest?.(selector);
+      if (event.defaultPrevented || tab == null || tab.matches(disabled)) {
+        return;
+      }
+      if (event.type === "click") {
+        selectTab(tab);
+        return;
+      }
+      const tabs = Array.from(
+        tab.closest('[role="tablist"]').querySelectorAll('[role="tab"]'),
+      ).filter((candidate) => !candidate.matches(disabled));
+      const current = tabs.indexOf(tab);
+      let next;
+      if (event.key === "ArrowRight" || event.key === "ArrowDown") {
+        next = (current + 1) % tabs.length;
+      } else if (event.key === "ArrowLeft" || event.key === "ArrowUp") {
+        next = (current + tabs.length - 1) % tabs.length;
+      } else if (event.key === "Home") {
+        next = 0;
+      } else if (event.key === "End") {
+        next = tabs.length - 1;
+      } else {
+        return;
+      }
+      event.preventDefault();
+      tabs[next].focus();
+      selectTab(tabs[next]);
+    };
+
+    for (const list of document.querySelectorAll('.nav[role="tablist"]')) {
+      const selected =
+        list.querySelector('[role="tab"][aria-selected="true"]') ??
+        list.querySelector('[role="tab"].active') ??
+        list.querySelector('[role="tab"]');
+      if (selected != null) {
+        selectTab(selected);
+      }
+    }
+    document.addEventListener("click", interact);
+    document.addEventListener("keydown", interact);
+    window.addEventListener(
+      "pagehide",
+      () => {
+        document.removeEventListener("click", interact);
+        document.removeEventListener("keydown", interact);
+      },
+      { once: true },
+    );
+  })();
+</script>
+<script
+  id="codex-visualization-lucide"
+  async
+  src="https://unpkg.com/lucide@1.17.0/dist/umd/lucide.js"
+></script>
+<script>
+  (() => {
+    const initialize = () => {
+      globalThis.lucide?.createIcons({ attrs: { width: 16, height: 16 } });
+    };
+    if (globalThis.lucide != null) {
+      initialize();
+      return;
+    }
+    document
+      .getElementById("codex-visualization-lucide")
+      ?.addEventListener("load", initialize, { once: true });
+  })();
+</script>

package/src/bundled_management_skills/opengeni-skills/SKILL.md

@@ -1,12 +1,12 @@
 ---
 name: opengeni-skills
-description: Find, install, create, and edit workspace Skills; understand reading, file changes, Learning modes, and optional sandbox checkout.
+description: Find, install, create, and edit workspace Skills; understand reading, file changes, Agent learning settings, and optional sandbox checkout.
 ---
 
 # Managing Skills
 
 A Skill is a folder containing `SKILL.md` and supporting UTF-8 text files.
-Use Skills for reusable instructions and procedures. Use Memory for facts and
+Use Skills for reusable instructions and procedures. Use Knowledge for facts and
 outcomes, and workspace instructions for short always-on rules.
 
 ## Read
@@ -63,13 +63,22 @@ Stop processes editing the directory before publishing it. Publishing reads the
 whole folder; server revision checks prevent overwriting a newer saved revision,
 but they do not freeze a directory another process is changing.
 
+Facts and incidents belong in `knowledge_save`, with exact evidence and relevant
+collections. Search published and pending Knowledge before adding duplicates.
+Pending findings may inform further investigation but are not accepted facts or
+permission to change a Skill. Use the current Skill content and its revision
+when proposing procedural changes.
+
 ## Persistent changes
 
-Shared workspace Skills are available to workspace agents. Learning mode
-governs persistent changes: Off refuses them; Require approval leaves a change
-inactive; Autonomous makes an authorized valid change live. An agent saying
-“the user asked” does not bypass the mode. Report whether the change is pending
-or live. Do not change Learning settings to make a save succeed.
+Shared workspace Skills are available to workspace agents. Private chats and
+Personal workspaces save personal Skills for their verified initiating user.
+Settings > Agent learning controls persistent agent changes, with a sparse chat
+or scheduled-task override when configured. Automatic publishes a valid authorized
+change; Review first saves an inactive revision and the task continues; Off
+prevents agent authoring. Existing Skills remain readable and usable, and an
+authorized human can still manage or install Skills in the UI. Do not change
+settings or infer an override from “the user asked.” Report the actual receipt.
 
 Saved history supports restoration. Upstream updates must preserve workspace
 customizations; report an available update instead of replacing customized
@@ -77,15 +86,12 @@ content silently. Platform-owned built-in Skills are not workspace-editable.
 
 Do not encode binary files as text to bypass the text-only boundary. Unsupported
 files and size limits are explicit errors, not permission to drop files silently.
-## One chat approval
-
-When save, publish, or install returns `humanInput`, call
-`request_human_input` with that exact payload. The card displays the complete
-immutable Skill files. The initiating human's Save activates that exact revision
-in the response transaction, before the session resumes. No follow-up activation
-tool or second review is needed. The runtime owns the review card's wording and
-Save/Don't save choices; do not combine it with other questions. Don't save does
-not activate the Skill, and Other is not a valid Skill decision.
-If the Skill changes before Save, make a new proposal for a fresh decision.
-Autonomous saves return applied and need no confirmation. Off refuses durable
-agent changes.
+## Nonblocking review
+
+A pending save, publish, or install is retained in Knowledge > Needs review.
+Continue the task and link the pending revision. Do not call request_human_input
+or a second activation tool to turn a pending receipt into a chat interruption.
+The human reviews the exact revision in the shared review surface. Approval
+publishes it; rejection leaves any previously published revision in place. A
+stale review cannot overwrite a newer revision. Automatic receipts are available
+immediately; Off creates no durable agent change.

package/src/bundled_site_skills/opengeni-sites/SKILL.md

@@ -15,6 +15,13 @@ provider-specific API wrapper, or OpenGeni-only build CLI.
 
 ## Start from the durable Site
 
+- For an existing page the user wants to view and share, consider Sites before
+  choosing a temporary tunnel or another server. Inspect whether it can be
+  packaged as self-contained HTML, preserve its design and behavior, and retain
+  editable source when available. A local preview alone is still appropriate
+  when that is all the user requests. Explain workspace access for the published
+  link; do not imply it is public to anyone. If the app requires a backend that
+  Sites cannot host, explain that constraint instead of dropping functionality.
 - For a new Site, create a normal project directory with `package.json`,
   `index.html`, TypeScript/React source, styles, tests, and any ordinary build
   configuration the app needs.
@@ -112,6 +119,41 @@ Exercise the real interactions at desktop and mobile widths, inspect console
 errors, and take a screenshot when visual quality matters. Do not declare the
 Site complete from compilation alone.
 
+## Plain HTML without a browser build
+
+For a small HTML-only Site, use ordinary HTML, CSS, and JavaScript. If it calls
+OpenGeni tools or SDK methods, place this exact optional tag before your own
+scripts (without async, defer, or type="module"):
+
+```html
+<script src="/__opengeni/site-tools/client.js"></script>
+<script>
+  const site = createOpenGeniSiteClient();
+  // Use the actual tool paths discovered with ogtool on site.tools.
+  // site.client is the same ordinary SDK client as in a React Site.
+</script>
+```
+
+The existing preview handler above serves this script. Serve the raw HTML with
+`new Response(Bun.file("./index.html"))` alongside its tool route; no browser
+build is needed. In the published viewer, the host resolves the tag to its
+browser client. Both use the same SDK implementation and existing tool bridge.
+Opening the file directly supplies no tool host. There are no credentials in
+the tag or HTML. Declare requested tools and handle errors as for any Site.
+
+Use the exact package pins above for the preview host. The preview runtime comes
+from that installed SDK; the published runtime comes from the viewer's deployed
+SDK. The tag does not install dependencies, replace React imports, or change Bun.
+For TypeScript checking, React components, or imported browser dependencies,
+use the normal typed SDK and build workflow above. Do not use both client-loading
+paths in one document.
+
+Publish the original HTML containing the tag, not the served client script or
+transformed viewer document. For this path, upload `index.html` wherever the
+publishing instructions below use `dist/index.html`. Inline ordinary styles,
+scripts, and assets as usual; the OpenGeni client tag is resolved by the host.
+An HTML-only Site can be a small widget; it does not require a full-page layout.
+
 ## Prefer OpenGeni's UI and typed client
 
 - Prefer `@opengeni/react` components and compiled CSS for OpenGeni-native
@@ -259,13 +301,38 @@ access limitation. Missing publishing access itself still blocks publication.
    SDK operations, with no direct `site.tools` calls, should publish
    `requestedTools: []`.
 4. The immutable requested set is only a maximum allowlist; publishing it grants
-   no tool authority and requires no separate tool approval. Site calls do not open
-   per-call approval dialogs.
+   no tool authority and requires no separate tool approval. Execution still follows
+   normal tool approval rules; handle approval-required responses in the UI.
 5. The host intersects that set with the viewer's
    live workspace, permission, and connection authority on every call. Handle
    missing tools, revoked connections, stale catalogs, and access loss as normal
    user-visible error states.
 
+## Show a visualization or Site inside chat
+
+For an inline visualization stored directly in a chat response, read
+`opengeni-visualize`. That path does not require publishing a Site.
+
+To embed a published Site, use a fenced `opengeni-site` block containing JSON:
+
+```opengeni-site
+{"siteId":"<artifact.id>","versionId":"<published version.id>"}
+```
+
+Use the actual returned ids. `versionId` is optional; omitting it loads the
+current version when the embed opens. Including it preserves the intended
+version. The viewer can choose another version within the embed without
+publishing or rolling back the Site. The embed uses the same Site renderer,
+reload/full-screen controls, tool declarations and viewer permissions as the
+Site page. Embeds resolve in the chat's workspace. Keep a normal Site link when
+it helps the user reopen or share it. Archived or inaccessible Sites display
+an unavailable state.
+
+Use inline HTML for a visualization that belongs in this response. Use a Site
+for a reusable app or durable page, and embed it when useful. Both can be small;
+neither requires a dashboard or full-page layout. React Sites still use the
+normal build and publish workflow.
+
 ## Publish one immutable version
 
 1. Call `opengeni__artifacts_prepare_upload` (no hashes or sizes required).

package/src/first-party-client.ts

@@ -0,0 +1,70 @@
+import {
+  DEFAULT_FIRST_PARTY_MCP_PERMISSIONS,
+  signDelegatedAccessToken,
+  type FirstPartyMcpToolName,
+  type Permission,
+} from "@opengeni/contracts";
+import {
+  firstPartyMcpInternalWorkspaceUrl,
+  resolveFirstPartyDelegationSecret,
+  type Settings,
+} from "@opengeni/config";
+import { OpenGeniClient } from "@opengeni/sdk";
+import { guardedMcpFetch } from "./mcp-network";
+
+/** Internal calls carry the same exact attempt and tool selection as MCP. */
+export function createFirstPartyAttemptClient(input: {
+  settings: Settings;
+  scope: {
+    accountId: string;
+    workspaceId: string;
+    sessionId: string;
+    turnId: string;
+    attemptId: string;
+    executionGeneration: number;
+  };
+  selectedTools: readonly FirstPartyMcpToolName[];
+  permissions?: readonly Permission[];
+  fetch?: typeof fetch;
+  signal?: AbortSignal;
+}) {
+  const secret = resolveFirstPartyDelegationSecret(input.settings);
+  if (!secret) throw new Error("First-party task access is unavailable");
+  const url = new URL(firstPartyMcpInternalWorkspaceUrl(input.settings, input.scope.workspaceId));
+  const suffix = `/v1/workspaces/${input.scope.workspaceId}/mcp`;
+  if (!url.pathname.endsWith(suffix)) throw new Error("First-party API URL is invalid");
+  url.pathname = url.pathname.slice(0, -suffix.length) || "/";
+  url.search = "";
+  url.hash = "";
+  const guarded = guardedMcpFetch(
+    { ...input.settings, integrationsAllowPrivateNetworkTargets: true },
+    input.fetch ?? globalThis.fetch.bind(globalThis),
+    {
+      requireHttpsOutsideLocalTest: false,
+      ...(process.versions.bun ? { pinResolvedDestination: false } : {}),
+    },
+  );
+  return new OpenGeniClient({
+    baseUrl: url.toString(),
+    fetch: async (request, init) => {
+      const bearer = await signDelegatedAccessToken(secret, {
+        ...input.scope,
+        subjectId: "worker:knowledge-preparation",
+        principalKind: "agent_attempt",
+        permissions: [...(input.permissions ?? DEFAULT_FIRST_PARTY_MCP_PERMISSIONS)],
+        firstPartyMcpTools: [...input.selectedTools],
+        exp: Math.floor(Date.now() / 1_000) + 60 * 60,
+      });
+      const headers = new Headers(init?.headers);
+      headers.set("authorization", `Bearer ${bearer}`);
+      const signals = [input.signal, init?.signal].filter(
+        (signal): signal is AbortSignal => !!signal,
+      );
+      return guarded(request, {
+        ...init,
+        headers,
+        ...(signals.length ? { signal: AbortSignal.any(signals) } : {}),
+      });
+    },
+  });
+}

package/src/index.ts

@@ -1897,9 +1897,9 @@ export type BuildAgentOptions = {
   attemptConnectorActionBindings?: readonly AttemptConnectorActionBinding[];
   /** Exact open-suffix call the current human approved before this agent was rebuilt. */
   approvedToolCallId?: string;
-  // Workspace Memory V1 working-set block, resolved by the worker per turn.
-  // Composed after the workspace persona/CORE/codemode substrate and before
-  // per-session instructions. Omitted/blank ⇒ byte-identical instructions.
+  // Historical prompt-replay/embedding compatibility slot. New Knowledge is
+  // retrieved through tools and must not be composed here as standing guidance.
+  // Omitted/blank preserves the existing prompt bytes.
   workspaceMemory?: string;
   // Exact-attempt active policy and preference descriptor block. When present,
   // runtime uses the structured governance precedence branch; absent preserves
@@ -2075,7 +2075,7 @@ export function coreInstructions(
 ): string[] {
   return [
     "If the session has a goal, you own it: keep working until you call opengeni__goal_complete with concrete evidence or opengeni__goal_pause with a rationale; resume a paused goal with opengeni__goal_resume regardless of who paused it or why; revise it with opengeni__goal_update; create one with opengeni__goal_set when given a long-running objective.",
-    "When workspace Memory tools are available, use memory_save autonomously for durable facts, decisions, incidents, bug fixes, and confirmed outcomes that future workspace sessions should retrieve, whether the user asked you to remember them or you learned them during work; use memory_correct when an active agent-writable memory is wrong or outdated. Use task_note_save instead for expiring coordination that should be visible only to agents in the current root session tree. Workspace Learning mode does not gate these agent-only Memory writes. Reusable conditional guidance belongs in Skills. Skill changes use the shared file lifecycle governed by Learning mode, not Knowledge evidence or confidence. Follow Skill management guidance only when it is present in the Skill index. Use remember lane=instruction_policy only for the shortest universal rules every agent must follow, and lane=knowledge only when memory_save is unavailable and the user explicitly requests reviewed workspace knowledge. Do not store the same material in multiple authorities.",
+    "Use knowledge_search and knowledge_get when retained information is relevant. For questions about what the workspace knows, ground the answer in authorized Knowledge and attached sources. Missing internal facts remain unknown; do not infer a person's role or cite unrelated public search results as evidence. Keep any relevant external research clearly separate from workspace records. Default retrieval returns published information. Before retaining or correcting anything, also search view=needs_review for existing pending entries and collections; read those with knowledge_get view=needs_review. Pending means unapproved: you may inspect and improve it, but do not present it as accepted knowledge or activate behavioral guidance from it. Reuse the existing entryId and current version instead of creating another proposal each run. Save durable facts, decisions, requirements, incidents, fixes and outcomes autonomously with knowledge_save when useful for future work, whether requested explicitly or learned during ordinary work. When a user supplies or confirms a durable fact, use knowledge_retain_message to retain the actual message and cite its returned entryId/revisionId in the finding evidence. Preserve existing source evidence and relationships when correcting an entry; do not replace them with empty arrays merely because the user confirmed a new value. Explicit confirmation can supersede a conflicting pending proposal, but explain that outcome to the user. Preserve uncertainty and exact supporting evidence; the fact label is not a verification claim. Chat attachments retain their original files and automatically prepare source text when authoring is enabled. Use knowledge_retain_file for a newly fetched file or failed preparation. A source entry contains retained original text; a finding states a useful conclusion and cites the exact source revision. Do not create both when they would simply repeat the same text. Reuse collections for customers, products, systems or subjects across sources, and link one entry to multiple collections instead of copying it. Technical incidents belong with the affected system and should include cause, fix and outcome when known. Reorganize references when useful; do not erase source evidence or revision history. Private tasks author personal Knowledge; shared tasks author workspace Knowledge. Automatic publishes immediately, Review first keeps a pending proposal without pausing your task, and Off prevents authoring while permitting retrieval. Never bypass review by making a new entry, switching tools, or asking for another approval. Reuse the same operationId and exact request after an uncertain save, including recovery. Use task_note_save for temporary coordination in this task tree. Conversation history is separate. Workspace instructions are concise standing rules; Skills are reusable procedures with their own Agent learning settings. Do not save the same content in multiple authorities.",
     ...(workspaceEnvironment ? workspaceEnvironmentInstructions(workspaceEnvironment) : []),
     // Rig doctrine (M3): data-conditional, inside the non-bypassable CORE so a
     // white-label persona template can never drop it. Absent for rig-less sessions.
@@ -2130,11 +2130,9 @@ export function appendPersistentSessionSettings(
 }
 
 /**
- * Appends the workspace memory working-set block to the already-composed
- * (workspace + CORE + generic substrate) instructions, joined by " ". The
- * memory slice is workspace-ground and intentionally lands before
- * per-session instructions. An absent/blank value is a no-op that returns the
- * composed string byte-for-byte.
+ * Historical prompt-composition compatibility helper. New Knowledge uses
+ * retrieval tools; this slot preserves existing embedding/replay inputs only.
+ * An absent/blank value returns the composed string byte-for-byte.
  */
 export function appendWorkspaceMemory(composed: string, workspaceMemory?: string): string {
   const trimmed = workspaceMemory?.trim();
@@ -2435,6 +2433,7 @@ export function buildOpenGeniAgent(
   // are equivalent. Reading supplied Skill files never needs either.
   const filesystemAvailable = (options.activeSandboxBackend ?? settings.sandboxBackend) !== "none";
   const skillComposition = composeRuntimeSkills(options.skillActivations ?? [], {
+    defaults: !hostSuppliedSkillCatalog,
     editableArtifacts: !hostSuppliedSkillCatalog && editableArtifactToolsAvailable,
     sites: !hostSuppliedSkillCatalog && filesystemAvailable,
     videoGeneration: !hostSuppliedSkillCatalog && Boolean(options.videoGeneration),
@@ -2619,8 +2618,8 @@ export function buildOpenGeniAgent(
     //      when a codemode token was minted for this managed-sandbox turn,
     //   4. + managed-sandbox Git binding discovery, ONLY when one provider has
     //      multiple credential bindings,
-    //   5. + workspace memory working set, ONLY when the workspace setting is on
-    //      and the worker resolved a nonblank block — appendWorkspaceMemory,
+    //   5. + a nonblank historical memory compatibility block, when supplied;
+    //      canonical Knowledge is retrieved through tools,
     //   6. + the per-session persona instructions (session-specific, so it
     //      refines both the workspace persona and the substrate note),
     //   7. + host context for this exact turn, when supplied,
@@ -11101,3 +11100,5 @@ function sortJson(value: unknown): unknown {
   }
   return value;
 }
+
+export { createFirstPartyAttemptClient } from "./first-party-client";