chainlesschain 0.166.20 → 0.166.21

package/src/lib/skill-vector-process-authority.js

@@ -0,0 +1,386 @@
+import { createHash } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { types as utilTypes } from "node:util";
+
+import { executionBroker } from "./process-execution-broker/index.js";
+import { createSkillVectorAuthority } from "./skill-vector-authority.js";
+
+export const SKILL_VECTOR_PROCESS_REQUEST_SCHEMA =
+  "chainlesschain.skill-vector-process-request/v1";
+
+const DIGEST = /^sha256:[a-f0-9]{64}$/u;
+const SAFE_ID = /^[A-Za-z0-9][A-Za-z0-9._:@/-]{0,255}$/u;
+const WORKER_KEYS = new Set([
+  "arguments",
+  "cwd",
+  "entryDigest",
+  "entryPath",
+  "environment",
+  "executableDigest",
+  "executablePath",
+  "identity",
+]);
+const DEFAULT_TIMEOUT_MS = 10_000;
+const DEFAULT_MAX_INPUT_BYTES = 12 * 1024 * 1024;
+const DEFAULT_MAX_OUTPUT_BYTES = 4 * 1024 * 1024;
+const MAX_STDERR_BYTES = 64 * 1024;
+const MAX_EXECUTABLE_BYTES = 512 * 1024 * 1024;
+const MAX_ENTRY_BYTES = 16 * 1024 * 1024;
+const PROCESS_DEPS = Object.freeze({
+  spawn: (...args) => executionBroker.spawn(...args),
+});
+
+function plainRecord(value, label, allowedKeys = null) {
+  if (
+    !value ||
+    typeof value !== "object" ||
+    Array.isArray(value) ||
+    utilTypes.isProxy(value) ||
+    ![Object.prototype, null].includes(Object.getPrototypeOf(value)) ||
+    (allowedKeys &&
+      Reflect.ownKeys(value).some(
+        (key) => typeof key !== "string" || !allowedKeys.has(key),
+      ))
+  ) {
+    throw new TypeError(`${label} is invalid`);
+  }
+  return value;
+}
+
+function identifier(value, label) {
+  if (typeof value !== "string" || !SAFE_ID.test(value)) {
+    throw new TypeError(`${label} is invalid`);
+  }
+  return value;
+}
+
+function pinnedDigest(value, label) {
+  if (typeof value !== "string" || !DIGEST.test(value)) {
+    throw new TypeError(`${label} must be sha256-bound`);
+  }
+  return value;
+}
+
+function absolutePath(value, label) {
+  if (
+    typeof value !== "string" ||
+    value.includes("\0") ||
+    !path.isAbsolute(value) ||
+    path.normalize(value) !== value
+  ) {
+    throw new TypeError(`${label} must be a normalized absolute path`);
+  }
+  return value;
+}
+
+function boundedInteger(value, fallback, label, maximum) {
+  const normalized = value === undefined ? fallback : value;
+  if (
+    !Number.isSafeInteger(normalized) ||
+    normalized < 1 ||
+    normalized > maximum
+  ) {
+    throw new TypeError(`${label} is invalid or unbounded`);
+  }
+  return normalized;
+}
+
+function normalizeArguments(value, label) {
+  if (value === undefined) return Object.freeze([]);
+  if (!Array.isArray(value) || utilTypes.isProxy(value) || value.length > 64) {
+    throw new TypeError(`${label} is invalid or unbounded`);
+  }
+  let bytes = 0;
+  const result = value.map((argument, index) => {
+    if (
+      typeof argument !== "string" ||
+      argument.includes("\0") ||
+      Buffer.byteLength(argument, "utf8") > 4096
+    ) {
+      throw new TypeError(`${label}[${index}] is invalid or unbounded`);
+    }
+    bytes += Buffer.byteLength(argument, "utf8");
+    return argument;
+  });
+  if (bytes > 32 * 1024) {
+    throw new TypeError(`${label} is invalid or unbounded`);
+  }
+  return Object.freeze(result);
+}
+
+function normalizeEnvironment(value, label) {
+  if (value === undefined) return Object.freeze({});
+  plainRecord(value, label);
+  const entries = Object.entries(value);
+  if (entries.length > 64) {
+    throw new TypeError(`${label} is invalid or unbounded`);
+  }
+  let bytes = 0;
+  const result = Object.create(null);
+  const normalizedKeys = new Set();
+  for (const [key, entry] of entries.sort(([left], [right]) =>
+    left.localeCompare(right),
+  )) {
+    const normalizedKey =
+      process.platform === "win32" ? key.toLowerCase() : key;
+    if (
+      !/^[A-Za-z_][A-Za-z0-9_]{0,127}$/u.test(key) ||
+      normalizedKeys.has(normalizedKey) ||
+      typeof entry !== "string" ||
+      entry.includes("\0") ||
+      Buffer.byteLength(entry, "utf8") > 16 * 1024
+    ) {
+      throw new TypeError(`${label}.${key} is invalid or unbounded`);
+    }
+    bytes += Buffer.byteLength(key, "utf8") + Buffer.byteLength(entry, "utf8");
+    normalizedKeys.add(normalizedKey);
+    result[key] = entry;
+  }
+  if (bytes > 32 * 1024) {
+    throw new TypeError(`${label} is invalid or unbounded`);
+  }
+  return Object.freeze(result);
+}
+
+function normalizeWorker(value, label) {
+  plainRecord(value, label, WORKER_KEYS);
+  return Object.freeze({
+    identity: identifier(value.identity, `${label}.identity`),
+    executablePath: absolutePath(
+      value.executablePath,
+      `${label}.executablePath`,
+    ),
+    executableDigest: pinnedDigest(
+      value.executableDigest,
+      `${label}.executableDigest`,
+    ),
+    entryPath: absolutePath(value.entryPath, `${label}.entryPath`),
+    entryDigest: pinnedDigest(value.entryDigest, `${label}.entryDigest`),
+    arguments: normalizeArguments(value.arguments, `${label}.arguments`),
+    cwd: absolutePath(value.cwd, `${label}.cwd`),
+    environment: normalizeEnvironment(
+      value.environment,
+      `${label}.environment`,
+    ),
+  });
+}
+
+function fileDigest(filePath) {
+  return `sha256:${createHash("sha256").update(fs.readFileSync(filePath)).digest("hex")}`;
+}
+
+function samePath(left, right) {
+  return process.platform === "win32"
+    ? left.toLowerCase() === right.toLowerCase()
+    : left === right;
+}
+
+function assertPinnedFile(filePath, expectedDigest, label, maximumBytes) {
+  const stat = fs.lstatSync(filePath);
+  if (
+    !stat.isFile() ||
+    stat.isSymbolicLink() ||
+    stat.size < 1 ||
+    stat.size > maximumBytes
+  ) {
+    throw new Error(`${label} is not a regular pinned file`);
+  }
+  const realPath = fs.realpathSync.native(filePath);
+  if (!samePath(realPath, filePath)) {
+    throw new Error(`${label} does not resolve to its pinned path`);
+  }
+  if (fileDigest(filePath) !== expectedDigest) {
+    throw new Error(`${label} digest changed`);
+  }
+}
+
+function assertWorkerIdentity(worker, label) {
+  assertPinnedFile(
+    worker.executablePath,
+    worker.executableDigest,
+    `${label} executable`,
+    MAX_EXECUTABLE_BYTES,
+  );
+  assertPinnedFile(
+    worker.entryPath,
+    worker.entryDigest,
+    `${label} entry`,
+    MAX_ENTRY_BYTES,
+  );
+  const cwd = fs.realpathSync.native(worker.cwd);
+  if (!samePath(cwd, worker.cwd) || !fs.statSync(cwd).isDirectory()) {
+    throw new Error(`${label} cwd does not resolve to its pinned directory`);
+  }
+}
+
+function processFailure(code) {
+  const error = new Error(`Skill vector process failed closed (${code})`);
+  error.code = code;
+  return error;
+}
+
+async function invokeWorker(
+  worker,
+  role,
+  payload,
+  { timeoutMs, maxInputBytes, maxOutputBytes },
+) {
+  assertWorkerIdentity(worker, role);
+  const input = Buffer.from(
+    `${JSON.stringify({
+      schema: SKILL_VECTOR_PROCESS_REQUEST_SCHEMA,
+      role,
+      payload,
+    })}\n`,
+    "utf8",
+  );
+  if (input.length > maxInputBytes) {
+    throw processFailure("CC_SKILL_VECTOR_PROCESS_INPUT_LIMIT");
+  }
+
+  const output = await new Promise((resolve, reject) => {
+    let settled = false;
+    let pendingFailure = null;
+    let timer = null;
+    let stdoutBytes = 0;
+    let stderrBytes = 0;
+    const stdout = [];
+    const child = PROCESS_DEPS.spawn(
+      worker.executablePath,
+      [worker.entryPath, ...worker.arguments],
+      {
+        cwd: worker.cwd,
+        env: { ...worker.environment },
+        shell: false,
+        windowsHide: true,
+        stdio: ["pipe", "pipe", "pipe"],
+        origin: "skill-vector-process-authority",
+        scope: "evolution",
+        policy: "allow",
+        auditRedactArgIndexes: worker.arguments.map((_, index) => index + 1),
+      },
+    );
+    const terminate = (error) => {
+      if (settled || pendingFailure) return;
+      pendingFailure = error;
+      if (child.exitCode === null) child.kill("SIGKILL");
+    };
+    timer = setTimeout(() => {
+      terminate(processFailure("CC_SKILL_VECTOR_PROCESS_TIMEOUT"));
+    }, timeoutMs);
+    timer.unref?.();
+    child.once("error", () => {
+      terminate(processFailure("CC_SKILL_VECTOR_PROCESS_SPAWN_FAILED"));
+    });
+    child.stdout.on("data", (chunk) => {
+      if (pendingFailure) return;
+      stdoutBytes += chunk.length;
+      if (stdoutBytes > maxOutputBytes) {
+        terminate(processFailure("CC_SKILL_VECTOR_PROCESS_OUTPUT_LIMIT"));
+        return;
+      }
+      stdout.push(chunk);
+    });
+    child.stderr.on("data", (chunk) => {
+      if (pendingFailure) return;
+      stderrBytes += chunk.length;
+      if (stderrBytes > MAX_STDERR_BYTES) {
+        terminate(processFailure("CC_SKILL_VECTOR_PROCESS_STDERR_LIMIT"));
+      }
+    });
+    child.once("close", (code, signal) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      if (pendingFailure) {
+        reject(pendingFailure);
+        return;
+      }
+      if (code !== 0 || signal !== null) {
+        reject(processFailure("CC_SKILL_VECTOR_PROCESS_EXITED"));
+        return;
+      }
+      resolve(Buffer.concat(stdout).toString("utf8"));
+    });
+    child.stdin.once("error", () => {
+      terminate(processFailure("CC_SKILL_VECTOR_PROCESS_STDIN_FAILED"));
+    });
+    child.stdin.end(input);
+  });
+
+  assertWorkerIdentity(worker, role);
+  const text = output.trim();
+  if (text === "" || Buffer.byteLength(text, "utf8") > maxOutputBytes) {
+    throw processFailure("CC_SKILL_VECTOR_PROCESS_EMPTY_OUTPUT");
+  }
+  try {
+    const parsed = JSON.parse(text);
+    plainRecord(parsed, `${role} process result`);
+    return parsed;
+  } catch (error) {
+    if (error?.code?.startsWith?.("CC_SKILL_VECTOR_")) throw error;
+    throw processFailure("CC_SKILL_VECTOR_PROCESS_INVALID_JSON");
+  }
+}
+
+/**
+ * Creates the existing branded vector authority over two independently pinned
+ * JSON worker processes. The host supplies all executable and entry digests;
+ * no PATH lookup, shell, inherited environment, local key or permissive
+ * verifier fallback is used.
+ */
+export function createSkillVectorProcessAuthority({
+  tenantId,
+  provider: providerInput,
+  verifier: verifierInput,
+  timeoutMs: timeoutInput,
+  maxInputBytes: maxInputInput,
+  maxOutputBytes: maxOutputInput,
+} = {}) {
+  const provider = normalizeWorker(providerInput, "provider");
+  const verifier = normalizeWorker(verifierInput, "verifier");
+  if (
+    provider.identity === verifier.identity ||
+    provider.entryDigest === verifier.entryDigest
+  ) {
+    throw new TypeError(
+      "Skill vector provider and verifier must be independent",
+    );
+  }
+  const limits = Object.freeze({
+    timeoutMs: boundedInteger(
+      timeoutInput,
+      DEFAULT_TIMEOUT_MS,
+      "timeoutMs",
+      60_000,
+    ),
+    maxInputBytes: boundedInteger(
+      maxInputInput,
+      DEFAULT_MAX_INPUT_BYTES,
+      "maxInputBytes",
+      16 * 1024 * 1024,
+    ),
+    maxOutputBytes: boundedInteger(
+      maxOutputInput,
+      DEFAULT_MAX_OUTPUT_BYTES,
+      "maxOutputBytes",
+      8 * 1024 * 1024,
+    ),
+  });
+  assertWorkerIdentity(provider, "provider");
+  assertWorkerIdentity(verifier, "verifier");
+  return createSkillVectorAuthority({
+    tenantId,
+    provider: Object.freeze({
+      score: Object.freeze((request) =>
+        invokeWorker(provider, "provider", request, limits),
+      ),
+    }),
+    verifier: Object.freeze({
+      verify: Object.freeze((request) =>
+        invokeWorker(verifier, "verifier", request, limits),
+      ),
+    }),
+  });
+}

package/src/repl/agent-repl.js

@@ -739,6 +739,7 @@ export async function agentLoop(messages, options) {
               tool: event?.tool || started?.tool || "?",
               isError: Boolean(event?.error || event?.result?.error),
               skill: event?.attribution?.skill,
+              invocationReceipt: event?.result?.invocationReceipt,
               durationMs: started
                 ? Math.max(
                     0,
@@ -918,9 +919,13 @@ export async function agentLoop(messages, options) {
                 : undefined,
             ...extractPluginUsageAttribution(event.result),
             durationMs,
+            invocationReceipt: event.result?.invocationReceipt,
           });
         } catch (_e) {
-          if (options.persistUsageTelemetry === true) {
+          if (
+            event.result?.invocationReceipt ||
+            options.persistUsageTelemetry === true
+          ) {
             throw markRuntimeLedgerPersistenceError(_e);
           }
           // Legacy non-JSONL persistence remains best-effort.
@@ -9638,6 +9643,7 @@ async function startAgentReplInWorkspaceOwned(
         sessionId,
         persistUsageTelemetry: useJsonl,
         skillLoader: _replSkillLoader,
+        skillOutcomeIndex: options.skillOutcomeIndex,
         cwd: process.cwd(),
         additionalDirectories,
         sandbox: _sandbox,

package/src/runtime/agent-core.js

@@ -45,6 +45,12 @@ import {
 } from "../lib/lsp/workspace-roots.js";
 import { getPlanModeManager } from "../lib/plan-mode.js";
 import { CLISkillLoader } from "../lib/skill-loader.js";
+import { routeSkillDescriptors } from "../lib/skill-retrieval-router.js";
+import { resolveSkillOutcomeAuthority } from "../lib/skill-outcome-authority.js";
+import {
+  captureSkillVectorAuthority,
+  unavailableSkillVectorEvidence,
+} from "../lib/skill-vector-authority.js";
 import {
   admitSkillPrompt,
   debitSkillPromptBudget,
@@ -3549,6 +3555,8 @@ export async function executeTool(name, args, context = {}) {
       skillLoader,
       // Subagent skill capability INTERSECT — forwarded to run_skill/list_skills.
       skillAllowlist: context.skillAllowlist ?? null,
+      skillOutcomeIndex: context.skillOutcomeIndex,
+      skillVectorAuthority: context.skillVectorAuthority,
       cwd,
       parentMessages: context.parentMessages,
       interaction: context.interaction,
@@ -5091,6 +5099,8 @@ async function executeToolInner(
   {
     skillLoader,
     skillAllowlist = null,
+    skillOutcomeIndex,
+    skillVectorAuthority,
     cwd,
     parentMessages,
     interaction,
@@ -8201,14 +8211,38 @@ async function executeToolInner(
           (s) => s.category.toLowerCase() === args.category.toLowerCase(),
         );
       }
+      let routing = null;
+      let outcomeAuthority = null;
+      let vector = null;
       if (args.query) {
-        const q = args.query.toLowerCase();
-        skills = skills.filter(
-          (s) =>
-            s.id.includes(q) ||
-            s.description.toLowerCase().includes(q) ||
-            s.category.toLowerCase().includes(q),
+        outcomeAuthority = resolveSkillOutcomeAuthority(
+          skillOutcomeIndex === undefined ? {} : { index: skillOutcomeIndex },
+        );
+        const vectorAuthority =
+          skillVectorAuthority == null
+            ? null
+            : captureSkillVectorAuthority(skillVectorAuthority);
+        vector =
+          vectorAuthority === null
+            ? null
+            : await vectorAuthority.score({ query: args.query, skills });
+        routing = routeSkillDescriptors({
+          skills,
+          query: args.query,
+          target: { os: process.platform },
+          vectorScores: vector?.scores ?? null,
+          outcomeMetrics: outcomeAuthority.metrics,
+          topK: Math.min(64, Math.max(1, skills.length)),
+        });
+        const byDigest = new Map(
+          skills.map((skill) => [
+            skill.executionIdentity?.contentDigest,
+            skill,
+          ]),
         );
+        skills = routing.candidates
+          .map(({ digest }) => byDigest.get(digest))
+          .filter(Boolean);
       }
       skillLoader.recordDescriptorUse?.(skills, {
         sessionId,
@@ -8217,12 +8251,42 @@ async function executeToolInner(
       });
       return attachDescriptor({
         count: skills.length,
+        ...(routing
+          ? {
+              routing: {
+                schema: routing.schema,
+                selectedDigest: routing.selected?.digest || null,
+                conflicts: routing.conflicts,
+                rejectedCount: routing.rejected.length,
+                vectorAvailable: routing.vectorAvailable,
+                vectorAuthority:
+                  vector?.evidence ?? unavailableSkillVectorEvidence(),
+                outcomeAuthority: outcomeAuthority.evidence,
+              },
+            }
+          : {}),
         skills: skills.map((s) => ({
           id: s.id,
           category: s.category,
           source: s.source,
           hasHandler: s.hasHandler,
           description: (s.description || "").substring(0, 80),
+          ...(routing
+            ? (() => {
+                const candidate = routing.candidates.find(
+                  ({ digest }) => digest === s.executionIdentity?.contentDigest,
+                );
+                return candidate
+                  ? {
+                      digest: candidate.digest,
+                      version: candidate.version,
+                      contextCostTokens: candidate.contextCostTokens,
+                      routeScore: candidate.score,
+                      routeReason: candidate.reason,
+                    }
+                  : {};
+              })()
+            : {}),
         })),
       });
     }
@@ -13160,6 +13224,8 @@ export async function* agentLoop(messages, options) {
   const toolContext = {
     hookDb: hermeticExecution ? null : options.hookDb || null,
     skillLoader: options.skillLoader || _defaultSkillLoader,
+    skillOutcomeIndex: options.skillOutcomeIndex,
+    skillVectorAuthority: options.skillVectorAuthority,
     // Hook-envelope tracing (P2 unified event bus): every settings-hook payload
     // fired during this run carries trace_id = this run's id; a spawned child
     // loop carries parent_id = the spawning run's id (threaded by

package/src/runtime/agent-runtime.js

@@ -34,6 +34,8 @@ import { registerHostHooksV2Workspace } from "../lib/hooks-v2-workspace-context.
 import { captureStructuredMemoryPolicyReceiptWriter } from "../lib/evolution/structured-memory-policy-receipt-writer.js";
 import { captureStructuredMemoryAgentControlPlane } from "../lib/evolution/structured-memory-agent-control-plane.js";
 import { captureAgentEvolutionIngress } from "../lib/evolution/agent-evolution-ingress.js";
+import { captureAgentSkillOutcomeIndex } from "../lib/evolution/agent-evolution-runtime-composition-brand.js";
+import { captureSkillVectorAuthority } from "../lib/skill-vector-authority.js";
 
 const {
   DEFAULT_ALLOWED_MCP_SERVER_NAMES,
@@ -69,6 +71,34 @@ export class AgentRuntime {
       deps.evolutionIngress == null
         ? null
         : captureAgentEvolutionIngress(deps.evolutionIngress);
+    this.skillOutcomeIndex =
+      deps.skillOutcomeIndex == null
+        ? null
+        : captureAgentSkillOutcomeIndex(deps.skillOutcomeIndex);
+    this.skillVectorAuthority =
+      deps.skillVectorAuthority == null
+        ? null
+        : captureSkillVectorAuthority(deps.skillVectorAuthority);
+    if (
+      this.evolutionIngress !== null &&
+      this.skillOutcomeIndex !== null &&
+      this.evolutionIngress.tenantId !== this.skillOutcomeIndex.tenantId
+    ) {
+      throw new Error(
+        "Agent evolution ingress and Skill outcome index must share one tenant",
+      );
+    }
+    const retrievalTenant =
+      this.evolutionIngress?.tenantId ??
+      this.skillOutcomeIndex?.tenantId ??
+      null;
+    if (
+      retrievalTenant !== null &&
+      this.skillVectorAuthority !== null &&
+      retrievalTenant !== this.skillVectorAuthority.tenantId
+    ) {
+      throw new Error("Agent retrieval authorities must share one tenant");
+    }
     this.structuredMemoryControlPlane =
       deps.structuredMemoryControlPlane == null
         ? null
@@ -297,6 +327,12 @@ export class AgentRuntime {
       ...(this.evolutionIngress === null
         ? {}
         : { evolutionIngress: this.evolutionIngress }),
+      ...(this.skillOutcomeIndex === null
+        ? {}
+        : { skillOutcomeIndex: this.skillOutcomeIndex }),
+      ...(this.skillVectorAuthority === null
+        ? {}
+        : { skillVectorAuthority: this.skillVectorAuthority }),
     });
     if (this.evolutionIngress !== null) {
       await this.evolutionIngress.complete();
@@ -468,6 +504,12 @@ export class AgentRuntime {
       remoteSessionPeerId,
       envelopeBus,
       evolutionCompositionFactory: this.deps.evolutionCompositionFactory,
+      ...(this.skillOutcomeIndex === null
+        ? {}
+        : { skillOutcomeIndex: this.skillOutcomeIndex }),
+      ...(this.skillVectorAuthority === null
+        ? {}
+        : { skillVectorAuthority: this.skillVectorAuthority }),
     });
 
     server.on("connection", ({ clientId, ip }) => {

package/src/runtime/headless-runner.js

@@ -121,6 +121,8 @@ import { createBackgroundPhaseReporter } from "../lib/background-phase-reporter.
 import { createBackgroundInteractionClient } from "../lib/background-interaction-resolver.js";
 import { withQuietStdout } from "./quiet-stdout.js";
 import { captureAgentEvolutionIngress } from "../lib/evolution/agent-evolution-ingress.js";
+import { captureAgentSkillOutcomeIndex } from "../lib/evolution/agent-evolution-runtime-composition-brand.js";
+import { captureSkillVectorAuthority } from "../lib/skill-vector-authority.js";
 import { CostBudget } from "../lib/cost-budget.js";
 import { estimateTokens } from "../harness/prompt-compressor.js";
 import {
@@ -659,6 +661,32 @@ async function runAgentHeadlessInWorkspace(
     options.evolutionIngress == null
       ? null
       : captureAgentEvolutionIngress(options.evolutionIngress);
+  const skillOutcomeIndex =
+    options.skillOutcomeIndex == null
+      ? null
+      : captureAgentSkillOutcomeIndex(options.skillOutcomeIndex);
+  const skillVectorAuthority =
+    options.skillVectorAuthority == null
+      ? null
+      : captureSkillVectorAuthority(options.skillVectorAuthority);
+  if (
+    evolutionIngress !== null &&
+    skillOutcomeIndex !== null &&
+    evolutionIngress.tenantId !== skillOutcomeIndex.tenantId
+  ) {
+    throw new TypeError(
+      "Agent evolution ingress and Skill outcome index must share one tenant",
+    );
+  }
+  const retrievalTenant =
+    evolutionIngress?.tenantId ?? skillOutcomeIndex?.tenantId ?? null;
+  if (
+    retrievalTenant !== null &&
+    skillVectorAuthority !== null &&
+    retrievalTenant !== skillVectorAuthority.tenantId
+  ) {
+    throw new TypeError("Agent retrieval authorities must share one tenant");
+  }
   const prompt = (options.prompt || "").trim();
   if (!prompt) {
     throw new Error(
@@ -2449,6 +2477,8 @@ async function runAgentHeadlessInWorkspace(
     apiKey,
     cwd,
     skillLoader: _runtimeSkillLoader,
+    ...(skillOutcomeIndex === null ? {} : { skillOutcomeIndex }),
+    ...(skillVectorAuthority === null ? {} : { skillVectorAuthority }),
     additionalDirectories,
     sandbox: options.sandbox || null,
     sessionId,
@@ -2605,6 +2635,7 @@ async function runAgentHeadlessInWorkspace(
               tool: event?.tool || started?.tool || "?",
               isError: Boolean(event?.error || event?.result?.error),
               skill: event?.attribution?.skill,
+              invocationReceipt: event?.result?.invocationReceipt,
               durationMs: started
                 ? Math.max(
                     0,
@@ -3211,6 +3242,7 @@ async function runAgentHeadlessInWorkspace(
                   plugin: settledCall.plugin || undefined,
                   pluginVersion: settledCall.pluginVersion || undefined,
                   durationMs: settledCall.durationMs,
+                  invocationReceipt: event.result?.invocationReceipt,
                 }),
               );
             }