chainlesschain 0.166.68 → 0.166.70

package/src/lib/evolution/volcengine-function-revocation-status-floor-store.js

@@ -0,0 +1,480 @@
+import { createHash } from "node:crypto";
+import path from "node:path";
+import { types } from "node:util";
+
+import { createEvolutionLedgerFileManifestHeadBackend } from "./evolution-ledger-file-manifest-head-store.js";
+
+export const VOLCENGINE_FUNCTION_REVOCATION_STATUS_FLOOR_STORE_SCHEMA =
+  "chainlesschain.volcengine-function-revocation-status-floor-store/v1";
+export const VOLCENGINE_FUNCTION_REVOCATION_STATUS_FLOOR_MODE =
+  "cross-process-exclusive-file-fsync";
+export const VOLCENGINE_FUNCTION_REVOCATION_STATUS_SNAPSHOT_SCHEMA =
+  "chainlesschain.volcengine-function-revocation-status-snapshot/v1";
+export const VOLCENGINE_FUNCTION_REVOCATION_STATUS_ACK_SCHEMA =
+  "chainlesschain.volcengine-function-revocation-status-ack/v1";
+
+const STATE_SCHEMA =
+  "chainlesschain.volcengine-function-revocation-status-floor-state/v1";
+const DIGEST = /^sha256:[a-f0-9]{64}$/u;
+const ID = /^[^\p{Cc}]{1,512}$/u;
+const stores = new WeakMap();
+
+function canonical(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
+  return `{${Object.keys(value)
+    .sort()
+    .map((key) => `${JSON.stringify(key)}:${canonical(value[key])}`)
+    .join(",")}}`;
+}
+
+function digest(domain, value) {
+  return `sha256:${createHash("sha256")
+    .update(`${domain}\0`)
+    .update(canonical(value))
+    .digest("hex")}`;
+}
+
+function exactData(value, keys, label) {
+  if (
+    !value ||
+    typeof value !== "object" ||
+    Array.isArray(value) ||
+    types.isProxy(value) ||
+    ![Object.prototype, null].includes(Object.getPrototypeOf(value)) ||
+    Reflect.ownKeys(value).length !== keys.length ||
+    keys.some((key) => {
+      const descriptor = Object.getOwnPropertyDescriptor(value, key);
+      return !descriptor?.enumerable || !Object.hasOwn(descriptor, "value");
+    })
+  ) {
+    throw new TypeError(`${label} has unexpected or accessor fields`);
+  }
+}
+
+function ownData(owner, name, label) {
+  const descriptor = Object.getOwnPropertyDescriptor(owner, name);
+  if (!descriptor || !Object.hasOwn(descriptor, "value")) {
+    throw new TypeError(`${label} must be plain data`);
+  }
+  return descriptor.value;
+}
+
+function normalizeDirectory(value) {
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new TypeError(
+      "Volcengine function revocation status floor directory is invalid",
+    );
+  }
+  return path.resolve(value);
+}
+
+export function digestVolcengineFunctionRevocationStatusFloorRoot(value) {
+  return digest(
+    "chainlesschain.volcengine-function-revocation-status-floor-root/v1",
+    normalizeDirectory(value),
+  );
+}
+
+function normalizeDescriptor(value) {
+  exactData(
+    value,
+    [
+      "schema",
+      "storeId",
+      "tenantId",
+      "handlerArtifactDigest",
+      "revocationAuthorityId",
+      "trustRootDigest",
+      "stateRootDigest",
+      "mode",
+    ],
+    "Volcengine function revocation status floor store descriptor",
+  );
+  const descriptor = Object.freeze({
+    schema: ownData(
+      value,
+      "schema",
+      "Volcengine function revocation status floor store schema",
+    ),
+    storeId: ownData(
+      value,
+      "storeId",
+      "Volcengine function revocation status floor store identifier",
+    ),
+    tenantId: ownData(
+      value,
+      "tenantId",
+      "Volcengine function revocation status floor store tenant",
+    ),
+    handlerArtifactDigest: ownData(
+      value,
+      "handlerArtifactDigest",
+      "Volcengine function revocation status floor store artifact digest",
+    ),
+    revocationAuthorityId: ownData(
+      value,
+      "revocationAuthorityId",
+      "Volcengine function revocation status floor store authority",
+    ),
+    trustRootDigest: ownData(
+      value,
+      "trustRootDigest",
+      "Volcengine function revocation status floor store trust root",
+    ),
+    stateRootDigest: ownData(
+      value,
+      "stateRootDigest",
+      "Volcengine function revocation status floor state root",
+    ),
+    mode: ownData(
+      value,
+      "mode",
+      "Volcengine function revocation status floor store mode",
+    ),
+  });
+  if (
+    descriptor.schema !==
+      VOLCENGINE_FUNCTION_REVOCATION_STATUS_FLOOR_STORE_SCHEMA ||
+    !ID.test(descriptor.storeId) ||
+    !ID.test(descriptor.tenantId) ||
+    !DIGEST.test(descriptor.handlerArtifactDigest) ||
+    !ID.test(descriptor.revocationAuthorityId) ||
+    !DIGEST.test(descriptor.trustRootDigest) ||
+    !DIGEST.test(descriptor.stateRootDigest) ||
+    descriptor.mode !== VOLCENGINE_FUNCTION_REVOCATION_STATUS_FLOOR_MODE
+  ) {
+    throw new TypeError(
+      "Volcengine function revocation status floor store descriptor is invalid",
+    );
+  }
+  return descriptor;
+}
+
+export function digestVolcengineFunctionRevocationStatusFloorStoreDescriptor(
+  value,
+) {
+  return digest(
+    VOLCENGINE_FUNCTION_REVOCATION_STATUS_FLOOR_STORE_SCHEMA,
+    normalizeDescriptor(value),
+  );
+}
+
+function normalizeSnapshot(value, descriptor) {
+  exactData(
+    value,
+    [
+      "schema",
+      "storeId",
+      "tenantId",
+      "handlerArtifactDigest",
+      "revocationAuthorityId",
+      "trustRootDigest",
+      "revision",
+      "snapshotDigest",
+      "issuedAt",
+      "nextUpdate",
+    ],
+    "Volcengine function revocation status snapshot",
+  );
+  const snapshot = Object.freeze({
+    schema: ownData(
+      value,
+      "schema",
+      "Volcengine function revocation status snapshot schema",
+    ),
+    storeId: ownData(
+      value,
+      "storeId",
+      "Volcengine function revocation status snapshot store",
+    ),
+    tenantId: ownData(
+      value,
+      "tenantId",
+      "Volcengine function revocation status snapshot tenant",
+    ),
+    handlerArtifactDigest: ownData(
+      value,
+      "handlerArtifactDigest",
+      "Volcengine function revocation status snapshot artifact digest",
+    ),
+    revocationAuthorityId: ownData(
+      value,
+      "revocationAuthorityId",
+      "Volcengine function revocation status snapshot authority",
+    ),
+    trustRootDigest: ownData(
+      value,
+      "trustRootDigest",
+      "Volcengine function revocation status snapshot trust root",
+    ),
+    revision: ownData(
+      value,
+      "revision",
+      "Volcengine function revocation status snapshot revision",
+    ),
+    snapshotDigest: ownData(
+      value,
+      "snapshotDigest",
+      "Volcengine function revocation status snapshot digest",
+    ),
+    issuedAt: ownData(
+      value,
+      "issuedAt",
+      "Volcengine function revocation status snapshot issue time",
+    ),
+    nextUpdate: ownData(
+      value,
+      "nextUpdate",
+      "Volcengine function revocation status snapshot next update",
+    ),
+  });
+  const issuedAtMs = Date.parse(snapshot.issuedAt);
+  const nextUpdateMs = Date.parse(snapshot.nextUpdate);
+  if (
+    snapshot.schema !== VOLCENGINE_FUNCTION_REVOCATION_STATUS_SNAPSHOT_SCHEMA ||
+    snapshot.storeId !== descriptor.storeId ||
+    snapshot.tenantId !== descriptor.tenantId ||
+    snapshot.handlerArtifactDigest !== descriptor.handlerArtifactDigest ||
+    snapshot.revocationAuthorityId !== descriptor.revocationAuthorityId ||
+    snapshot.trustRootDigest !== descriptor.trustRootDigest ||
+    !Number.isSafeInteger(snapshot.revision) ||
+    snapshot.revision < 1 ||
+    !DIGEST.test(snapshot.snapshotDigest) ||
+    !Number.isFinite(issuedAtMs) ||
+    new Date(issuedAtMs).toISOString() !== snapshot.issuedAt ||
+    !Number.isFinite(nextUpdateMs) ||
+    new Date(nextUpdateMs).toISOString() !== snapshot.nextUpdate ||
+    nextUpdateMs <= issuedAtMs
+  ) {
+    throw new TypeError(
+      "Volcengine function revocation status snapshot is invalid",
+    );
+  }
+  return snapshot;
+}
+
+function normalizeState(value, descriptorDigest) {
+  if (value === null) return null;
+  exactData(
+    value,
+    [
+      "schema",
+      "descriptorDigest",
+      "revision",
+      "snapshotDigest",
+      "issuedAt",
+      "nextUpdate",
+      "headDigest",
+    ],
+    "Volcengine function revocation status floor state",
+  );
+  const core = Object.freeze({
+    schema: ownData(
+      value,
+      "schema",
+      "Volcengine function revocation status floor state schema",
+    ),
+    descriptorDigest: ownData(
+      value,
+      "descriptorDigest",
+      "Volcengine function revocation status floor descriptor digest",
+    ),
+    revision: ownData(
+      value,
+      "revision",
+      "Volcengine function revocation status floor revision",
+    ),
+    snapshotDigest: ownData(
+      value,
+      "snapshotDigest",
+      "Volcengine function revocation status floor snapshot digest",
+    ),
+    issuedAt: ownData(
+      value,
+      "issuedAt",
+      "Volcengine function revocation status floor issue time",
+    ),
+    nextUpdate: ownData(
+      value,
+      "nextUpdate",
+      "Volcengine function revocation status floor next update",
+    ),
+  });
+  const headDigest = ownData(
+    value,
+    "headDigest",
+    "Volcengine function revocation status floor head digest",
+  );
+  const issuedAtMs = Date.parse(core.issuedAt);
+  const nextUpdateMs = Date.parse(core.nextUpdate);
+  if (
+    core.schema !== STATE_SCHEMA ||
+    core.descriptorDigest !== descriptorDigest ||
+    !Number.isSafeInteger(core.revision) ||
+    core.revision < 1 ||
+    !DIGEST.test(core.snapshotDigest) ||
+    !Number.isFinite(issuedAtMs) ||
+    new Date(issuedAtMs).toISOString() !== core.issuedAt ||
+    !Number.isFinite(nextUpdateMs) ||
+    new Date(nextUpdateMs).toISOString() !== core.nextUpdate ||
+    nextUpdateMs <= issuedAtMs ||
+    headDigest !== digest(STATE_SCHEMA, core)
+  ) {
+    throw new Error(
+      "Volcengine function revocation status floor state is invalid",
+    );
+  }
+  return Object.freeze({ ...core, headDigest });
+}
+
+function rollbackError(received, floor) {
+  const error = new Error(
+    `Volcengine function revocation signer status rollback rejected: received ${received}, floor ${floor}`,
+  );
+  error.code = "CC_VOLCENGINE_FUNCTION_REVOCATION_STATUS_ROLLBACK";
+  return error;
+}
+
+export function createVolcengineFunctionRevocationStatusFloorStore(options) {
+  exactData(
+    options,
+    ["descriptor", "directoryPath"],
+    "Volcengine function revocation status floor store",
+  );
+  const descriptor = normalizeDescriptor(
+    ownData(
+      options,
+      "descriptor",
+      "Volcengine function revocation status floor store descriptor",
+    ),
+  );
+  const directoryPath = normalizeDirectory(
+    ownData(
+      options,
+      "directoryPath",
+      "Volcengine function revocation status floor directory",
+    ),
+  );
+  if (
+    descriptor.stateRootDigest !==
+    digestVolcengineFunctionRevocationStatusFloorRoot(directoryPath)
+  ) {
+    throw new TypeError(
+      "Volcengine function revocation status floor state root does not match descriptor",
+    );
+  }
+  const descriptorDigest = digest(
+    VOLCENGINE_FUNCTION_REVOCATION_STATUS_FLOOR_STORE_SCHEMA,
+    descriptor,
+  );
+  const backend = createEvolutionLedgerFileManifestHeadBackend({
+    directoryPath,
+  });
+  const store = Object.freeze({});
+  stores.set(store, { backend, descriptor, descriptorDigest });
+  return store;
+}
+
+export function inspectVolcengineFunctionRevocationStatusFloorStore(value) {
+  const captured = stores.get(value);
+  if (!captured) {
+    throw new TypeError(
+      "A branded Volcengine function revocation status floor store is required",
+    );
+  }
+  return Object.freeze({
+    descriptor: captured.descriptor,
+    descriptorDigest: captured.descriptorDigest,
+  });
+}
+
+export function captureVolcengineFunctionRevocationStatusFloorStore(value) {
+  const captured = stores.get(value);
+  if (!captured) {
+    throw new TypeError(
+      "A branded Volcengine function revocation status floor store is required",
+    );
+  }
+  const read = () =>
+    normalizeState(captured.backend.load(), captured.descriptorDigest);
+  return Object.freeze({
+    descriptor: captured.descriptor,
+    descriptorDigest: captured.descriptorDigest,
+    readFloor: read,
+    acceptSnapshot(input) {
+      const snapshot = normalizeSnapshot(input, captured.descriptor);
+      for (let attempt = 0; attempt < 16; attempt += 1) {
+        const current = read();
+        if (current && snapshot.revision < current.revision) {
+          throw rollbackError(snapshot.revision, current.revision);
+        }
+        if (current && snapshot.revision === current.revision) {
+          if (snapshot.snapshotDigest !== current.snapshotDigest) {
+            throw new Error(
+              "Volcengine function revocation signer status conflicts at the current revision",
+            );
+          }
+          return Object.freeze({
+            schema: VOLCENGINE_FUNCTION_REVOCATION_STATUS_ACK_SCHEMA,
+            storeId: captured.descriptor.storeId,
+            revision: current.revision,
+            snapshotDigest: current.snapshotDigest,
+            headDigest: current.headDigest,
+            durable: true,
+            readbackVerified: true,
+          });
+        }
+        if (
+          current &&
+          Date.parse(snapshot.issuedAt) <= Date.parse(current.issuedAt)
+        ) {
+          throw new Error(
+            "Volcengine function revocation signer status issue time did not advance",
+          );
+        }
+        const core = Object.freeze({
+          schema: STATE_SCHEMA,
+          descriptorDigest: captured.descriptorDigest,
+          revision: snapshot.revision,
+          snapshotDigest: snapshot.snapshotDigest,
+          issuedAt: snapshot.issuedAt,
+          nextUpdate: snapshot.nextUpdate,
+        });
+        const next = Object.freeze({
+          ...core,
+          headDigest: digest(STATE_SCHEMA, core),
+        });
+        const result = captured.backend.compareAndSet({
+          expectedHeadDigest: current?.headDigest ?? null,
+          nextHead: next,
+        });
+        if (!result.committed) continue;
+        const confirmed = normalizeState(
+          result.head,
+          captured.descriptorDigest,
+        );
+        if (
+          confirmed.revision !== snapshot.revision ||
+          confirmed.snapshotDigest !== snapshot.snapshotDigest
+        ) {
+          throw new Error(
+            "Volcengine function revocation status floor durable readback differs",
+          );
+        }
+        return Object.freeze({
+          schema: VOLCENGINE_FUNCTION_REVOCATION_STATUS_ACK_SCHEMA,
+          storeId: captured.descriptor.storeId,
+          revision: confirmed.revision,
+          snapshotDigest: confirmed.snapshotDigest,
+          headDigest: confirmed.headDigest,
+          durable: true,
+          readbackVerified: true,
+        });
+      }
+      throw new Error(
+        "Volcengine function revocation status floor contention did not settle",
+      );
+    },
+  });
+}

package/src/runtime/agent-core.js

@@ -86,6 +86,7 @@ import {
 import { getPlanModeManager } from "../lib/plan-mode.js";
 import { CLISkillLoader } from "../lib/skill-loader.js";
 import { routeSkillDescriptors } from "../lib/skill-retrieval-router.js";
+import { captureSkillDecisionRuntime } from "../lib/decision-layer/runtime.js";
 import { resolveSkillOutcomeAuthority } from "../lib/skill-outcome-authority.js";
 import {
   captureSkillVectorAuthority,
@@ -3629,6 +3630,7 @@ export async function executeTool(name, args, context = {}) {
       skillAllowlist: context.skillAllowlist ?? null,
       skillOutcomeIndex: context.skillOutcomeIndex,
       skillVectorAuthority: context.skillVectorAuthority,
+      skillDecisionRuntime: context.skillDecisionRuntime,
       skillRuntimeAdmission: context.skillRuntimeAdmission,
       skillRuntimeAdmissionRequired: context.skillRuntimeAdmissionRequired,
       skillRetrievalRevocationReader: context.skillRetrievalRevocationReader,
@@ -5184,6 +5186,7 @@ async function executeToolInner(
     skillAllowlist = null,
     skillOutcomeIndex,
     skillVectorAuthority,
+    skillDecisionRuntime,
     skillRuntimeAdmission,
     skillRuntimeAdmissionRequired = false,
     skillRetrievalRevocationReader,
@@ -8622,6 +8625,45 @@ async function executeToolInner(
         skills = routing.candidates
           .map(({ digest }) => byDigest.get(digest))
           .filter(Boolean);
+        const decisionRuntime =
+          skillDecisionRuntime == null
+            ? null
+            : captureSkillDecisionRuntime(skillDecisionRuntime);
+        if (decisionRuntime !== null && routing.candidates.length > 0) {
+          const decision = await decisionRuntime.suggest({
+            query: args.query,
+            candidates: routing.candidates.slice(0, 5).map((candidate) => {
+              const descriptor = byDigest.get(candidate.digest);
+              return {
+                id: candidate.id,
+                displayName: candidate.displayName,
+                description: descriptor?.description || candidate.displayName,
+                category: candidate.category,
+                digest: candidate.digest,
+                tags: Array.isArray(descriptor?.tags) ? descriptor.tags : [],
+              };
+            }),
+            turnId: turnId || toolCallId || "list-skills",
+            contextRevision: "skill-routing-v1",
+            signal,
+          });
+          if (decision.visible) {
+            routing = Object.freeze({
+              ...routing,
+              decisionSuggestion: Object.freeze({
+                schema: decision.schema,
+                decisionId: decision.decisionId,
+                status: decision.status,
+                reasonCode: decision.reasonCode,
+                selectedDigest: decision.selectedDigest,
+                selectedSkillId: decision.selectedSkillId,
+                needsSkillProbability: decision.needsSkillProbability,
+                choiceConfidence: decision.choiceConfidence,
+                receiptRef: decision.receiptRef,
+              }),
+            });
+          }
+        }
       }
       skillLoader.recordDescriptorUse?.(skills, {
         sessionId,
@@ -8641,6 +8683,9 @@ async function executeToolInner(
                 vectorAuthority:
                   vector?.evidence ?? unavailableSkillVectorEvidence(),
                 outcomeAuthority: outcomeAuthority.evidence,
+                ...(routing.decisionSuggestion
+                  ? { decisionSuggestion: routing.decisionSuggestion }
+                  : {}),
               },
             }
           : {}),
@@ -14029,6 +14074,10 @@ export async function* agentLoop(messages, options) {
         : _defaultSkillLoader),
     skillOutcomeIndex: options.skillOutcomeIndex,
     skillVectorAuthority: options.skillVectorAuthority,
+    skillDecisionRuntime:
+      options.skillDecisionRuntime == null
+        ? null
+        : captureSkillDecisionRuntime(options.skillDecisionRuntime),
     skillRuntimeAdmission: options.skillRuntimeAdmission,
     skillRuntimeAdmissionRequired: options.skillRuntimeAdmissionRequired,
     skillRetrievalRevocationReader: options.skillRetrievalRevocationReader,

package/src/runtime/headless-runner.js

@@ -217,6 +217,9 @@ import {
 } from "../lib/runtime-usage-ledger.js";
 import { runMeteredDirectModelCall } from "../lib/direct-model-usage.js";
 import { resolveTeamMessageToolBundle } from "../lib/agent-team/team-message-tools.js";
+import { normalizeDecisionMode } from "../lib/decision-layer/contracts.js";
+import { createSkillDecisionRuntime } from "../lib/decision-layer/runtime.js";
+import { createTypeSafeDecisionProvider } from "../lib/decision-layer/typesafe-provider.js";
 
 /**
  * Normalize a public --permission-mode spelling to the canonical internal mode.
@@ -248,6 +251,38 @@ export function validateHeadlessInvocationOptions(options = {}) {
     );
   }
   normalizePermissionMode(options.permissionMode);
+  resolveHeadlessSkillDecisionOptions(options);
+}
+
+/** Normalize the opt-in Jev Skill-routing experiment without acquiring egress. */
+export function resolveHeadlessSkillDecisionOptions(options = {}) {
+  let mode;
+  try {
+    mode = normalizeDecisionMode(options.decisionMode || "off");
+  } catch {
+    throw new Error(
+      `Invalid --decision-mode "${options.decisionMode}". Expected one of: off, shadow, suggest`,
+    );
+  }
+  const timeoutMs =
+    options.decisionTimeoutMs === undefined
+      ? 800
+      : Number(options.decisionTimeoutMs);
+  if (
+    !Number.isSafeInteger(timeoutMs) ||
+    timeoutMs < 50 ||
+    timeoutMs > 30_000
+  ) {
+    throw new Error(
+      "Invalid --decision-timeout-ms. Expected an integer from 50 to 30000",
+    );
+  }
+  return Object.freeze({
+    mode,
+    model: options.decisionModel || "jev-latest",
+    baseUrl: options.decisionBaseUrl || "https://api.typesafe.ai",
+    timeoutMs,
+  });
 }
 
 /**
@@ -488,6 +523,7 @@ async function withHeadlessSessionHostLease(options, deps, task) {
       `Invalid --output-format "${outputFormat}". Expected one of: ${VALID_OUTPUT_FORMATS.join(", ")}`,
     );
   }
+  const skillDecision = resolveHeadlessSkillDecisionOptions(options);
   let resolution = null;
   let lease = null;
   let budgetRoot = null;
@@ -518,6 +554,21 @@ async function withHeadlessSessionHostLease(options, deps, task) {
         },
         `headless-${Date.now()}-${process.pid}`,
       );
+      if (skillDecision.mode !== "off" && !resolution.persist) {
+        throw new Error(
+          "--decision-mode shadow/suggest requires a durable session; use --session/--resume/--continue and do not use --ephemeral",
+        );
+      }
+      if (
+        skillDecision.mode !== "off" &&
+        !deps.decisionProvider &&
+        !options.decisionApiKey &&
+        !process.env.TYPESAFE_API_KEY
+      ) {
+        throw new Error(
+          "TYPESAFE_API_KEY is required when --decision-mode is shadow or suggest",
+        );
+      }
       const authoritySessionId =
         resolution.resumeId ||
         (resolution.persist ? resolution.sessionId : null);
@@ -2386,6 +2437,33 @@ async function runAgentHeadlessInWorkspace(
     }
   };
 
+  const skillDecisionOptions = resolveHeadlessSkillDecisionOptions(options);
+  let skillDecisionRuntime = null;
+  if (skillDecisionOptions.mode !== "off") {
+    const decisionProvider =
+      deps.decisionProvider ||
+      createTypeSafeDecisionProvider({
+        apiKey: options.decisionApiKey || process.env.TYPESAFE_API_KEY,
+        baseUrl: skillDecisionOptions.baseUrl,
+        model: skillDecisionOptions.model,
+        ...(deps.decisionFetch ? { fetchImpl: deps.decisionFetch } : {}),
+      });
+    const persistDecisionEvent = (type, data) =>
+      persistRuntimeLedgerWrite(() => store.appendEvent(sessionId, type, data));
+    skillDecisionRuntime = createSkillDecisionRuntime({
+      mode: skillDecisionOptions.mode,
+      tenantId:
+        options.decisionTenantId || evolutionIngress?.tenantId || "cli-local",
+      sessionId,
+      provider: decisionProvider,
+      persist: persistDecisionEvent,
+      observe: (observation) =>
+        persistDecisionEvent("skill_decision_observation", observation),
+      sessionBudget: options.sessionBudget || null,
+      timeoutMs: skillDecisionOptions.timeoutMs,
+    });
+  }
+
   // Subagent internals may contain prompts and tool results.  The public
   // stream exposes only stable lifecycle/progress metadata, and only with the
   // explicit --include-hook-events opt-in.
@@ -2513,6 +2591,7 @@ async function runAgentHeadlessInWorkspace(
     apiKey,
     cwd,
     skillLoader: _runtimeSkillLoader,
+    ...(skillDecisionRuntime === null ? {} : { skillDecisionRuntime }),
     ...captureSkillRuntimeDependencies(options, evolutionIngress?.tenantId),
     ...(skillOutcomeIndex === null ? {} : { skillOutcomeIndex }),
     ...(skillVectorAuthority === null ? {} : { skillVectorAuthority }),

package/src/assets/web-panel/assets/ChatBubbleRenderer-Bpf1hDUl.js

@@ -1 +0,0 @@
-import{I as v,P as u,J as S,U as s,R as a,S as y,K as x,Q as C,V as w,_ as B,b as n}from"./vendor-Bn1JzzAn.js";import{_ as k}from"./index-C3XeNS82.js";import"./icons-DG5UD-6K.js";const N={__name:"ChatBubbleRenderer",props:{event:{type:Object,required:!0}},setup(c,{expose:d}){d();const t=c,r=n(()=>{const e=t.event.content||{};return e.text||e.body||e.message||e.title||JSON.stringify(e).slice(0,200)}),i=n(()=>{const e=t.event.content||{};return e.from||e.sender||e.senderName||t.event.actor||"(unknown)"}),l=n(()=>{const e=(t.event.actor||"").toLowerCase();return e.includes("self")||e==="me"||e.endsWith("_self")}),o=n(()=>{const e=t.event.source.adapter||"";return e.startsWith("messaging-qq")?"magenta":e==="wechat"?"green":"blue"}),m=n(()=>{if(!t.event.occurredAt)return"";try{const e=new Date(t.event.occurredAt),p=e.getFullYear(),f=String(e.getMonth()+1).padStart(2,"0"),g=String(e.getDate()).padStart(2,"0"),b=String(e.getHours()).padStart(2,"0"),h=String(e.getMinutes()).padStart(2,"0");return`${p}-${f}-${g} ${b}:${h}`}catch{return""}}),_={props:t,messageText:r,actorLabel:i,isMine:l,adapterColor:o,formattedTime:m,computed:n};return Object.defineProperty(_,"__isScriptSetup",{enumerable:!1,value:!0}),_}},T={class:"bubble"},q={class:"meta"},M={class:"actor"},R={class:"time"},V={class:"body"};function j(c,d,t,r,i,l){const o=v("a-tag");return u(),S("div",{class:B(["chat-row",{mine:r.isMine}])},[s("div",T,[s("div",q,[s("span",M,a(r.actorLabel),1),s("span",R,a(r.formattedTime),1)]),s("div",V,a(r.messageText),1),t.event.source.adapter?(u(),y(o,{key:0,class:"src",color:r.adapterColor},{default:x(()=>[C(a(t.event.source.adapter),1)]),_:1},8,["color"])):w("v-if",!0)])],2)}const z=k(N,[["render",j],["__scopeId","data-v-49238629"],["__file","/tmp/cc-web-panel-ejxnqz/repo/packages/web-panel/src/components/pdh/renderers/ChatBubbleRenderer.vue"]]);export{z as default};