@agent-native/core 0.99.3 → 0.100.1

package/corpus/core/src/server/agent-chat/prompt-resources.ts

@@ -14,6 +14,11 @@ import {
   sharedResourceOwner,
   WORKSPACE_OWNER,
 } from "../../resources/store.js";
+import type {
+  ContextGovernanceTier,
+  ContextManifestSourceRef,
+  ContextSystemProvenance,
+} from "../../shared/context-xray.js";
 import { discoverAgents } from "../agent-discovery.js";
 import { getRequestOrgId } from "../request-context.js";
 import { parseSkillFrontmatter } from "./skill-frontmatter.js";
@@ -40,10 +45,177 @@ const PROMPT_SKILL_METADATA_READ_LIMIT = 80;
 const PROMPT_INSTRUCTION_SUMMARY_LIMIT = 20;
 const PROMPT_SUMMARY_DESCRIPTION_MAX_CHARS = 180;
 
+export interface PromptResourceManifestSection {
+  label: string;
+  provenance: ContextSystemProvenance;
+  governance: ContextGovernanceTier;
+  content: string;
+  sourceRef?: ContextManifestSourceRef;
+}
+
 function normalizeResourcePathForPrompt(path: string): string {
   return path.replace(/^\/+/, "").trim();
 }
 
+function xmlAttribute(attrs: string, name: string): string | undefined {
+  const match = new RegExp(`\\b${name}="([^"]*)"`).exec(attrs);
+  return match?.[1];
+}
+
+function resourceManifestClassification(
+  scope: string,
+  path: string,
+  index: number,
+): {
+  provenance: ContextSystemProvenance;
+  governance: ContextGovernanceTier;
+} {
+  const normalizedPath = normalizeResourcePathForPrompt(path);
+  if (scope === "template") {
+    return { provenance: "template", governance: "inherited" };
+  }
+  if (scope.startsWith("workspace")) {
+    return {
+      provenance:
+        scope === "workspace" && index === 0
+          ? "enterprise-workspace-core"
+          : "sql-workspace",
+      governance:
+        scope === "workspace" && index === 0 ? "required" : "inherited",
+    };
+  }
+  if (scope.startsWith("personal")) {
+    return {
+      provenance: normalizedPath === "memory/MEMORY.md" ? "memory" : "personal",
+      governance: "user",
+    };
+  }
+  if (scope.startsWith("app-default")) {
+    return { provenance: "legacy-app-default", governance: "inherited" };
+  }
+  if (scope.startsWith("organization")) {
+    return { provenance: "organization", governance: "inherited" };
+  }
+  if (scope.startsWith("shared")) {
+    return {
+      provenance:
+        normalizedPath === "LEARNINGS.md"
+          ? "organization"
+          : "legacy-app-default",
+      governance: "inherited",
+    };
+  }
+  return { provenance: "template", governance: "inherited" };
+}
+
+/**
+ * Extracts bounded-in-memory metadata from the already-composed resource
+ * prompt. The caller turns these inputs into hashed/previews before anything
+ * is persisted; this helper never writes or returns the full manifest.
+ */
+export function promptResourceManifestSections(
+  prompt: string,
+): PromptResourceManifestSection[] {
+  const sections: PromptResourceManifestSection[] = [];
+  const resourcePattern = /<resource\b([^>]*)>([\s\S]*?)<\/resource>/g;
+  let match: RegExpExecArray | null;
+  let workspaceIndex = 0;
+  let sharedIndex = 0;
+  while ((match = resourcePattern.exec(prompt))) {
+    const attrs = match[1] ?? "";
+    const scope = xmlAttribute(attrs, "scope") ?? "resource";
+    const path =
+      xmlAttribute(attrs, "path") ?? xmlAttribute(attrs, "name") ?? "";
+    const name = xmlAttribute(attrs, "name") ?? (path || "resource");
+    const index = scope.startsWith("workspace")
+      ? workspaceIndex++
+      : scope.startsWith("shared")
+        ? sharedIndex++
+        : 0;
+    const classification = resourceManifestClassification(scope, path, index);
+    sections.push({
+      label: name,
+      ...classification,
+      content: match[2] ?? "",
+      sourceRef: {
+        ...(path ? { path } : {}),
+        scope,
+      },
+    });
+  }
+
+  const taggedSections = [
+    {
+      tag: "skills-summary",
+      label: "Workspace skills index",
+      provenance: "template" as const,
+      governance: "inherited" as const,
+    },
+    {
+      tag: "resource-skills",
+      label: "Workspace resource skills",
+      provenance: "template" as const,
+      governance: "inherited" as const,
+    },
+    {
+      tag: "instruction-resources",
+      label: "Instruction resources index",
+      provenance: "sql-workspace" as const,
+      governance: "inherited" as const,
+    },
+    {
+      tag: "workspace-resources",
+      label: "Workspace reference resources",
+      provenance: "sql-workspace" as const,
+      governance: "inherited" as const,
+    },
+    {
+      tag: "context-note",
+      label: "Resource availability note",
+      provenance: "framework-core" as const,
+      governance: "required" as const,
+    },
+    {
+      tag: "context-budget-note",
+      label: "Context budget note",
+      provenance: "framework-core" as const,
+      governance: "required" as const,
+    },
+    {
+      tag: "available-apps",
+      label: "Available workspace apps",
+      provenance: "tools" as const,
+      governance: "required" as const,
+    },
+  ];
+  for (const tagged of taggedSections) {
+    const pattern = new RegExp(
+      `<${tagged.tag}\\b[^>]*>([\\s\\S]*?)</${tagged.tag}>`,
+      "g",
+    );
+    let taggedMatch: RegExpExecArray | null;
+    while ((taggedMatch = pattern.exec(prompt))) {
+      const taggedAttrs =
+        taggedMatch[0]?.slice(tagged.tag.length + 1).split(">")[0] ?? "";
+      const taggedScope = xmlAttribute(taggedAttrs, "scope");
+      const taggedClassification =
+        tagged.tag === "instruction-resources" && taggedScope
+          ? resourceManifestClassification(taggedScope, "", 0)
+          : {
+              provenance: tagged.provenance,
+              governance: tagged.governance,
+            };
+      sections.push({
+        label: tagged.label,
+        ...taggedClassification,
+        content: taggedMatch[1] ?? "",
+        ...(taggedScope ? { sourceRef: { scope: taggedScope } } : {}),
+      });
+    }
+  }
+  return sections;
+}
+
 function resourceToolHint(
   action: "list" | "read" | "effective" | "write" | "delete" | "promote",
   extra?: string,
@@ -541,14 +713,14 @@ export async function loadResourcesForPrompt(
   if (organizationOwner !== SHARED_OWNER) {
     const organizationAgents = await loadAgentsResourceForPrompt(
       organizationOwner,
-      "shared",
+      "organization",
       promptResourceMaxChars,
     );
     if (organizationAgents) sections.push(organizationAgents);
     sections.push(
       ...(await loadInstructionResourcesForPrompt(
         organizationOwner,
-        "shared-instruction",
+        "organization-instruction",
         promptResourceMaxChars,
         compact,
       )),

package/corpus/core/src/server/agent-chat-plugin.ts

@@ -189,6 +189,10 @@ async function lazyFs(): Promise<typeof import("fs")> {
   return _fs;
 }
 
+import {
+  buildSystemManifestSections,
+  setContextXraySystemSections,
+} from "../agent/context-xray/manifest.js";
 // ---------------------------------------------------------------------------
 // The bulk of this file's former implementation now lives in focused sibling
 // modules under `./agent-chat/`. This file re-imports them (and re-exports
@@ -233,6 +237,7 @@ import {
 import { finalizeClaimedAgentChatProcessRunFailure } from "./agent-chat/process-run-failure.js";
 import {
   loadResourcesForPrompt,
+  promptResourceManifestSections,
   resourceScopeForOwner,
 } from "./agent-chat/prompt-resources.js";
 import { shouldDisableRecurringJobsRuntime } from "./agent-chat/recurring-jobs-runtime.js";
@@ -265,6 +270,13 @@ export { loadRunCodeToolEntries };
 export { shouldDisableRecurringJobsRuntime };
 export { finalizeClaimedAgentChatProcessRunFailure };
 
+export function buildLeanRunPolicyPrompt(
+  codeEditingSurfaceRestriction: string,
+  prodCodeExecPromptNote: string,
+): string {
+  return codeEditingSurfaceRestriction + prodCodeExecPromptNote;
+}
+
 /**
  * Returns whether `owner` has already finished (or explicitly skipped) the
  * First-Session Personalization flow, via the owner-scoped
@@ -2329,6 +2341,104 @@ export function createAgentChatPlugin(
         return prompt;
       };
 
+      const emitContextXraySystemSections = async (
+        event: any,
+        input: {
+          frameworkPrompt?: string;
+          actionsPrompt?: string;
+          resources?: string;
+          schemaBlock?: string;
+          modelOverlay?: string;
+          runtimeContext?: string;
+          additionalFramework?: string;
+          extra?: string;
+        },
+      ): Promise<void> => {
+        const sections = await buildSystemManifestSections([
+          ...(input.frameworkPrompt
+            ? [
+                {
+                  label: "Framework core",
+                  provenance: "framework-core" as const,
+                  governance: "required" as const,
+                  content: input.frameworkPrompt,
+                  sourceRef: { scope: "framework" },
+                },
+              ]
+            : []),
+          ...(input.actionsPrompt
+            ? [
+                {
+                  label: "Available actions prompt",
+                  provenance: "actions-prompt" as const,
+                  governance: "required" as const,
+                  content: input.actionsPrompt,
+                  sourceRef: { scope: "actions" },
+                },
+              ]
+            : []),
+          ...(input.resources
+            ? promptResourceManifestSections(input.resources)
+            : []),
+          ...(input.schemaBlock
+            ? [
+                {
+                  label: "SQL schema",
+                  provenance: "db-schema" as const,
+                  governance: "required" as const,
+                  content: input.schemaBlock,
+                  sourceRef: { scope: "sql" },
+                },
+              ]
+            : []),
+          ...(input.additionalFramework
+            ? [
+                {
+                  label: "Framework run policy",
+                  provenance: "framework-core" as const,
+                  governance: "required" as const,
+                  content: input.additionalFramework,
+                  sourceRef: { scope: "framework" },
+                },
+              ]
+            : []),
+          ...(input.extra
+            ? [
+                {
+                  label: "App runtime context",
+                  provenance: "runtime-context" as const,
+                  governance: "inherited" as const,
+                  content: input.extra,
+                  sourceRef: { scope: "app" },
+                },
+              ]
+            : []),
+          ...(input.modelOverlay
+            ? [
+                {
+                  label: "Model overlay",
+                  provenance: "model-overlay" as const,
+                  governance: "required" as const,
+                  content: input.modelOverlay,
+                  sourceRef: { scope: "model" },
+                },
+              ]
+            : []),
+          ...(input.runtimeContext
+            ? [
+                {
+                  label: "Runtime context",
+                  provenance: "runtime-context" as const,
+                  governance: "required" as const,
+                  content: input.runtimeContext,
+                  sourceRef: { scope: "runtime" },
+                },
+              ]
+            : []),
+        ]);
+        setContextXraySystemSections(event, sections);
+      };
+
       /**
        * Read the model family overlay for the currently-resolved model.
        * onEngineResolved sets runCtx.model before systemPrompt is called, so
@@ -2420,10 +2530,24 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
           // everything that follows it — putting it last means a day
           // rollover invalidates as little of the prefix as possible.
           if (leanPrompt) {
+            const leanRunPolicyPrompt = buildLeanRunPolicyPrompt(
+              codeEditingSurfaceRestriction,
+              prodCodeExecPromptNote,
+            );
+            await emitContextXraySystemSections(event, {
+              frameworkPrompt: leanBasePrompt.slice(
+                0,
+                Math.max(0, leanBasePrompt.length - prodActionsPrompt.length),
+              ),
+              actionsPrompt: prodActionsPrompt,
+              additionalFramework: leanRunPolicyPrompt,
+              extra,
+              modelOverlay,
+              runtimeContext,
+            });
             return setSystemPromptOnContext(
               leanBasePrompt +
-                codeEditingSurfaceRestriction +
-                prodCodeExecPromptNote +
+                leanRunPolicyPrompt +
                 extra +
                 modelOverlay +
                 runtimeContext,
@@ -2439,6 +2563,22 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
           const schemaBlock = lazyContext
             ? ""
             : await buildSchemaBlock(owner, databaseToolsMode);
+          await emitContextXraySystemSections(event, {
+            frameworkPrompt: basePrompt.slice(
+              0,
+              Math.max(0, basePrompt.length - prodActionsPrompt.length),
+            ),
+            actionsPrompt: prodActionsPrompt,
+            resources,
+            schemaBlock,
+            extra,
+            modelOverlay,
+            runtimeContext,
+            additionalFramework:
+              personalizationBlock +
+              codeEditingSurfaceRestriction +
+              prodCodeExecPromptNote,
+          });
           return setSystemPromptOnContext(
             basePrompt +
               personalizationBlock +
@@ -2548,6 +2688,11 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
               actions: anonymousReadOnlyActions,
               systemPrompt: async (event: any) => {
                 const { extra } = await prepareRun(event);
+                await emitContextXraySystemSections(event, {
+                  frameworkPrompt: anonymousReadOnlyPrompt,
+                  extra,
+                  runtimeContext: runtimeContextForEvent(event),
+                });
                 return setSystemPromptOnContext(
                   anonymousReadOnlyPrompt +
                     extra +
@@ -2668,6 +2813,16 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
             // cached prompt prefix as possible. See the prod handler above
             // for the same pattern.
             if (leanPrompt) {
+              await emitContextXraySystemSections(event, {
+                frameworkPrompt: leanBasePrompt.slice(
+                  0,
+                  Math.max(0, leanBasePrompt.length - prodActionsPrompt.length),
+                ),
+                actionsPrompt: prodActionsPrompt,
+                extra,
+                modelOverlay,
+                runtimeContext,
+              });
               return setSystemPromptOnContext(
                 leanBasePrompt + extra + modelOverlay + runtimeContext,
               );
@@ -2681,6 +2836,24 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
               lazyContext || !databaseToolsEnabled
                 ? ""
                 : await buildSchemaBlock(owner, databaseToolsMode);
+            await emitContextXraySystemSections(event, {
+              frameworkPrompt: devNative
+                ? basePrompt.slice(
+                    0,
+                    Math.max(0, basePrompt.length - prodActionsPrompt.length),
+                  )
+                : devPrompt.slice(
+                    0,
+                    Math.max(0, devPrompt.length - devActionsPrompt.length),
+                  ),
+              actionsPrompt: devNative ? prodActionsPrompt : devActionsPrompt,
+              resources,
+              schemaBlock,
+              extra,
+              modelOverlay,
+              runtimeContext,
+              additionalFramework: personalizationBlock,
+            });
             return setSystemPromptOnContext(
               devPrompt +
                 personalizationBlock +

package/corpus/core/src/server/auth.ts

@@ -144,6 +144,7 @@ import {
   type OnboardingHtmlOptions,
 } from "./onboarding-html.js";
 import { captureAuthError } from "./sentry.js";
+import { isWorkspaceOAuthCallbackRelayEnabled } from "./workspace-oauth.js";
 
 /**
  * Get the configured session max age. Desktop SSO broker writes from
@@ -1455,13 +1456,6 @@ function mountAuthCorsMiddleware(app: H3App): void {
   app.use("/_agent-native/google", handler);
 }
 
-function isWorkspaceOAuthCallbackRelayEnabled(): boolean {
-  return (
-    process.env.AGENT_NATIVE_WORKSPACE === "1" ||
-    process.env.VITE_AGENT_NATIVE_WORKSPACE === "1"
-  );
-}
-
 function isFrameworkOAuthCallbackPath(pathname: string): boolean {
   return (
     pathname.startsWith("/_agent-native/") &&

package/corpus/core/src/server/google-oauth.ts

@@ -34,6 +34,7 @@ import {
 import { getWorkspaceA2ADerivedSecret } from "./derived-secret.js";
 import { writeDesktopSso } from "./desktop-sso.js";
 import { appendSessionToOAuthReturnUrl } from "./oauth-return-url.js";
+import { isWorkspaceOAuthCallbackRelayEnabled } from "./workspace-oauth.js";
 
 // ─── Platform Detection ─────────────────────────────────────────────────────
 
@@ -294,13 +295,6 @@ export function getAppUrl(event: H3Event, path = "/"): string {
   return `${getOrigin(event)}${getAppBasePath()}${cleanPath}`;
 }
 
-function isWorkspaceOAuthCallbackRelayEnabled(): boolean {
-  return (
-    process.env.AGENT_NATIVE_WORKSPACE === "1" ||
-    process.env.VITE_AGENT_NATIVE_WORKSPACE === "1"
-  );
-}
-
 function isFrameworkOAuthCallbackPath(pathname: string): boolean {
   return (
     pathname.startsWith("/_agent-native/") &&

package/corpus/core/src/server/workspace-oauth.ts

@@ -0,0 +1,31 @@
+/**
+ * Whether workspace OAuth callbacks use the root framework relay.
+ *
+ * Workspace deploy wrappers normally provide the runtime flags, but mounted
+ * app bundles can retain only their workspace app id or build-time Vite env.
+ * Redirect construction and callback handling must use this exact same
+ * predicate so a callback sent to the root relay is always forwarded back to
+ * the mounted app that initiated it.
+ */
+export function isWorkspaceOAuthCallbackRelayEnabled(): boolean {
+  const metaEnv = (
+    import.meta as unknown as {
+      env?: Record<string, string | undefined>;
+    }
+  ).env;
+
+  return (
+    [
+      process.env.AGENT_NATIVE_WORKSPACE,
+      process.env.VITE_AGENT_NATIVE_WORKSPACE,
+      metaEnv?.AGENT_NATIVE_WORKSPACE,
+      metaEnv?.VITE_AGENT_NATIVE_WORKSPACE,
+    ].some((value) => value === "1" || value === "true") ||
+    [
+      process.env.AGENT_NATIVE_WORKSPACE_APP_ID,
+      process.env.VITE_AGENT_NATIVE_WORKSPACE_APP_ID,
+      metaEnv?.AGENT_NATIVE_WORKSPACE_APP_ID,
+      metaEnv?.VITE_AGENT_NATIVE_WORKSPACE_APP_ID,
+    ].some((value) => typeof value === "string" && value.trim().length > 0)
+  );
+}

package/corpus/core/src/shared/context-xray.ts

@@ -16,7 +16,63 @@ export type ContextSegmentStatus =
   | "evicted"
   | "summarized";
 export type ContextTokenCountMethod = "exact" | "estimate";
-export type ContextManifestSource = "structured" | "flattened" | "external";
+export type ContextManifestSource =
+  | "structured"
+  | "flattened"
+  | "external"
+  | "preview";
+export type ContextSystemProvenance =
+  | "framework-core"
+  | "actions-prompt"
+  | "template"
+  | "enterprise-workspace-core"
+  | "sql-workspace"
+  | "legacy-app-default"
+  | "organization"
+  | "personal"
+  | "memory"
+  | "db-schema"
+  | "tools"
+  | "model-overlay"
+  | "runtime-context";
+export type ContextGovernanceTier = "required" | "inherited" | "user";
+
+export interface ContextManifestSourceRef {
+  resourceId?: string;
+  path?: string;
+  scope?: string;
+}
+
+/**
+ * A non-evictable system-prompt contribution. This is intentionally separate
+ * from conversation segments so old manifests can be read without a schema
+ * migration and directive code can never accidentally evict system context.
+ */
+export interface ContextManifestSystemSection {
+  kind: "system";
+  segmentId: string;
+  group: string;
+  label: string;
+  provenance: ContextSystemProvenance;
+  governance: ContextGovernanceTier;
+  tokenCount: number;
+  tokenMethod: ContextTokenCountMethod;
+  sourceRef?: ContextManifestSourceRef;
+  contentHash: string;
+  preview: string;
+  timestamp: number;
+}
+
+export interface ContextPreview {
+  computedAt: number;
+  model?: string;
+  scope: "user" | "org";
+  totalTokens: number;
+  systemTokens: number;
+  tokenCountMethod: ContextTokenCountMethod;
+  sections: ContextManifestSystemSection[];
+  source: "preview";
+}
 
 export interface ContextDirective {
   id?: string;
@@ -58,12 +114,36 @@ export interface ContextManifest {
   rawTokens: number;
   reclaimedTokens: number;
   tokenCountMethod: ContextTokenCountMethod;
+  /** Conversation-only total. Old manifests omit this and are conversation-only. */
+  conversationTokens?: number;
+  /** System-prompt total. Old manifests omit this and have no system sections. */
+  systemTokens?: number;
   source: ContextManifestSource;
   enforceable: boolean;
   segments: ContextManifestSegment[];
+  /** Optional for strict backward compatibility with persisted old manifests. */
+  systemSections?: ContextManifestSystemSection[];
   url?: string;
 }
 
+export function manifestSystemTokens(manifest: ContextManifest): number {
+  return (
+    manifest.systemTokens ??
+    manifest.systemSections?.reduce(
+      (total, section) => total + section.tokenCount,
+      0,
+    ) ??
+    0
+  );
+}
+
+export function manifestConversationTokens(manifest: ContextManifest): number {
+  return (
+    manifest.conversationTokens ??
+    Math.max(0, manifest.totalTokens - manifestSystemTokens(manifest))
+  );
+}
+
 export function emptyContextManifest(
   threadId: string,
   opts: {
@@ -85,5 +165,8 @@ export function emptyContextManifest(
     source: opts.source ?? "structured",
     enforceable: opts.enforceable ?? true,
     segments: [],
+    conversationTokens: 0,
+    systemTokens: 0,
+    systemSections: [],
   };
 }