chainlesschain 0.166.46 → 0.166.47

package/src/lib/openai-responses.js

@@ -0,0 +1,428 @@
+const RESPONSES_FAILURE_CODE = "CC_OPENAI_RESPONSES_FAILED";
+const MAX_REASONING_ITEMS = 16;
+const MAX_REASONING_SUMMARY_CHARS = 8_192;
+
+function nonNegativeInteger(value) {
+  return Number.isSafeInteger(value) && value >= 0 ? value : null;
+}
+
+function printableString(value, fallback = "") {
+  return typeof value === "string" ? value : fallback;
+}
+
+function jsonText(value) {
+  if (typeof value === "string") return value;
+  try {
+    const encoded = JSON.stringify(value);
+    return typeof encoded === "string" ? encoded : "";
+  } catch {
+    return String(value ?? "");
+  }
+}
+
+function responseFailure(data) {
+  const providerCode = printableString(
+    data?.error?.code || data?.incomplete_details?.reason || data?.status,
+    "unknown",
+  ).slice(0, 128);
+  const error = new Error(`OpenAI Responses request failed (${providerCode})`);
+  error.code = RESPONSES_FAILURE_CODE;
+  error.providerCode = providerCode;
+  return error;
+}
+
+function normalizeImageBlock(block) {
+  const imageUrl =
+    typeof block?.image_url === "string"
+      ? block.image_url
+      : block?.image_url?.url;
+  if (typeof imageUrl !== "string" || !imageUrl) return null;
+  return {
+    type: "input_image",
+    image_url: imageUrl,
+    ...(typeof block?.image_url?.detail === "string"
+      ? { detail: block.image_url.detail }
+      : typeof block?.detail === "string"
+        ? { detail: block.detail }
+        : {}),
+  };
+}
+
+function normalizeMessageContent(content, role) {
+  if (!Array.isArray(content)) return jsonText(content);
+  const assistant = role === "assistant";
+  return content.map((block) => {
+    if (block?.type === "image_url" || block?.type === "input_image") {
+      return (
+        normalizeImageBlock(block) || {
+          type: assistant ? "output_text" : "input_text",
+          text: "[invalid image input]",
+        }
+      );
+    }
+    if (block?.type === "input_file" && !assistant) return block;
+    const text = printableString(
+      block?.text ?? block?.refusal,
+      jsonText(block),
+    );
+    return {
+      type: assistant ? "output_text" : "input_text",
+      text,
+    };
+  });
+}
+
+function sanitizeReasoningItems(items) {
+  if (!Array.isArray(items)) return [];
+  const output = [];
+  for (const item of items.slice(0, MAX_REASONING_ITEMS)) {
+    if (!item || item.type !== "reasoning") continue;
+    const id = printableString(item.id);
+    const encryptedContent = printableString(item.encrypted_content);
+    const status = ["completed", "in_progress", "incomplete"].includes(
+      item.status,
+    )
+      ? item.status
+      : null;
+    const summary = Array.isArray(item.summary)
+      ? item.summary
+          .filter((part) => part?.type === "summary_text")
+          .map((part) => ({
+            type: "summary_text",
+            text: printableString(part.text).slice(
+              0,
+              MAX_REASONING_SUMMARY_CHARS,
+            ),
+          }))
+      : [];
+    if (!id && !encryptedContent && summary.length === 0) continue;
+    output.push({
+      type: "reasoning",
+      ...(id ? { id } : {}),
+      ...(encryptedContent ? { encrypted_content: encryptedContent } : {}),
+      ...(summary.length ? { summary } : {}),
+      ...(status ? { status } : {}),
+    });
+  }
+  return output;
+}
+
+/** Convert the internal Chat-Completions-shaped history into Responses items. */
+export function toOpenAIResponsesInput(messages) {
+  const input = [];
+  for (const message of messages || []) {
+    if (!message || typeof message !== "object") continue;
+    if (message.role === "tool") {
+      input.push({
+        type: "function_call_output",
+        call_id: printableString(message.tool_call_id),
+        output: jsonText(message.content),
+      });
+      continue;
+    }
+    if (message.role === "assistant") {
+      input.push(...sanitizeReasoningItems(message._openaiReasoningItems));
+    }
+    const content = normalizeMessageContent(message.content, message.role);
+    const hasContent = Array.isArray(content)
+      ? content.length > 0
+      : content.length > 0;
+    if (hasContent || message.role !== "assistant") {
+      input.push({
+        role: ["system", "developer", "assistant", "user"].includes(
+          message.role,
+        )
+          ? message.role
+          : "user",
+        content,
+      });
+    }
+    if (message.role === "assistant" && Array.isArray(message.tool_calls)) {
+      for (const toolCall of message.tool_calls) {
+        const name = printableString(toolCall?.function?.name);
+        const callId = printableString(toolCall?.id);
+        if (!name || !callId) continue;
+        input.push({
+          type: "function_call",
+          call_id: callId,
+          name,
+          arguments: printableString(toolCall?.function?.arguments, "{}"),
+        });
+      }
+    }
+  }
+  return input;
+}
+
+/** Flatten Chat Completions function descriptors into Responses tools. */
+export function toOpenAIResponsesTools(tools) {
+  return (tools || [])
+    .filter((tool) => tool?.type === "function" && tool.function?.name)
+    .map((tool) => ({
+      type: "function",
+      name: tool.function.name,
+      description: printableString(tool.function.description),
+      parameters: tool.function.parameters || { type: "object" },
+      ...(typeof tool.function.strict === "boolean"
+        ? { strict: tool.function.strict }
+        : {}),
+    }));
+}
+
+export function createOpenAIResponsesBody({
+  model,
+  messages,
+  tools,
+  maxOutputTokens = null,
+  reasoning = null,
+  stream = false,
+}) {
+  return {
+    model,
+    input: toOpenAIResponsesInput(messages),
+    tools: toOpenAIResponsesTools(tools),
+    store: false,
+    include: ["reasoning.encrypted_content"],
+    ...(maxOutputTokens ? { max_output_tokens: maxOutputTokens } : {}),
+    ...(reasoning ? { reasoning } : {}),
+    ...(stream ? { stream: true } : {}),
+  };
+}
+
+export function normalizeOpenAIResponsesUsage(usage) {
+  if (!usage || typeof usage !== "object" || Array.isArray(usage)) return null;
+  const input = nonNegativeInteger(usage.input_tokens);
+  const output = nonNegativeInteger(usage.output_tokens);
+  if (input === null || output === null) return null;
+  const details = usage.input_tokens_details;
+  const outputDetails = usage.output_tokens_details;
+  let cached = 0;
+  let reasoning = null;
+  if (details != null) {
+    if (typeof details !== "object" || Array.isArray(details)) return null;
+    if (Object.hasOwn(details, "cached_tokens")) {
+      cached = nonNegativeInteger(details.cached_tokens);
+      if (cached === null || cached > input) return null;
+    }
+  }
+  if (outputDetails != null) {
+    if (typeof outputDetails !== "object" || Array.isArray(outputDetails)) {
+      return null;
+    }
+    if (Object.hasOwn(outputDetails, "reasoning_tokens")) {
+      reasoning = nonNegativeInteger(outputDetails.reasoning_tokens);
+      // OpenAI reports reasoning tokens as a subset of output tokens. Keep the
+      // dimension independently, but reject impossible usage rather than
+      // allowing it to inflate or contradict the billable output total.
+      if (reasoning === null || reasoning > output) return null;
+    }
+  }
+  return {
+    input_tokens: input - cached,
+    output_tokens: output,
+    cache_read_input_tokens: cached,
+    ...(reasoning !== null ? { reasoning_tokens: reasoning } : {}),
+  };
+}
+
+function responseOutput(data) {
+  return Array.isArray(data?.output) ? data.output : [];
+}
+
+/** Normalize one completed/incomplete Responses object for the existing loop. */
+export function normalizeOpenAIResponsesResponse(data) {
+  if (!data || typeof data !== "object" || Array.isArray(data)) {
+    throw responseFailure({ status: "invalid_response" });
+  }
+  if (data.error || ["failed", "cancelled"].includes(data.status)) {
+    throw responseFailure(data);
+  }
+  if (data.status && !["completed", "incomplete"].includes(data.status)) {
+    throw responseFailure(data);
+  }
+
+  const output = responseOutput(data);
+  const text = [];
+  const toolCalls = [];
+  const reasoningItems = [];
+  const reasoningSummary = [];
+  for (const item of output) {
+    if (item?.type === "message" && Array.isArray(item.content)) {
+      for (const part of item.content) {
+        if (part?.type === "output_text" && typeof part.text === "string") {
+          text.push(part.text);
+        } else if (
+          part?.type === "refusal" &&
+          typeof part.refusal === "string"
+        ) {
+          text.push(part.refusal);
+        }
+      }
+    } else if (item?.type === "function_call") {
+      const id = printableString(item.call_id || item.id);
+      const name = printableString(item.name);
+      if (id && name) {
+        toolCalls.push({
+          id,
+          type: "function",
+          function: {
+            name,
+            arguments: printableString(item.arguments, "{}"),
+          },
+        });
+      }
+    } else if (item?.type === "reasoning") {
+      reasoningItems.push(item);
+      for (const part of item.summary || []) {
+        if (part?.type === "summary_text" && typeof part.text === "string") {
+          reasoningSummary.push(part.text);
+        }
+      }
+    }
+  }
+
+  const message = { role: "assistant", content: text.join("") };
+  if (toolCalls.length) message.tool_calls = toolCalls;
+  const safeReasoning = sanitizeReasoningItems(reasoningItems);
+  if (safeReasoning.length) message._openaiReasoningItems = safeReasoning;
+  if (reasoningSummary.length) {
+    message._openaiReasoningSummary = reasoningSummary
+      .join("")
+      .slice(0, MAX_REASONING_SUMMARY_CHARS);
+  }
+  if (data.status === "incomplete") {
+    delete message.tool_calls;
+    delete message._openaiReasoningItems;
+    message._truncated = true;
+  }
+  const result = {
+    message,
+    responseId: printableString(data.id) || null,
+  };
+  const usage = normalizeOpenAIResponsesUsage(data.usage);
+  if (usage) result.usage = usage;
+  return result;
+}
+
+export function createOpenAIResponsesStreamState() {
+  return {
+    responseId: null,
+    text: "",
+    reasoningSummary: "",
+    outputItems: [],
+    normalized: null,
+    terminalError: null,
+  };
+}
+
+function streamItem(state, event) {
+  const index = Number.isSafeInteger(event.output_index)
+    ? event.output_index
+    : state.outputItems.length;
+  if (!state.outputItems[index]) {
+    state.outputItems[index] = {
+      type: "function_call",
+      call_id: printableString(event.call_id || event.item_id),
+      name: printableString(event.name),
+      arguments: "",
+    };
+  }
+  return state.outputItems[index];
+}
+
+export function reduceOpenAIResponsesStreamLine(
+  state,
+  raw,
+  onToken,
+  onThinking,
+) {
+  const line = printableString(raw).trim();
+  if (!line.startsWith("data:")) return state;
+  const payload = line.slice(5).trim();
+  if (!payload || payload === "[DONE]") return state;
+  let event;
+  try {
+    event = JSON.parse(payload);
+  } catch {
+    return state;
+  }
+  state.responseId ||= printableString(event.response_id || event.response?.id);
+  if (event.type === "response.output_text.delta") {
+    const delta = printableString(event.delta);
+    state.text += delta;
+    onToken?.(delta);
+  } else if (event.type === "response.refusal.delta") {
+    const delta = printableString(event.delta);
+    state.text += delta;
+    onToken?.(delta);
+  } else if (event.type === "response.reasoning_summary_text.delta") {
+    const delta = printableString(event.delta);
+    state.reasoningSummary += delta;
+    onThinking?.(delta);
+  } else if (event.type === "response.output_item.added" && event.item) {
+    const index = Number.isSafeInteger(event.output_index)
+      ? event.output_index
+      : state.outputItems.length;
+    state.outputItems[index] = event.item;
+  } else if (event.type === "response.output_item.done" && event.item) {
+    const index = Number.isSafeInteger(event.output_index)
+      ? event.output_index
+      : state.outputItems.length;
+    state.outputItems[index] = event.item;
+  } else if (event.type === "response.function_call_arguments.delta") {
+    const item = streamItem(state, event);
+    item.arguments = `${printableString(item.arguments)}${printableString(event.delta)}`;
+  } else if (event.type === "response.function_call_arguments.done") {
+    const item = streamItem(state, event);
+    item.arguments = printableString(event.arguments, item.arguments || "{}");
+  } else if (
+    event.type === "response.completed" ||
+    event.type === "response.incomplete"
+  ) {
+    try {
+      state.normalized = normalizeOpenAIResponsesResponse(event.response);
+    } catch (error) {
+      state.terminalError = error;
+    }
+  } else if (event.type === "response.failed" || event.type === "error") {
+    state.terminalError = responseFailure(event.response || event);
+  }
+  return state;
+}
+
+export function finalizeOpenAIResponsesStream(state) {
+  if (state.terminalError) throw state.terminalError;
+  if (state.normalized) return state.normalized;
+  const output = state.outputItems.filter(Boolean);
+  let normalized;
+  if (output.length) {
+    normalized = normalizeOpenAIResponsesResponse({
+      id: state.responseId,
+      status: "completed",
+      output,
+    });
+  } else {
+    normalized = {
+      message: { role: "assistant", content: state.text },
+      responseId: state.responseId,
+    };
+  }
+  if (!normalized.message.content && state.text) {
+    normalized.message.content = state.text;
+  }
+  if (!normalized.message._openaiReasoningSummary && state.reasoningSummary) {
+    normalized.message._openaiReasoningSummary = state.reasoningSummary.slice(
+      0,
+      MAX_REASONING_SUMMARY_CHARS,
+    );
+  }
+  return normalized;
+}
+
+export function accumulateOpenAIResponsesStream(lines, onToken, onThinking) {
+  const state = createOpenAIResponsesStreamState();
+  for (const line of lines) {
+    reduceOpenAIResponsesStreamLine(state, line, onToken, onThinking);
+  }
+  return finalizeOpenAIResponsesStream(state);
+}

package/src/lib/plugin-runtime/scopes.js

@@ -226,7 +226,13 @@ export function discoverPlugins(opts = {}) {
   ) {
     return [];
   }
-  const requestedScopes = new Set(opts.scopes || SCOPES);
+  const envScopes = String((opts.env || process.env).CC_PLUGIN_SCOPES || "")
+    .split(",")
+    .map((scope) => scope.trim())
+    .filter(Boolean);
+  const requestedScopes = new Set(
+    opts.scopes || (envScopes.length > 0 ? envScopes : SCOPES),
+  );
   for (const requested of requestedScopes) {
     if (!SCOPES.includes(requested)) {
       throw new Error(`unknown plugin scope: ${requested}`);

package/src/lib/remote-read-loop-guard.js

@@ -387,7 +387,7 @@ export class RemoteReadLoopGuard {
         "For git-tool-reroute, call the dedicated git tool with git arguments and the repository cwd, without the leading git, pipes or 2>&1. " +
         "If the dedicated tool fails, inspect its actual stderr and verify cwd/remotes before continuing. " +
         "For a policy denial with no authorized route, report the exact blocker and completed findings; the task is not complete. " +
-        "Do not relax permissions or reroute through run_code to bypass policy."
+        "Keep execution permissions unchanged and use only authorized tool routes. Respect the execution policy; when it denies the command, stop and report the blocked action."
       );
     }
     if (this.targets.get(this.activeKey)?.gitRepository) {
@@ -406,7 +406,7 @@ export class RemoteReadLoopGuard {
         "Inspect stdout/stderr for command errors first. gh pr --json uses state and mergedAt, not merged; " +
         "use gh pr list --help or gh pr view --help to check supported fields. " +
         "If metadata is missing, request gh pr view <number> --repo <owner/repo> --json number,title,state,mergedAt,headRefOid,baseRefOid once. " +
-        "For a shell-policy git reroute, use the dedicated git tool with command arguments only (no leading git, pipes, or 2>&1); do not retry the shell command or bypass policy. " +
+        "For a shell-policy git reroute, use the dedicated git tool with command arguments only (no leading git, pipes, or 2>&1). Respect the execution policy; when it denies the command, stop and report the blocked action. " +
         "Compare the specific PR diff/commits with the target branch to decide the requested fix or disposition. " +
         "For review, synthesize evidence-backed findings; do not create edits merely to reset the loop. " +
         "Perform only already-authorized PR actions. If a required fact or authorization remains unavailable, report the concrete blocker and useful findings. " +

package/src/lib/runtime-usage-ledger.js

@@ -122,6 +122,22 @@ export function projectRuntimeTokenUsage(event = {}) {
       required: index < 2,
     });
   }
+  if (
+    Object.hasOwn(event.usage, "reasoning_tokens") ||
+    Object.hasOwn(event.usage, "reasoningTokens")
+  ) {
+    const reasoningTokens = tokenCount(
+      event.usage,
+      "reasoning_tokens",
+      "reasoningTokens",
+    );
+    if (reasoningTokens > usage.output_tokens) {
+      throw new TypeError(
+        "runtime reasoning token usage exceeds output tokens",
+      );
+    }
+    usage.reasoning_tokens = reasoningTokens;
+  }
   if (Object.hasOwn(event.usage, "total_tokens")) {
     const total = event.usage.total_tokens;
     if (

package/src/lib/skill-loader.js

@@ -32,6 +32,10 @@ import { normalizeSkillPaths } from "./skill-path-scope.js";
 import { discoverPluginSkillLayers } from "./plugin-runtime/skills.js";
 import settingsLoader from "./settings-loader.cjs";
 import contextSourceLedger from "./context-source-ledger.js";
+import {
+  bindSkillRuntimeAdmission,
+  assertSkillRuntimeAdmission,
+} from "./evolution/skill-runtime-revalidation.js";
 import {
   createAbortError,
   isAbortError,
@@ -375,6 +379,8 @@ export class CLISkillLoader {
     contextLedger = contextSourceLedger,
     reauthorizeSkill = null,
     executionAuthority = null,
+    skillRuntimeAdmission = null,
+    skillRuntimeAdmissionRequired = false,
     limits = {},
     // Only package-owned, immutable-at-install sources are trusted by
     // default. The historical "managed" layer is actually the user-writable
@@ -386,6 +392,9 @@ export class CLISkillLoader {
       throw new TypeError("reauthorizeSkill must be a function or null");
     }
     this._cache = null;
+    bindSkillRuntimeAdmission(this, skillRuntimeAdmission, {
+      required: skillRuntimeAdmissionRequired,
+    });
     this._bodyCache = new Map();
     this._contextLedger = contextLedger;
     this._reauthorizeSkill = reauthorizeSkill;
@@ -653,6 +662,7 @@ export class CLISkillLoader {
   }
 
   async materializeSkillForExecution(skill, context = {}) {
+    assertSkillRuntimeAdmission({ skill, loader: this, context });
     const executionLease = this.acquireSkillExecution(skill, {
       signal: context.signal,
     });
@@ -918,6 +928,7 @@ export class CLISkillLoader {
    * size/mtime metadata, and provenance records never include source content.
    */
   materializeSkill(skill, context = {}) {
+    assertSkillRuntimeAdmission({ skill, loader: this, context });
     throwIfAborted(
       context.signal,
       "Skill execution materialization was interrupted",
@@ -1118,6 +1129,7 @@ export class CLISkillLoader {
     } catch {
       // Context observability must never make a valid skill unloadable.
     }
+    assertSkillRuntimeAdmission({ skill, loader: this, context });
     return skill;
   }
 

package/src/lib/with-file-lock.js

@@ -22,7 +22,7 @@
  * lock convoys.
  *
  * @param {string} targetPath  the file being guarded (lock is `${targetPath}.lock`)
- * @param {(ctx:{locked:boolean,publishReleaseAfterPathRemoved:(pendingPath:string)=>boolean})=>T} fn
+ * @param {(ctx:{locked:boolean,waitMs:number,attempts:number,publishReleaseAfterPathRemoved:(pendingPath:string)=>boolean})=>T} fn
  *   critical section; `publishReleaseAfterPathRemoved` lets a transaction
  *   publish an exact, contender-completable handoff before its final atomic
  *   rename removes a uniquely named staging path
@@ -188,6 +188,8 @@ export function withFileLock(targetPath, fn, opts = {}) {
   try {
     result = fn({
       locked: held,
+      waitMs: Math.max(0, _now() - owner.startedAt),
+      attempts: retryAttempt + 1,
       publishReleaseAfterPathRemoved(pendingPath) {
         if (!held || typeof pendingPath !== "string" || !pendingPath) {
           return false;

package/src/repl/agent-repl.js

@@ -25,6 +25,7 @@ import path from "path";
 import { createHash, randomUUID } from "node:crypto";
 import { isPromise, isProxy } from "node:util/types";
 import { logger } from "../lib/logger.js";
+import { captureSkillRuntimeDependencies } from "../lib/evolution/skill-runtime-revalidation.js";
 import { captureAmbientExecutionLocation } from "../lib/execution-location-runtime.js";
 import { issueMcpStdioExecutionAuthority } from "../lib/mcp-stdio-execution-authority.js";
 import { getPlanModeManager, PlanState } from "../lib/plan-mode.js";
@@ -4076,7 +4077,9 @@ async function startAgentReplInWorkspaceOwned(
   let _loadedReplInstructions = null;
   let _loadedReplPersonaSkills = [];
   let _replSkillCacheLedger = null;
-  const _replSkillLoader = options.skillLoader || new CLISkillLoader();
+  const _replSkillLoader =
+    options.skillLoader ||
+    new CLISkillLoader(captureSkillRuntimeDependencies(options));
   const _buildReplBaseSystem = () =>
     composeSystemPrompt(
       buildSystemPrompt(process.cwd(), {
@@ -9612,6 +9615,7 @@ async function startAgentReplInWorkspaceOwned(
         usageEvents,
         thinking: reasoning,
       } = await agentLoop(messages, {
+        ...captureSkillRuntimeDependencies(options),
         ...liveOpts,
         waitForOutput: _replOutputFlow.wait,
         mergeRoles: _mergeRolesThisTurn,