@opengeni/worker-bundle 0.28.3 → 0.28.4-canary.1

package/dist/sandbox-archive-storage.d.ts

@@ -1,4 +1,5 @@
-import type { ObjectStorage } from "@opengeni/storage";
+import { type ObjectStorage } from "@opengeni/storage";
+import type { VerifiedHostWorkspaceArchive } from "@opengeni/runtime/sandbox";
 import { type WorkspaceArchiveDescriptor, type WorkspaceArchiveObjectRef } from "@opengeni/contracts";
 export declare class WorkspaceArchiveObjectStorageRequiredError extends Error {
     readonly code: "workspace_archive_object_storage_required";
@@ -13,15 +14,26 @@ export declare function putTarWorkspaceArchiveObject(input: {
     archive: {
         bytes: Uint8Array;
         descriptor: WorkspaceArchiveDescriptor;
-    };
+    } | VerifiedHostWorkspaceArchive;
 }): Promise<WorkspaceArchiveObjectRef>;
+/** The caller owns a fresh candidate returned by this module. A thrown or lost
+ * database response is UNKNOWN: it may have committed, so never delete on catch.
+ * Only the transaction's exact candidate disposition can authorize cleanup. */
+export declare function persistWorkspaceArchiveCandidate<T extends {
+    wrote: boolean;
+    candidateDisposition?: "adopted" | "already_referenced" | "unused";
+}>(input: {
+    objectStorage?: ObjectStorage | null;
+    ref?: WorkspaceArchiveObjectRef;
+    persist: () => Promise<T>;
+}): Promise<T>;
 export declare function putVersion1TarArchiveOrInline(input: {
     backend: string;
     objectStorage?: ObjectStorage | null | undefined;
     accountId: string;
     workspaceId: string;
     sandboxGroupId: string;
-    archive: {
+    archive: VerifiedHostWorkspaceArchive | {
         bytes: Uint8Array;
         descriptor: WorkspaceArchiveDescriptor;
         base64: string;

package/dist/sandbox-resume.d.ts

@@ -1,7 +1,7 @@
 import { type Settings } from "@opengeni/config";
 import { readLease, reinstateTurnLeaseHolder, SandboxLeaseSupersededError, type Database, type LeaseHolderKind } from "@opengeni/db";
 import { establishSandboxSessionFromEnvelope, type EstablishedSandboxSession, type RuntimeMetricsHooks } from "@opengeni/runtime";
-import type { ObjectStorage } from "@opengeni/storage";
+import { type ObjectStorage } from "@opengeni/storage";
 import type { Observability } from "@opengeni/observability";
 export type ResumeHolderKind = LeaseHolderKind;
 /**

package/dist/sandbox-routing.d.ts

@@ -2,7 +2,7 @@ import { type Settings } from "@opengeni/config";
 import { type Database, type EnrollmentRecord } from "@opengeni/db";
 import type { OpStreamOutputFrame } from "@opengeni/runtime/sandbox";
 import type { EventBus } from "@opengeni/events";
-import { type EstablishedSandboxSession, type RoutingSandboxFirstOperationObserver, type RoutingSandboxOperationObserver, type SelfhostedOpObserver, type SelfhostedRelayConfig, type OpStreamJournal } from "@opengeni/runtime";
+import { type EstablishedSandboxSession, type RoutingSandboxFirstOperationObserver, type RoutingSandboxOperationObserver, type SelfhostedOpObserver, type SelfhostedConnectionBinding, type SelfhostedRelayConfig, type OpStreamJournal } from "@opengeni/runtime";
 export type RoutingWiringServices = {
     db: Database;
     settings: Settings;
@@ -179,6 +179,8 @@ export type SelfhostedTurnSessionArgs = {
     operationResourcePolicy: EnrollmentRecord["operationPolicy"];
     operationResourcePolicySupported: boolean;
     operationCpuQuotaSupported: boolean;
+    /** Feature advertisement only; refreshed by exact live admission for each operation. */
+    transactionalFsWriteSupported?: boolean;
     /** The active pointer's epoch — the control-op fence echoed to the agent. */
     epoch: number;
     /** The run's declared sandbox environment (the SAME object fed to buildAgent +
@@ -197,6 +199,9 @@ export type SelfhostedTurnSessionArgs = {
         sessionId: string;
     };
 };
+/** Project one enrollment read into one exact runtime route. Capability and
+ * process identity must be taken from the same snapshot. */
+export declare function connectionBindingFor(services: RoutingWiringServices, enrollment: EnrollmentRecord | null): SelfhostedConnectionBinding | null;
 export declare function establishSelfhostedTurnSession(services: RoutingWiringServices, args: SelfhostedTurnSessionArgs): Promise<EstablishedSandboxSession>;
 /** Whether the routing proxy should wrap the turn box: the hot-swap feature is
  *  gated by the selfhosted flag (the active pointer + swap tools are only

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengeni/worker-bundle",
-  "version": "0.28.3",
+  "version": "0.28.4-canary.1",
   "description": "OpenGeni worker entry and reusable embedded lifecycle, shipped with a release-coherent pre-bundled Temporal workflow artifact.",
   "license": "Apache-2.0",
   "repository": {
@@ -54,22 +54,23 @@
   },
   "dependencies": {
     "@llamaindex/liteparse": "2.14.2",
-    "@opengeni/agent-proto": "^0.5.1",
-    "@opengeni/capabilities": "^0.3.3",
-    "@opengeni/codemode": "^0.5.5",
-    "@opengeni/codex": "^0.2.22",
-    "@opengeni/config": "^1.1.1",
-    "@opengeni/contracts": "^3.0.1",
-    "@opengeni/core": "^2.9.3",
-    "@opengeni/db": "^4.3.2",
-    "@opengeni/documents": "^0.8.26",
-    "@opengeni/events": "^0.4.24",
-    "@opengeni/github": "^0.7.9",
-    "@opengeni/network": "^0.3.1",
-    "@opengeni/observability": "^0.8.25",
-    "@opengeni/runtime": "^2.5.2",
-    "@opengeni/storage": "^0.2.126",
-    "@opengeni/xai-subscription": "^0.1.4",
+    "@opengeni/agent-proto": "^0.5.1-canary.27",
+    "@opengeni/capabilities": "^0.3.3-canary.9",
+    "@opengeni/codemode": "^0.5.6-canary.1",
+    "@opengeni/codex": "^0.2.22-canary.9",
+    "@opengeni/config": "^1.1.2-canary.1",
+    "@opengeni/contracts": "^3.0.2-canary.1",
+    "@opengeni/core": "^2.9.4-canary.1",
+    "@opengeni/db": "^4.3.3-canary.1",
+    "@opengeni/documents": "^0.8.27-canary.1",
+    "@opengeni/events": "^0.4.25-canary.1",
+    "@opengeni/github": "^0.7.10-canary.1",
+    "@opengeni/network": "^0.3.1-canary.9",
+    "@opengeni/observability": "^0.8.26-canary.1",
+    "@opengeni/runtime": "^2.5.3-canary.1",
+    "@opengeni/storage": "^0.2.127-canary.1",
+    "@opengeni/tool-gateway": "^0.1.7-canary.1",
+    "@opengeni/xai-subscription": "^0.1.4-canary.9",
     "@temporalio/activity": "^1.17.0",
     "@temporalio/client": "^1.17.0",
     "@temporalio/worker": "^1.17.0",

package/src/activities/agent-turn/claim.ts

@@ -347,7 +347,7 @@ export async function claimTurnAttempt(deps: ClaimTurnDeps): Promise<ClaimTurnOu
     });
     return attached.action === "claimed" && attached.turn.id === turn.id;
   };
-  turnLifecycleMetricsFor(observability).start(attempt.turnId);
+  turnLifecycleMetricsFor(observability).start({ attemptId: input.attemptId });
   // §7.5 P3 — pass the accepted billing attribution (externally funded turns
   // bypass OpenGeni credit/token gates)
   // AND the optional host `entitlements` port (when bound, its admitRun replaces
@@ -451,7 +451,7 @@ export async function claimTurnAttempt(deps: ClaimTurnDeps): Promise<ClaimTurnOu
     }
     recordCanonicalStartupMilestones(appended.canonicalStartupMilestones);
     if (inputs.length > 0) {
-      turnLifecycleMetricsFor(observability).progress(attempt.turnId!);
+      turnLifecycleMetricsFor(observability).progress({ attemptId: input.attemptId });
     }
     activityContext?.heartbeat({
       ...heartbeatDetails,
@@ -515,7 +515,7 @@ export async function claimTurnAttempt(deps: ClaimTurnDeps): Promise<ClaimTurnOu
       return false;
     }
     recordCanonicalStartupMilestones(result.canonicalStartupMilestones);
-    turnLifecycleMetricsFor(observability).progress(attempt.turnId!);
+    turnLifecycleMetricsFor(observability).progress({ attemptId: input.attemptId });
     await publishDurableSessionEvents(bus, input.workspaceId, input.sessionId, result.events);
     if (inputSettlement.turnStatus === "requires_action") {
       // The settlement transaction committed the parent's child_requires_action

package/src/activities/agent-turn/codex-capacity.ts

@@ -5,7 +5,7 @@ import {
   CodexCredentialLeaseAttemptFencedError,
   CodexCredentialFailoverExhaustedError,
   CODEX_CREDENTIAL_LEASE_TTL_MS,
-  recordSessionActiveCodexCredential,
+  recordSessionCodexSelectionForTurnAttempt,
   setSessionCodexPinInTransaction,
   settleCodexCredentialFailover,
   withSessionCodexCapacityMutation,
@@ -288,19 +288,40 @@ export async function selectCodexTurnCapacity(
         leases.codex.confirmedUntilMs !== null;
       if (leases.codex.held) leases.codex.startHeartbeat();
 
+      const eligibleCount = leased.accounts.filter((account) =>
+        isCodexCredentialEligible(account, new Date()),
+      ).length;
+      const selectionReceipt = providerTurn.effectiveCodexCredentialId
+        ? await recordSessionCodexSelectionForTurnAttempt(db, {
+            workspaceId: input.workspaceId,
+            sessionId: input.sessionId,
+            turnId,
+            attemptId: input.attemptId,
+            executionGeneration: attempt.executionGeneration,
+            credentialId: providerTurn.effectiveCodexCredentialId,
+            strategy: leased.rotationStrategy,
+            reusedLease: leased.reused,
+            pinnedCredentialId: sessionPin,
+            pinSource: sessionPinSource,
+            eligibleCount,
+            connectedCount: leased.accounts.length,
+          })
+        : null;
+      if (selectionReceipt)
+        await publishDurableSessionEvents(
+          bus,
+          input.workspaceId,
+          input.sessionId,
+          selectionReceipt.events,
+        );
+      const selectionDiagnostics = selectionReceipt?.diagnostics ?? null;
       const actualOutcome = providerTurn.effectiveCodexCredentialId
         ? "selected"
         : rotationDecision.kind === "allCapped" || rotationDecision.kind === "allocatorDisabled"
           ? "waiting"
           : "none";
-      const actualReason = providerTurn.effectiveCodexCredentialId
-        ? leased.reused
-          ? "lease_reused"
-          : sessionPin === providerTurn.effectiveCodexCredentialId
-            ? "pin"
-            : rotationDecision.kind === "active" && rotationDecision.moved
-              ? "rotation"
-              : "active"
+      const actualReason = selectionDiagnostics
+        ? selectionDiagnostics.reason
         : rotationDecision.kind === "allCapped"
           ? "all_capped"
           : rotationDecision.kind === "allocatorDisabled"
@@ -362,9 +383,6 @@ export async function selectCodexTurnCapacity(
         });
       }
 
-      const eligibleCount = leased.accounts.filter((account) =>
-        isCodexCredentialEligible(account, new Date()),
-      ).length;
       const poolDepth = eligibleCount === 0 ? "zero" : eligibleCount === 1 ? "one" : "many";
       observability.incrementCounter({
         name: "opengeni_codex_pool_observations_total",
@@ -690,34 +708,7 @@ export async function selectCodexTurnCapacity(
         return { exit: claimedResult({ status: "cancelled" }) };
       }
       if (providerTurn.effectiveCodexCredentialId) {
-        const priorAccountId = lockedSessionCodexState.lastCredentialId;
-        if (priorAccountId !== providerTurn.effectiveCodexCredentialId) {
-          await recordSessionActiveCodexCredential(
-            db,
-            input.workspaceId,
-            input.sessionId,
-            providerTurn.effectiveCodexCredentialId,
-          );
-          const rotated = rotationDecision.kind === "active" && rotationDecision.moved;
-          await eventing.publish([
-            {
-              type: "codex.account.switched",
-              payload: {
-                fromAccountId: priorAccountId,
-                toAccountId: providerTurn.effectiveCodexCredentialId,
-                reason: rotated ? "rotation" : "manual",
-              },
-            },
-          ]);
-        }
-
-        const selectionReason = leased.reused
-          ? "lease_reused"
-          : sessionPin === providerTurn.effectiveCodexCredentialId
-            ? "pin"
-            : rotationDecision.kind === "active" && rotationDecision.moved
-              ? "rotation"
-              : "active";
+        const selectionReason = selectionDiagnostics!.reason;
         observability.incrementCounter({
           name: "opengeni_codex_credential_selections_total",
           help: "Codex credential selections by strategy and reason.",
@@ -727,19 +718,6 @@ export async function selectCodexTurnCapacity(
             reason: selectionReason,
           },
         });
-        await eventing.publish([
-          {
-            type: "codex.credential.selected",
-            payload: {
-              credentialId: providerTurn.effectiveCodexCredentialId,
-              strategy: leased.rotationStrategy,
-              reason: selectionReason,
-              eligibleCount,
-              connectedCount: leased.accounts.length,
-              reused: leased.reused,
-            },
-          },
-        ]);
       }
     } catch (error) {
       credentialSelectionOutcome = "failed";

package/src/activities/agent-turn/codex-selection-diagnostics.ts

@@ -0,0 +1 @@
+export { codexSelectionDiagnostics } from "@opengeni/db";

package/src/activities/agent-turn/finalization.ts

@@ -745,12 +745,17 @@ export async function finalizeTurnAttempt(deps: TurnFinalizationDeps): Promise<v
       status: finalizationError ? "cleanup_failed" : control.activityStatus,
       durationSeconds,
     });
-    if (attempt.turnId && control.activityStatus !== "unknown") {
-      turnLifecycleMetricsFor(observability).finish(
-        attempt.turnId,
-        control.turnMetricOutcome,
+    if (attempt.turnId) {
+      // This registry describes physical activity ownership, not durable turn
+      // settlement. Always clear the exact attempt when its activity unwinds,
+      // even when failure settlement could not classify an outcome. Otherwise
+      // a recovered successor can make progress while the predecessor leaves a
+      // process-local false stuck-turn alert behind.
+      turnLifecycleMetricsFor(observability).finish({
+        attemptId: input.attemptId,
+        outcome: control.turnMetricOutcome,
         durationSeconds,
-      );
+      });
     }
     activitySpan.end({
       attributes: {

package/src/activities/agent-turn/mcp-operation-read-tool.ts

@@ -0,0 +1,61 @@
+import type { AttemptToolDefinition } from "@opengeni/codemode";
+import { AttemptToolResult } from "@opengeni/contracts";
+import { z } from "zod";
+
+const selectorSchema = z.union([
+  z.object({ operationId: z.string().uuid() }).strict(),
+  z.object({ sourceTurnId: z.string().uuid(), sourceCallId: z.string().min(1) }).strict(),
+]);
+
+export type McpOperationReadSelector = z.infer<typeof selectorSchema>;
+
+/** Attempt-local adapter. The supplied read closure owns canonical session
+ * access, current provider authority, immutable binding checks and settlement.
+ * No caller-controlled provider parameters cross this tool boundary. */
+export function createOperationReadAttemptToolDefinition(input: {
+  read: (selector: McpOperationReadSelector) => Promise<Record<string, unknown>>;
+}): AttemptToolDefinition {
+  return {
+    identity: { serverId: "opengeni", toolName: "operation_read" },
+    modelName: "operation_read",
+    codemodePath: ["opengeni", "operation_read"],
+    title: "Read an existing MCP operation outcome",
+    description:
+      "Read a retained MCP operation and, when supported and currently authorized, observe its provider receipt. " +
+      "Use the operationId from the original call, or its exact sourceTurnId and sourceCallId if that response was lost. " +
+      "This never repeats the original mutation. Unknown means the outcome is not proven, not that the operation failed. " +
+      "Provider support and renewed authorization may be required after reconnecting.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        operationId: { type: "string", format: "uuid" },
+        sourceTurnId: { type: "string", format: "uuid" },
+        sourceCallId: { type: "string", minLength: 1 },
+      },
+      additionalProperties: false,
+      oneOf: [
+        {
+          required: ["operationId"],
+          not: { anyOf: [{ required: ["sourceTurnId"] }, { required: ["sourceCallId"] }] },
+        },
+        { required: ["sourceTurnId", "sourceCallId"], not: { required: ["operationId"] } },
+      ],
+    },
+    annotations: {
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true,
+    },
+    source: "opengeni",
+    approval: "none",
+    execute: async (args) => {
+      const selector = selectorSchema.parse(args);
+      const receipt = await input.read(selector);
+      return AttemptToolResult.parse({
+        content: [{ type: "text", text: JSON.stringify(receipt) }],
+        structuredContent: receipt,
+      });
+    },
+  };
+}

package/src/activities/agent-turn/sandbox-establish.ts

@@ -475,6 +475,8 @@ export async function establishTurnSandbox(deps: EstablishTurnSandboxDeps): Prom
               liveMachineEnrollment?.agentCapabilities.operationResourcePolicy === true,
             operationCpuQuotaSupported:
               liveMachineEnrollment?.agentCapabilities.operationCpuQuota === true,
+            transactionalFsWriteSupported:
+              liveMachineEnrollment?.agentCapabilities.transactionalFsWrite === true,
             ...(activeSandboxRecord!.scope === "user" && fileAuthoritySubjectId
               ? {
                   personalMachineAttempt: {

package/src/activities/agent-turn/skill-search.ts

@@ -1,6 +1,5 @@
 import type { AttemptToolDefinition } from "@opengeni/codemode";
 import { PublicSkillSearchError, type PublicSkillSearchClient } from "@opengeni/core";
-import { listSkillLibraryEntries } from "@opengeni/runtime/skill-library";
 
 export type WorkspaceSkillSearchEntry = Readonly<{
   id: string;
@@ -23,7 +22,7 @@ export function createSkillSearchAttemptToolDefinition(input: {
     codemodePath: ["opengeni", "skill_search"],
     title: "Search Skills",
     description:
-      "Find installed workspace Skills or available curated and public Skills. Returns identifiers and install sources, not file contents. Search never installs or starts a sandbox. Scope defaults to all; use installed to avoid external search.",
+      "Find installed workspace Skills or available public Skills. Returns identifiers and install sources, not file contents. Search never installs or starts a sandbox. Scope defaults to all; use installed to avoid external search.",
     inputSchema: {
       type: "object",
       properties: {
@@ -60,19 +59,6 @@ export function createSkillSearchAttemptToolDefinition(input: {
           source: entry.source ?? "workspace",
           installed: !entry.source || entry.source === "workspace",
         }));
-      const libraryHits =
-        scope === "installed"
-          ? []
-          : listSkillLibraryEntries()
-              .filter(matches)
-              .slice(0, limit)
-              .map((entry) => ({
-                id: `library:${entry.id}`,
-                name: entry.name,
-                description: entry.description,
-                source: "library" as const,
-                libraryId: entry.id,
-              }));
       let publicResult: Awaited<ReturnType<PublicSkillSearchClient["search"]>> | null = null;
       let publicError: {
         source: "skills_sh";
@@ -93,7 +79,7 @@ export function createSkillSearchAttemptToolDefinition(input: {
       }
       const output = {
         workspace: workspaceHits,
-        library: libraryHits,
+        library: [], // Retained response field for older clients.
         public: publicResult?.items.map((entry) => ({ ...entry })) ?? [],
         // A provider outage is not an empty search. Keep local results useful
         // and expose partial failure explicitly, without leaking network details.

package/src/activities/agent-turn/stream-attempt.ts

@@ -1062,7 +1062,7 @@ export async function runTurnStreamAttempt(
           currentToolBatchCallIds = new Set<string>();
           currentToolBatchCompletedCallIds = new Set<string>();
           await historySink.reconcileConversationTruth();
-          turnLifecycleMetricsFor(observability).progress(attempt.turnId!);
+          turnLifecycleMetricsFor(observability).progress({ attemptId: input.attemptId });
           modelCheckpointMemoryCollector.schedule(observability);
           try {
             await ensureRunAllowed(

package/src/activities/agent-turn/tool-environment.ts

@@ -37,6 +37,11 @@ import {
   resolveGoogleDrivePublicationTarget,
 } from "../google-drive-publication";
 import { connectionTokenResolverForTurn } from "../mcp-credentials";
+import { createMcpOperationPersistence } from "@opengeni/db/mcp-operations";
+import { createMcpOperationReadStore } from "../mcp-operation-store";
+import { createMcpOperationObserverResolver } from "../mcp-operation-observer";
+import { readMcpOperation } from "../mcp-operation-reader";
+import { createOperationReadAttemptToolDefinition } from "./mcp-operation-read-tool";
 import { buildGitHubRestMcpForTurn } from "../../github-rest-mcp";
 import { materializeConnectorAttachmentsInChannel } from "../connector-attachments";
 import { allowedFirstPartyMcpToolsForSession, type Settings } from "@opengeni/config";
@@ -668,7 +673,66 @@ export async function prepareTurnToolRuntime(deps: PrepareTurnToolRuntimeDeps) {
       });
     },
   });
+  const operationRecoveryEnabled = githubRestMcp.settings.mcpServers.some(
+    (server) =>
+      server.operationRecovery &&
+      Object.keys(server.operationRecovery).length > 0 &&
+      githubRestMcp.tools.some((tool) => tool.kind === "mcp" && tool.id === server.id),
+  );
+  const operationAttempt = {
+    accountId: input.accountId,
+    workspaceId: input.workspaceId,
+    sessionId: input.sessionId,
+    turnId: turn.id,
+    attemptId: input.attemptId,
+    executionGeneration: attempt.executionGeneration,
+  };
+  const operationPersistence = operationRecoveryEnabled
+    ? createMcpOperationPersistence(db, operationAttempt)
+    : undefined;
+  const operationReadStore = operationRecoveryEnabled
+    ? createMcpOperationReadStore(db, operationAttempt)
+    : undefined;
+  const operationObserver = createMcpOperationObserverResolver({
+    settings: githubRestMcp.settings,
+    workspaceId: input.workspaceId,
+    ...(credentialSubjectId ? { credentialSubjectId } : {}),
+    resolveCredential,
+    assertAttempt: async () => {
+      throwIfWorkerShuttingDown();
+      throwIfTurnCancelled();
+      const current = await getSessionTurnForAttempt(
+        db,
+        input.workspaceId,
+        input.sessionId,
+        input.attemptId,
+      );
+      if (
+        !current ||
+        current.id !== turn.id ||
+        current.executionGeneration !== attempt.executionGeneration
+      ) {
+        throw new Error("MCP operation reader no longer owns the executing attempt");
+      }
+    },
+    getEnvironment: async () => {
+      const prepared = eventing.preparedTools;
+      if (!prepared) return null;
+      return ((await prepared.ready) ?? prepared).attemptToolEnvironment;
+    },
+  });
   const attemptToolDefinitions = [
+    ...(operationReadStore
+      ? [
+          createOperationReadAttemptToolDefinition({
+            read: async (selector) =>
+              await readMcpOperation(selector, {
+                ...operationReadStore,
+                resolveObserver: operationObserver,
+              }),
+          }),
+        ]
+      : []),
     ...skillTools,
     createListModelsAttemptToolDefinition({
       currentModelId: turnExecutionPolicy.productModelId,
@@ -876,6 +940,7 @@ export async function prepareTurnToolRuntime(deps: PrepareTurnToolRuntimeDeps) {
         ...(credentialSubjectId ? { credentialSubjectId } : {}),
         ...(codexAppsAuth ? { codexAppsAuth } : {}),
         resolveCredential,
+        ...(operationPersistence ? { mcpOperationPersistence: operationPersistence } : {}),
         ...(linkedAuthority
           ? {
               authorizeAttemptExecution: async () => {

package/src/activities/codex-fleet-shadow.ts

@@ -18,6 +18,9 @@ export type CodexFleetActualDecisionV1 = {
   candidateKey: string | null;
   reason:
     | "lease_reused"
+    | "affinity_reused"
+    | "assigned"
+    | "switched"
     | "pin"
     | "rotation"
     | "active"