chore(sync): preview upstream main merge

.changeset/execution-history-content-fit-table.md

@@ -0,0 +1,13 @@
+---
+"@executor-js/plugin-execution-history": patch
+---
+
+Rebuild the runs list as a real semantic `<table>` with content-fit columns.
+Each column now sizes to the maximum width its rows need (browser
+`table-layout: auto`), instead of fixed pixel widths — the sticky `<thead>` and
+the rows share one column model so they stay aligned for free. Short / numeric /
+badge columns (status, duration, tools, interaction, log) are centered; text
+columns (started, trigger, actor, code) are left-aligned. The two columns that
+can run long — `actor` and `code` — are width-capped and truncated (hover shows
+the full value). Removes the fixed-width `COL_*` slot constants and the
+`min-w` horizontal-scroll floor.

.changeset/execution-history-plugin.md

@@ -0,0 +1,12 @@
+---
+"@executor-js/plugin-execution-history": minor
+---
+
+Add the `@executor-js/plugin-execution-history` plugin — an opt-in execution
+history sink built on the ExecutionObserver foundation. It records every run
+(plus its tool calls and interactions) into three owner-scoped pluginStorage
+collections via a buffered-batch writer (no new tables, no migrations; works on
+D1/libSQL/sqlite/postgres), exposes a `list`/`get`/`listToolCalls` read API over
+HttpApi (`./api`'s `executionHistoryHttpPlugin`), and ships a Runs page UI
+(`./client`) that mounts at `/plugins/executionHistory/`. The base `.` entry is
+SDK-only and never loads `@executor-js/api` or React.

.changeset/execution-history-r2-detail.md

@@ -0,0 +1,18 @@
+---
+"@executor-js/plugin-execution-history": minor
+---
+
+Move per-run detail to an append-only R2 object and slim the D1 index. The
+`runs` row now keeps only list/aggregate fields plus a bounded `codePreview` and
+denormalized `logErrorCount`/`logWarnCount`, so the runs list renders entirely
+from D1 with no per-row blob fetch. Full `code`, `resultJson`, `errorText`,
+`logsJson`, `triggerMetaJson`, and the per-tool-call / per-interaction rows now
+live in one immutable object per run in the plugin blob store (keyed
+`run-detail/<executionId>`) — a code-only stub on `ExecutionStarted`, the full
+detail on finish. The detail drawer reads it in a single request (`get`
+flat-merges the R2 detail onto the slim run); the separate tool-calls endpoint
+and `runToolCallsAtom` are removed, and the `toolCalls`/`interactions`
+collections are gone.
+
+Breaking: the runs list/detail response shapes change and past runs are cleared
+(no backfill, no compatibility shim — the cutover wipe is authoritative).

.changeset/execution-history-rich-list.md

@@ -0,0 +1,15 @@
+---
+"@executor-js/plugin-execution-history": minor
+---
+
+Rework the runs list into a keyset-paginated, aggregate-aware read surface
+backed by the storage JSON pushdown. The `list` endpoint now takes an opaque
+keyset `cursor` (instead of offset), a sort field (`startedAt`/`durationMs`)
+with direction, and a live-tail `after` floor, and returns `{ runs, nextCursor,
+meta }`. The `meta` block — computed once per filter set on the first page —
+carries status/trigger facet counts (each ignoring its own filter), interaction
+counts, a stacked-by-status timeline with a server-chosen bucket width, total
+and filtered row counts, and duration min/max plus P50–P99 percentiles. All
+counts, buckets, percentiles, and pages are pushed to SQL rather than reducing
+the whole collection in memory. Tool-path facets and full-text code search are
+intentionally not included yet.

.changeset/execution-history-runs-ui.md

@@ -0,0 +1,13 @@
+---
+"@executor-js/plugin-execution-history": minor
+---
+
+Rebuild the runs page as an openstatus-style observability table on the keyset +
+aggregate API. The page now has a faceted filter rail (status / trigger /
+interaction / time range with live counts), a cmdk filter command palette, a
+stacked-by-status timeline chart with drag-to-zoom, live tailing, keyset
+infinite scroll, sortable columns, column visibility, keyboard shortcuts, and
+the existing 4-tab detail drawer. List data flows through an Effect-atoms hook
+(`useRunsList`) that accumulates cursor pages and polls the head for live mode;
+the accumulation logic is a pure, unit-tested reducer. Adds `recharts` as an
+optional peer dependency (provided by `@executor-js/react`).

.changeset/execution-metrics-plugin.md

@@ -0,0 +1,13 @@
+---
+"@executor-js/plugin-execution-metrics": minor
+---
+
+Add the `@executor-js/plugin-execution-metrics` plugin — an opt-in metrics sink
+built on the ExecutionObserver foundation. The base plugin drives Effect Metric
+counters and an execution-duration histogram from the event stream; `./api`'s
+`executionMetricsHttpPlugin` exposes them as an auth-gated `GET
+/execution-metrics/metrics` Prometheus scrape for long-lived hosts; and
+`./cloudflare`'s `createWaeMetricsObserver` writes Workers Analytics Engine data
+points on the Cloudflare host (per-isolate Effect metrics being meaningless on a
+Worker fleet). The base `.` entry never loads `@executor-js/api` or
+`@cloudflare/workers-types`.

.changeset/execution-observer-foundation.md

@@ -0,0 +1,14 @@
+---
+"@executor-js/sdk": minor
+"@executor-js/execution": minor
+"@executor-js/api": minor
+---
+
+Add the execution-observer foundation. The execution engine now emits a typed
+lifecycle stream (`ExecutionStarted`/`Finished`, `ToolCallStarted`/`Finished`,
+`InteractionStarted`/`Resolved`), plugins can subscribe via the new
+`plugin.runtime.executionObserver` hook, and `makeExecutionStack` composes every
+registered plugin's observer onto the engine. Behaviour is unchanged when no
+plugin observes — this is the opt-in seam the execution-history and
+execution-metrics plugins build on. Also exposes `Executor.owner` and enriches
+the `mcp.execute` span with the run id and trigger.

.changeset/fumadb-json-pushdown.md

@@ -0,0 +1,16 @@
+---
+"@executor-js/fumadb": minor
+"@executor-js/sdk": minor
+---
+
+Push JSON-document aggregation and keyset pagination down to SQL. FumaDB's query
+layer gains `jsonCount`, `jsonGroupCount`, `jsonTimeBuckets`, `jsonStats`
+(min/max + continuous percentiles), and `jsonPage` (cursor pagination) over a
+JSON document column, implemented natively for the memory and Drizzle
+(SQLite/Postgres) adapters and failing loudly on adapters that don't support
+them. Plugin storage exposes this as `collection.aggregate.{count,groupCount,
+timeBuckets,stats}` and `collection.queryKeyset(...)`, translating a
+collection's indexed-field `where` into JSON-path predicates while owner/tenant
+scoping stays enforced by the storage policy. Aggregates and pages are computed
+in the database instead of by fetching the whole collection and reducing in
+memory.

.changeset/semantic-search-manifest-snapshot.md

@@ -0,0 +1,10 @@
+---
+"@executor-js/sdk": minor
+"@executor-js/plugin-semantic-search": minor
+---
+
+Snapshot the tool manifest per reindex run instead of re-reading it from D1 on every scan page.
+
+`createExecutor` now exposes its cache `KeyValueStore` on the executor instance as `executor.cache`, so plugins can reach durable cache storage (Cloudflare KV in production) without re-threading a binding — wrap it with `KeyValueStore.toSchemaStore` for typed entries, the same way the internal `tools.list` / schema-view caches do.
+
+The semantic-search scan phase used to call `tools.manifest()` — a full `tool_schema_manifest` table read — once per partition page, so an unchanged catalog cost `O(N² / pageLimit)` cross-region reads. Now `create` reads the manifest once, partitions it, and writes one snapshot per partition to `executor.cache`; `scan` reads only its partition's snapshot (KV-only, with no D1 fallback on the hot path — a miss fails the message so the queue retries). Snapshots are deleted when the run completes. This collapses the scan's manifest reads from `O(N² / pageLimit)` to a single pass and cuts per-message memory from the whole manifest to one partition's slice.

.changeset/semantic-search-tenant-namespace-prefix.md

@@ -0,0 +1,14 @@
+---
+"@executor-js/plugin-semantic-search": patch
+---
+
+fix: don't default the operator search prefix filter to the tenant namespace
+
+`executor.semanticSearch.search` (the operator `tools.search` surface) overloaded a
+single `namespace` value as both the Vectorize tenant namespace (storage isolation)
+and the optional integration/path-prefix filter. With no operator-supplied prefix it
+defaulted the filter to the tenant namespace (e.g. `"default"`), so the provider's
+`matchesNamespace` required every tool path to start with the tenant id and dropped
+every result — search returned nothing for all queries despite a fully populated
+index. The integration prefix is now applied only when explicitly provided; the
+tenant namespace drives the store query alone and is still reported on the result page.

.changeset/tools-list-revision-cache.md

@@ -0,0 +1,14 @@
+---
+"@executor-js/sdk": minor
+---
+
+Cache `tools.list` by a content-derived catalog revision. `produceConnectionTools` now
+records a per-connection `toolset_revision` — a hash of the connection's manifest
+`(path, index_fingerprint)` pairs — in `plugin_storage`, and `tools.list` keys a KV cache of
+the DB-derived, policy-filtered list on the combined catalog revision plus a policy
+revision (both read live, O(connections)/O(policies), not the full `tool` scan). Static tools
+are unioned live and the `query` substring filter is applied post-cache, so a distinct query
+reuses the same cached set. The cache stays warm through token rotation and unrelated writes
+and invalidates exactly when a connection's tool set, a tool's schema, or a `tool_policy`
+changes — including OpenAPI/MCP tool additions on refresh (a new manifest row) and
+connection/integration removal.

.changeset/tools-schema-precompile-typescript.md

@@ -0,0 +1,15 @@
+---
+"@executor-js/sdk": minor
+"@executor-js/plugin-semantic-search": patch
+---
+
+Always render the TypeScript preview in `executor.tools.schema` and warm it during
+indexing. The `includeTypeScript` option (and the now-empty `ToolSchemaOptions` type) is
+removed — the only caller that passed `false` was the reindex pipeline, which did so to
+skip the CPU-heavy JSON-schema → TypeScript codegen. It now calls `tools.schema` plainly,
+so every reindex pre-warms exactly the schema view the web UI reads on first open (the
+codegen is content-addressed in KV), turning first tool-detail views into cache hits
+instead of a cold compile. The embedding text is unchanged — the indexer only ever read
+the raw schema facets, never the rendered TypeScript. Because `includeTypeScript` is
+dropped from the schema-view cache key, existing cached entries are superseded on the next
+reindex or view (regenerable derived data).

.oxlintrc.jsonc

@@ -3,6 +3,16 @@
   "jsPlugins": [{ "name": "executor", "specifier": "./scripts/oxlint-plugin-executor.js" }],
   "rules": {
     "typescript/no-explicit-any": "error",
+    // Unused function parameters are allowed with their real names (no `_`
+    // prefix required) — keep a descriptive name for params retained for
+    // signature/interface reasons. Unused *variables* and imports are still
+    // flagged. Same for unused catch bindings. Destructuring-skip variables
+    // (e.g. `{ type: _type, ...rest }`) keep the `_` convention since they
+    // cannot be omitted structurally.
+    "no-unused-vars": [
+      "error",
+      { "args": "none", "caughtErrors": "none", "varsIgnorePattern": "^_" },
+    ],
     "executor/no-vitest-import": "error",
     "executor/no-conditional-tests": "error",
     "executor/no-double-cast": "error",

apps/cloud/src/api/protected-api-key-auth.node.test.ts

@@ -27,7 +27,7 @@ const stubApiKeys = Layer.succeed(ApiKeyService)({
 const stubWorkOS = Layer.succeed(
   WorkOSClient,
   new Proxy({} as WorkOSClientService, {
-    get: (_target, prop) => {
+    get: (target, prop) => {
       if (prop === "listUserMemberships") {
         return (userId: string) =>
           Effect.succeed({
@@ -87,6 +87,7 @@ describe("protected API key auth", () => {
         accountId: "user_123",
         organizationId: "org_123",
         organizationName: "Org org_123",
+        organizationSlug: "org-slug-org_123",
         email: "",
         name: null,
         avatarUrl: null,

apps/cloud/src/api/protected-jwt-auth.node.test.ts

@@ -109,6 +109,7 @@ describe("protected JWT (device-login) auth", () => {
         accountId: "user_123",
         organizationId: "org_123",
         organizationName: "Org org_123",
+        organizationSlug: "org-slug-org_123",
         email: "",
         name: null,
         avatarUrl: null,

apps/cloud/src/auth/api-keys.node.test.ts

@@ -8,7 +8,7 @@ const stubWorkOS = (overrides: Partial<WorkOSClientService>) =>
   Layer.succeed(
     WorkOSClient,
     new Proxy({} as WorkOSClientService, {
-      get: (_target, prop) => {
+      get: (target, prop) => {
         if (prop in overrides) return overrides[prop as keyof WorkOSClientService];
         return () => Effect.die(`unexpected WorkOSClient.${String(prop)} call`);
       },

apps/cloud/src/auth/middleware-live.ts

@@ -6,7 +6,12 @@
 import { Effect, Layer, Redacted } from "effect";
 import { HttpServerResponse } from "effect/unstable/http";
 
-import { AuthContext, NoOrganization, Unauthorized } from "@executor-js/api/server";
+import {
+  AuthContext,
+  authContextFromPrincipal,
+  NoOrganization,
+  Unauthorized,
+} from "@executor-js/api/server";
 
 import {
   OrgAuth,
@@ -93,17 +98,20 @@ export const OrgAuthLive = Layer.effect(
           // (org-settings → domain verification) is niche; URL-scoping it would
           // mean converting this to an HttpRouter middleware — deferred.
           const session = sessionFromSealed(result, Redacted.value(credential));
-          const auth = {
+          // Wrap the WorkOS session into a neutral `Principal` and let
+          // `authContextFromPrincipal` derive everything (incl. the run actor),
+          // so this path never re-implements the actor/label logic. `roles` is
+          // empty (the WorkOS control plane doesn't resolve them here; no cloud
+          // handler reads them) and `organizationName` is unused by AuthContext.
+          const auth = authContextFromPrincipal({
             accountId: session.accountId,
             organizationId: result.organizationId,
+            organizationName: "",
             email: session.email,
             name: session.name,
             avatarUrl: session.avatarUrl,
-            // The unified `AuthContext` carries roles; cloud's WorkOS control
-            // plane does not resolve them here, so pass an empty list (no cloud
-            // handler reads roles today).
             roles: [],
-          };
+          });
 
           return yield* Effect.provideService(httpEffect, AuthContext, auth);
         }),

apps/cloud/src/auth/org-selector-auth.node.test.ts

@@ -32,7 +32,7 @@ const stubApiKeys = Layer.succeed(ApiKeyService)({
 const stubWorkOS = Layer.succeed(
   WorkOSClient,
   new Proxy({} as WorkOSClientService, {
-    get: (_t, prop) => {
+    get: (target, prop) => {
       if (prop === "authenticateRequest") {
         return () =>
           Effect.succeed({ userId: MEMBER, email: "u@e2e.test", organizationId: SESSION_ORG });

apps/cloud/src/db/db.schema.test.ts

@@ -106,9 +106,14 @@ describe("combinedSchema", () => {
             provider: "postgresql",
           });
           const schemaTables = drizzleTableColumns(combinedSchema);
+          const missingTables: string[] = [];
           const missingColumns: string[] = [];
 
           for (const table of Object.values(fumaDbInternals(fuma.db).internal.tables)) {
+            if (schemaTables[table.names.drizzle] === undefined) {
+              missingTables.push(table.names.drizzle);
+              continue;
+            }
             const drizzleTable = drizzleTableColumns(schemaTables[table.names.drizzle]);
             for (const column of Object.values(table.columns)) {
               if (drizzleTable[column.names.drizzle] === undefined) {
@@ -119,6 +124,7 @@ describe("combinedSchema", () => {
             }
           }
 
+          expect(missingTables).toEqual([]);
           expect(missingColumns).toEqual([]);
         }),
       ),

apps/cloud/src/db/executor-schema.ts

@@ -184,6 +184,44 @@ export const definition = pgTable(
   ],
 );
 
+export const tool_schema_manifest = pgTable(
+  "tool_schema_manifest",
+  {
+    integration: varchar("integration", { length: 255 }).notNull(),
+    connection: varchar("connection", { length: 255 }).notNull(),
+    plugin_id: text("plugin_id").notNull(),
+    name: varchar("name", { length: 255 }).notNull(),
+    path: varchar("path", { length: 255 }).notNull(),
+    description: text("description").notNull(),
+    descriptor_hash: text("descriptor_hash").notNull(),
+    input_schema_hash: text("input_schema_hash").notNull(),
+    output_schema_hash: text("output_schema_hash").notNull(),
+    definition_set_hash: text("definition_set_hash").notNull(),
+    index_fingerprint: text("index_fingerprint").notNull(),
+    fingerprint_version: text("fingerprint_version").notNull(),
+    source_revision: text("source_revision"),
+    created_at: timestamp("created_at").notNull(),
+    updated_at: timestamp("updated_at").notNull(),
+    row_id: varchar("row_id", { length: 255 })
+      .primaryKey()
+      .notNull()
+      .$defaultFn(() => createId()),
+    tenant: varchar("tenant", { length: 255 }).notNull(),
+    owner: varchar("owner", { length: 255 }).notNull(),
+    subject: varchar("subject", { length: 255 }).notNull(),
+  },
+  (table) => [
+    uniqueIndex("tool_schema_manifest_uidx").on(
+      table.tenant,
+      table.owner,
+      table.subject,
+      table.integration,
+      table.connection,
+      table.name,
+    ),
+  ],
+);
+
 export const tool_policy = pgTable(
   "tool_policy",
   {

apps/cloud/src/engine/execution-usage.ts

@@ -12,9 +12,9 @@ export const withExecutionUsageTracking = <E extends Cause.YieldableError>(
     engine
       .execute(code, options)
       .pipe(Effect.tap(() => Effect.sync(() => trackUsage(organizationId)))),
-  executeWithPause: (code) =>
+  executeWithPause: (code, options) =>
     engine
-      .executeWithPause(code)
+      .executeWithPause(code, options)
       .pipe(Effect.tap(() => Effect.sync(() => trackUsage(organizationId)))),
   // resume doesn't count as usage
   resume: (executionId, response) => engine.resume(executionId, response),

apps/cloud/src/org/handlers.test.ts

@@ -32,7 +32,7 @@ const stubWorkOS = (overrides: StubOverrides = {}) =>
   Layer.succeed(
     WorkOSClient,
     new Proxy({} as WorkOSClientService, {
-      get: (_target, prop) => {
+      get: (target, prop) => {
         if (typeof prop === "string" && prop in overrides) {
           return overrides[prop as keyof StubOverrides];
         }
@@ -53,6 +53,7 @@ const adminAuth = {
   name: "Admin",
   avatarUrl: null,
   roles: [],
+  actor: { kind: "user", id: "user_admin", label: "Admin" },
 };
 
 const memberAuth = {
@@ -62,6 +63,7 @@ const memberAuth = {
   name: "Member",
   avatarUrl: null,
   roles: [],
+  actor: { kind: "user", id: "user_member", label: "Member" },
 };
 
 const provide = (auth: typeof adminAuth, workosOverrides: StubOverrides = {}) =>
@@ -78,7 +80,7 @@ const requireAdmin = Effect.gen(function* () {
 });
 
 const withCurrentMembership: StubOverrides = {
-  getUserOrgMembership: (_organizationId: string, userId: string) =>
+  getUserOrgMembership: (organizationId: string, userId: string) =>
     Effect.succeed(
       userId === "user_admin"
         ? { id: "mem_admin", userId, status: "active", role: { slug: "admin" } }