@bitkyc08/opencodex 2.19.0 → 2.21.0

package/src/adapters/responses-tool-schema.ts

@@ -0,0 +1,67 @@
+// Codex multi-agent v2 stamps a Responses-only `encrypted: true` marker on
+// collaboration tool schemas (openai/codex 5f4d06ef; issue #85). It is an
+// annotation for the ChatGPT backend only, so translated provider schemas must
+// drop it without removing properties or definitions literally named `encrypted`.
+const ENCRYPTED_MARKER_NAME_BAG_KEYS = new Set([
+  "properties",
+  "patternProperties",
+  "$defs",
+  "definitions",
+  "dependencies",
+  "dependentSchemas",
+  "dependentRequired",
+]);
+const ENCRYPTED_MARKER_LITERAL_VALUE_KEYS = new Set(["const", "default", "enum", "examples"]);
+
+/**
+ * The schema is caller-supplied, so its nesting depth is attacker-influenced. Native recursion
+ * would turn a deep schema into a stack overflow that takes down the request path, so this walks
+ * an explicit stack instead: depth costs heap, which is bounded and recoverable.
+ */
+export function stripResponsesOnlyEncryptedMarker(node: unknown, inNameBag = false): unknown {
+  type Assign = (value: unknown) => void;
+  interface Frame { node: unknown; inNameBag: boolean; assign: Assign }
+
+  let result: unknown;
+  const stack: Frame[] = [{ node, inNameBag, assign: value => { result = value; } }];
+
+  while (stack.length > 0) {
+    const frame = stack.pop()!;
+    const current = frame.node;
+
+    if (Array.isArray(current)) {
+      const out: unknown[] = new Array(current.length);
+      frame.assign(out);
+      // Array items are schemas in their own right, never a name bag.
+      for (let i = current.length - 1; i >= 0; i--) {
+        stack.push({ node: current[i], inNameBag: false, assign: value => { out[i] = value; } });
+      }
+      continue;
+    }
+    if (!current || typeof current !== "object") {
+      frame.assign(current);
+      continue;
+    }
+
+    // A schema name may be `__proto__`; a null-prototype record keeps it as data.
+    const out: Record<string, unknown> = Object.create(null) as Record<string, unknown>;
+    frame.assign(out);
+
+    for (const [key, value] of Object.entries(current as Record<string, unknown>)) {
+      if (frame.inNameBag) {
+        // Inside a name bag every key is a caller-chosen name, so `encrypted` here is data.
+        stack.push({ node: value, inNameBag: false, assign: v => { out[key] = v; } });
+      } else if (key !== "encrypted") {
+        if (ENCRYPTED_MARKER_LITERAL_VALUE_KEYS.has(key)) {
+          // Literal payloads are values, not schemas: an `encrypted` key inside them is data.
+          out[key] = value;
+        } else {
+          const childInNameBag = ENCRYPTED_MARKER_NAME_BAG_KEYS.has(key);
+          stack.push({ node: value, inNameBag: childInNameBag, assign: v => { out[key] = v; } });
+        }
+      }
+    }
+  }
+
+  return result;
+}

package/src/bridge.ts

@@ -2,6 +2,7 @@ import type {
   AdapterEvent,
   OcxMessagePhase,
   OcxProviderContinuationState,
+  OcxProviderOpaqueToolCallMetadata,
   OcxReasoningReplayScopeRef,
   OcxUsage,
 } from "./types";
@@ -10,6 +11,7 @@ import { adapterFailureFromMessage, classifyError, CYBER_POLICY_ERROR_CODE, isCy
 import { encodeCompactionSummary } from "./responses/compaction";
 import { encodeReasoningEnvelope, type ReasoningEnvelope } from "./responses/reasoning-envelope";
 import { rememberReasoningForCall } from "./responses/reasoning-replay-cache";
+import { responsesExtraContentFromProviderMetadata } from "./responses/provider-opaque-metadata";
 import { resolveStallTimeoutSec } from "./stall-timeout";
 import { usageDisplayTotalTokens } from "./usage/totals";
 import {
@@ -496,7 +498,7 @@ export function bridgeToResponsesSSE(
       // synthetic compaction item's payload on done.
       let compactionText = "";
       let compactionTextBytes = 0;
-      let currentToolCall: { itemId: string; outputIndex: number; callId: string; name: string; args: string; argsBytes: number; namespace?: string; freeform?: boolean; toolSearch?: boolean; inputEmitted?: string } | null = null;
+      let currentToolCall: { itemId: string; outputIndex: number; callId: string; name: string; args: string; argsBytes: number; namespace?: string; freeform?: boolean; toolSearch?: boolean; inputEmitted?: string; providerMetadata?: OcxProviderOpaqueToolCallMetadata } | null = null;
       // Open native web-search cell (between begin and end). Holds the output index allocated on
       // begin so the matching done reuses it; closed as `failed` if the stream terminates early.
       let currentWebSearch: { itemId: string; eventId: string; outputIndex: number } | null = null;
@@ -621,6 +623,9 @@ export function bridgeToResponsesSSE(
               call_id: currentToolCall.callId, name: currentToolCall.name,
               arguments: argsStr, status: "completed",
               ...(currentToolCall.namespace ? { namespace: currentToolCall.namespace } : {}),
+              // Provider-opaque metadata (issue #1735) rides the item so a client that replays
+              // this history can hand the signature back on the part it belongs to.
+              ...(responsesExtraContentFromProviderMetadata(currentToolCall.providerMetadata) ?? {}),
             };
         emit("response.output_item.done", { output_index: currentToolCall.outputIndex, item });
         retainFinishedItem(item as OutputItem);
@@ -655,6 +660,10 @@ export function bridgeToResponsesSSE(
               call_id: currentToolCall.callId, name: currentToolCall.name,
               arguments: argsStr, status: "incomplete",
               ...(currentToolCall.namespace ? { namespace: currentToolCall.namespace } : {}),
+              // An incomplete call can still be persisted and replayed (max_output_tokens), so it
+              // carries the same metadata as the completed item — otherwise SSE and buffered JSON
+              // would disagree about whether the signature survives.
+              ...(responsesExtraContentFromProviderMetadata(currentToolCall.providerMetadata) ?? {}),
             };
         emit("response.output_item.done", { output_index: currentToolCall.outputIndex, item });
         retainFinishedItem(item as OutputItem);
@@ -1013,7 +1022,7 @@ export function bridgeToResponsesSSE(
                 ? { type: "custom_tool_call", id: itemId, call_id: event.id, name: realName, input: "", status: "in_progress" }
                 : { type: "function_call", id: itemId, call_id: event.id, name: realName, arguments: "", status: "in_progress", ...(ns ? { namespace: ns } : {}) };
               emit("response.output_item.added", { output_index: outputIndex, item });
-              currentToolCall = { itemId, outputIndex, callId: event.id, name: realName, args: "", argsBytes: 0, namespace: ns, freeform, toolSearch };
+              currentToolCall = { itemId, outputIndex, callId: event.id, name: realName, args: "", argsBytes: 0, namespace: ns, freeform, toolSearch, providerMetadata: event.providerMetadata };
               budget?.openCall(event.id);
               break;
             }
@@ -1476,6 +1485,7 @@ function buildResponseJSONWithBudget(
   let currentToolCallId = "";
   let currentToolCallName = "";
   let currentToolCallArgs = "";
+  let currentToolCallProviderMetadata: OcxProviderOpaqueToolCallMetadata | undefined;
   let currentToolCallArgsBytes = 0;
   // Web-search citations awaiting the next assistant message (attached as url_citation annotations).
   let pendingWebSources: { url: string; title?: string }[] = [];
@@ -1584,11 +1594,13 @@ function buildResponseJSONWithBudget(
         call_id: currentToolCallId, name: realName,
         arguments: coercedArgs || "{}", status,
         ...(ns ? { namespace: ns } : {}),
+        ...(responsesExtraContentFromProviderMetadata(currentToolCallProviderMetadata) ?? {}),
       });
     }
     budget?.closeCall(currentToolCallId);
     currentToolCallId = "";
     currentToolCallName = "";
+    currentToolCallProviderMetadata = undefined;
     currentToolCallArgs = "";
     currentToolCallArgsBytes = 0;
   };
@@ -1703,6 +1715,7 @@ function buildResponseJSONWithBudget(
         currentToolCallName = e.name;
         currentToolCallArgs = "";
         currentToolCallArgsBytes = 0;
+        currentToolCallProviderMetadata = e.providerMetadata;
         break;
       case "tool_call_delta":
         {

package/src/chat/inbound.ts

@@ -8,11 +8,23 @@
 export class ChatCompletionsRequestError extends Error {}
 
 type Rec = Record<string, unknown>;
+type ChatCompletionsRoutingBody = Rec & { model: string; messages: unknown[] };
 
 function isRec(v: unknown): v is Rec {
   return !!v && typeof v === "object" && !Array.isArray(v);
 }
 
+/** Validate only the fields needed before Chat routing, without projecting the body. */
+export function assertChatCompletionsRoutingBody(raw: unknown): asserts raw is ChatCompletionsRoutingBody {
+  if (!isRec(raw)) throw new ChatCompletionsRequestError("request body must be a JSON object");
+  if (typeof raw.model !== "string" || raw.model.length === 0) {
+    throw new ChatCompletionsRequestError("model is required");
+  }
+  if (!Array.isArray(raw.messages) || raw.messages.length === 0) {
+    throw new ChatCompletionsRequestError("messages must be a non-empty array");
+  }
+}
+
 const OUTPUT_CONFIG_EFFORTS = new Set(["minimal", "low", "medium", "high", "xhigh", "max", "ultra"]);
 const OUTPUT_CONFIG_SUMMARIES = new Set(["auto", "concise", "detailed", "none"]);
 
@@ -227,13 +239,7 @@ function resolveReasoningSummary(raw: Rec): string | undefined {
  * Throws ChatCompletionsRequestError (-> 400) on malformed input.
  */
 export function chatCompletionsToResponsesBody(raw: unknown): Rec {
-  if (!isRec(raw)) throw new ChatCompletionsRequestError("request body must be a JSON object");
-  if (typeof raw.model !== "string" || raw.model.length === 0) {
-    throw new ChatCompletionsRequestError("model is required");
-  }
-  if (!Array.isArray(raw.messages) || raw.messages.length === 0) {
-    throw new ChatCompletionsRequestError("messages must be a non-empty array");
-  }
+  assertChatCompletionsRoutingBody(raw);
 
   const systemParts: string[] = [];
   const input: Rec[] = [];

package/src/claude/gateway-cache.ts

@@ -13,12 +13,21 @@
 import { mkdirSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
+import { loadServiceTokenFromFile, serviceApiTokenFilePath } from "../lib/service-secrets";
+import type { OcxConfig } from "../types";
 
 export interface GatewayModelRow {
   id: string;
   display_name?: string;
 }
 
+export interface GatewayModelCacheRefreshOptions {
+  timeoutMs?: number;
+  configDir?: string;
+  admissionConfig?: Pick<OcxConfig, "apiKeys">;
+  env?: NodeJS.ProcessEnv;
+}
+
 /** Claude Code config dir (CLAUDE_CONFIG_DIR override honored, like the CLI). */
 export function claudeConfigDir(): string {
   const custom = process.env.CLAUDE_CONFIG_DIR;
@@ -45,14 +54,42 @@ export function writeGatewayModelCache(baseUrl: string, models: readonly Gateway
   }
 }
 
+/**
+ * Hardened service-token file, the same precedence `ocx opencode` uses. A service
+ * install writes the admission token to disk rather than the interactive environment,
+ * so an interactive `ocx claude` with neither env token nor configured key would
+ * otherwise still get a 401 and keep a stale picker list.
+ */
+function serviceFileToken(env: NodeJS.ProcessEnv): string | null {
+  const lookup = env.OCX_API_TOKEN_FILE?.trim()
+    ? env
+    : { ...env, OCX_API_TOKEN_FILE: serviceApiTokenFilePath() };
+  return loadServiceTokenFromFile(lookup as Record<string, string | undefined>);
+}
+
 /** Fetch the anthropic-flavor /v1/models from the local proxy and write the cache. */
-export async function refreshGatewayModelCacheFromProxy(port: number, timeoutMs = 3_000, configDir?: string): Promise<string | null> {
+export async function refreshGatewayModelCacheFromProxy(
+  port: number,
+  options: GatewayModelCacheRefreshOptions = {},
+): Promise<string | null> {
   try {
+    const headers = new Headers({ "anthropic-version": "2023-06-01" });
+    // A wildcard/non-loopback listener requires data-plane admission even for a
+    // request sent to its local 127.0.0.1 address. Reuse the same dedicated
+    // credential domain as /v1/models admission; never place it in Authorization,
+    // which can belong to an upstream provider on other data-plane surfaces.
+    const envToken = (options.env ?? process.env).OPENCODEX_API_AUTH_TOKEN?.trim();
+    const configuredToken = options.admissionConfig?.apiKeys
+      ?.find(entry => entry.key.trim().length > 0)
+      ?.key.trim();
+    const admissionToken = envToken || serviceFileToken(options.env ?? process.env) || configuredToken;
+    if (admissionToken) headers.set("x-opencodex-api-key", admissionToken);
+
     // ?ids=cli pins the readable claude-ocx id family deterministically (audit 051
     // #5): the cache prewrite must not depend on UA sniffing.
     const res = await fetch(`http://127.0.0.1:${port}/v1/models?limit=1000&ids=cli`, {
-      headers: { "anthropic-version": "2023-06-01" },
-      signal: AbortSignal.timeout(timeoutMs),
+      headers,
+      signal: AbortSignal.timeout(options.timeoutMs ?? 3_000),
     });
     if (!res.ok) return null;
     const body = await res.json() as { data?: unknown };
@@ -63,7 +100,7 @@ export async function refreshGatewayModelCacheFromProxy(port: number, timeoutMs
         id: m.id as string,
         display_name: typeof m.display_name === "string" ? m.display_name : undefined,
       }));
-    return writeGatewayModelCache(`http://127.0.0.1:${port}`, models, configDir);
+    return writeGatewayModelCache(`http://127.0.0.1:${port}`, models, options.configDir);
   } catch {
     return null;
   }

package/src/cli/claude.ts

@@ -19,6 +19,7 @@ import { configuredAdminToken } from "../lib/admin-secrets";
 import { PROXY_MARKER, ownAdmissionTokens, defaultAuthDetectDeps, detectClaudeAuth, type AuthDetectDeps } from "../claude/auth-detect";
 import { resolveClaudeAuthMode } from "../claude/auth-mode";
 import { withProcessRuntimeProvenance } from "../lib/bun-runtime";
+import { selfLaunchArgv } from "../lib/self-launch-argv";
 import { ANTHROPIC_PARENT_ENV_SLOTS, trustedNodeLauncherContext, type AnthropicParentEnvSlot } from "./launcher-context";
 
 export interface ClaudeLaunchEnv {
@@ -269,7 +270,7 @@ async function ensureProxyForClaude(): Promise<number | null> {
   if (live) return live.port;
   const cfgPort = loadConfig().port;
   const pinPort = typeof cfgPort === "number" && cfgPort > 0 ? cfgPort : 10100;
-  const child = spawn(process.execPath, [process.argv[1], "start", "--port", String(pinPort)], {
+  const child = spawn(process.execPath, selfLaunchArgv(["start", "--port", String(pinPort)]), {
     detached: true,
     stdio: "ignore",
     windowsHide: true,
@@ -316,7 +317,7 @@ export async function cmdClaude(args: string[]): Promise<number> {
   // Pre-write the CLI's gateway-model cache (devlog 030): without a token the CLI
   // never refreshes it, so the picker would keep showing yesterday's aliases.
   try {
-    const cachePath = await refreshGatewayModelCacheFromProxy(port);
+    const cachePath = await refreshGatewayModelCacheFromProxy(port, { admissionConfig: config });
     if (cachePath === null) {
       console.error("⚠ Gateway model cache could not be refreshed; the model picker may be stale.");
     }

package/src/cli/combo.ts

@@ -91,6 +91,9 @@ async function set(argv: string[], deps: RuntimeApiDeps): Promise<void> {
   if (alias !== undefined) combo.alias = alias === "-" ? "" : alias;
   if (nativeAlias) combo.nativeAlias = true;
   if (displayName !== undefined) combo.displayName = displayName === "-" ? "" : displayName;
+  const current = await runtimeRequest<{ combos?: ComboRow[] }>("/api/combos", {}, deps);
+  const existing = (current.combos ?? []).find(row => row.id === (renameFrom ?? id));
+  if (existing?.imageInput === "disabled") combo.imageInput = "disabled";
   const result = await runtimeRequest("/api/combos", {
     method: "PUT",
     body: JSON.stringify({ id, combo, ...(renameFrom ? { renameFrom } : {}) }),

package/src/cli/dispatch.ts

@@ -488,6 +488,14 @@ const commandRunners: Record<string, CommandRunner> = {
     const { cmdOpencode } = await import("./opencode");
     return await cmdOpencode(deps.args.slice(1));
   },
+  mcode: async deps => {
+    const { cmdMcode } = await import("./minimax");
+    return await cmdMcode(deps.args.slice(1));
+  },
+  mmx: async deps => {
+    const { cmdMmx } = await import("./minimax");
+    return await cmdMmx(deps.args.slice(1));
+  },
   help: async () => {
     printUsage();
     return 0;

package/src/cli/export-command.ts

@@ -1,8 +1,8 @@
 /**
  * `ocx export --client <id>` — print a client config for the live proxy.
  *
- * Seven clients, four formats: opencode and Pi are JSON, OMP, Hermes and Gajae
- * are YAML, OpenClaw JSON5, Kimi TOML.
+ * Eight clients, four formats: OpenCode and Pi are JSON; OMP, Hermes, Gajae and
+ * MiniMax Code are YAML; OpenClaw is JSON5; Kimi is TOML.
  *
  * Two consumers, one payload (devlog 260731_client_config_export/020):
  *

package/src/cli/help.ts

@@ -67,6 +67,8 @@ Usage:
   ocx claude [args...]        Launch Claude Code wired to the proxy (model discovery on)
   ocx claude desktop [sub]    Manage and apply Claude Desktop's four-family profile
   ocx opencode [args...]      Launch opencode wired to the proxy (runtime provider config)
+  ocx mcode [args...]         Launch MiniMax Code through its managed provider
+  ocx mmx text <sub> [args]   Launch MiniMax CLI text through the proxy
   ocx help [command]          Show help
   ocx --version | -v          Print version
 

package/src/cli/index.ts

@@ -60,6 +60,7 @@ import { setIntegrationEnabled, shouldSyncCodexOnStart, shouldSyncGrokOnStart, s
 
 import { removeOwnedConfigState } from "../lib/config-ownership";
 import { withProcessRuntimeProvenance } from "../lib/bun-runtime";
+import { selfLaunchArgv } from "../lib/self-launch-argv";
 import { initializeNodeLauncherContext } from "./launcher-context";
 import { createLocalAttestationSecret } from "../lib/local-management-attestation";
 import { MEMORY_DRAIN_RESTART_MS, REPLACEMENT_READY_TIMEOUT_MS } from "../lib/system-restart-contract";
@@ -121,11 +122,11 @@ function grokSyncFailureMessage(err: unknown): string {
 
 /** Argv for detached `start`, optionally hard-pinning the listen port. */
 function startArgv(port?: number): string[] {
-  const args = [process.argv[1], "start"];
+  const args = ["start"];
   if (typeof port === "number" && Number.isFinite(port) && port > 0 && port <= 65535) {
     args.push("--port", String(Math.trunc(port)));
   }
-  return args;
+  return selfLaunchArgv(args);
 }
 
 async function chooseListenPort(requestedPort?: number): Promise<number> {

package/src/cli/lab.ts

@@ -36,6 +36,7 @@ import {
   queryPassiveProductionSignals,
   type PassiveProductionQueryResultV1,
 } from "../lab/query";
+import { isLabRouteSubjectId } from "../usage/log";
 import {
   CliUsageError,
   RuntimeApiError,
@@ -63,6 +64,14 @@ import { planManualLabRun } from "../lab/automation/planner";
 import { listLabAutomationRuns } from "../lab/automation/runs-query";
 import { LabAutomationError, type LabAutomationLayer } from "../lab/automation/types";
 import { createProductionLabRouteExecutor } from "../lib/lab-live-route-production";
+import {
+  exportLocalPublicEvidence,
+  importCommunityEvidenceFile,
+  listCommunityEvidenceContext,
+  previewLocalPublicEvidence,
+  verifyPublicEvidenceFile,
+  type PublicVerificationSummaryV1,
+} from "../lab/public";
 
 const USAGE = `Usage:
   ocx lab status [--json]
@@ -76,6 +85,11 @@ const USAGE = `Usage:
   ocx lab artifacts [--status <s>] [--artifact-class <c>] [--limit <n>] [--cursor <c>] [--json]
   ocx lab artifact <digest> [--json]
   ocx lab catalog [--layer <layer>] [--suite <id>] [--json]
+  ocx lab public preview --event <eventId> [--event <eventId> ...] [--json]
+  ocx lab public export --event <eventId> [--event <eventId> ...] [--json]
+  ocx lab public verify --file <bundle.json> [--json]
+  ocx lab public import --file <bundle.json> [--json]
+  ocx lab public community [--json]
   ocx lab automation status [--json]
   ocx lab automation enable [--protocol] [--live] [--json]
   ocx lab automation disable [--json]
@@ -223,6 +237,119 @@ function runListLines(page: ReturnType<typeof listLabAutomationRuns>): string[]
   return lines.length > 0 ? lines : ["No automation runs"];
 }
 
+function takeRepeatedOptions(args: string[], flag: string): string[] {
+  const values: string[] = [];
+  while (true) {
+    const index = args.indexOf(flag);
+    if (index < 0) break;
+    const value = args[index + 1];
+    if (!value || value.startsWith("--")) {
+      throw new CliUsageError(`${flag} requires a value`, USAGE);
+    }
+    values.push(value);
+    args.splice(index, 2);
+  }
+  return values;
+}
+
+function publicPreviewLines(result: ReturnType<typeof previewLocalPublicEvidence>): string[] {
+  return [
+    `Public evidence preview: ${result.bundle.records.length} exportable record(s)`,
+    `Excluded: ${result.excluded.length}`,
+    "Unsigned local preview; no publisher key or remote publish is created.",
+  ];
+}
+
+function publicExportLines(result: ReturnType<typeof exportLocalPublicEvidence>): string[] {
+  return [
+    "Public evidence exported locally",
+    `Bundle: ${result.bundle.bundleId}`,
+    `Publisher: ${result.bundle.publisher.keyId}`,
+    `Path: ${result.stored.path}`,
+    `Excluded: ${result.excluded.length}`,
+    "No remote publish occurred.",
+  ];
+}
+
+function publicVerificationLines(result: PublicVerificationSummaryV1): string[] {
+  if (result.status !== "cryptographically_valid") {
+    return [
+      `Public evidence verification: ${result.status}`,
+      "Not locally verified.",
+    ];
+  }
+  return [
+    "Public evidence verification: cryptographically valid",
+    `Bundle: ${result.bundleId}`,
+    `Publisher: ${result.publisherKeyId}`,
+    "Not locally verified. Signature validity proves integrity/continuity only.",
+  ];
+}
+
+function handlePublicLabCommand(
+  argv: string[],
+  wantsJson: boolean,
+  configDir: string,
+): void {
+  const [action, ...restInput] = argv;
+  const rest = [...restInput];
+  switch (action) {
+    case "preview": {
+      const eventIds = takeRepeatedOptions(rest, "--event");
+      rejectArgs(rest, USAGE);
+      const result = previewLocalPublicEvidence({ eventIds }, configDir);
+      printData(result, wantsJson, publicPreviewLines(result));
+      return;
+    }
+    case "export": {
+      const eventIds = takeRepeatedOptions(rest, "--event");
+      rejectArgs(rest, USAGE);
+      const result = exportLocalPublicEvidence({ eventIds }, configDir);
+      printData(result, wantsJson, publicExportLines(result));
+      return;
+    }
+    case "verify": {
+      const path = takeOption(rest, "--file");
+      if (!path) throw new CliUsageError("public verify requires --file", USAGE);
+      rejectArgs(rest, USAGE);
+      const result = verifyPublicEvidenceFile(path);
+      printData(result, wantsJson, publicVerificationLines(result));
+      if (result.status !== "cryptographically_valid") {
+        throw new RuntimeApiError(`public evidence verification failed: ${result.status}`, 422, result);
+      }
+      return;
+    }
+    case "import": {
+      const path = takeOption(rest, "--file");
+      if (!path) throw new CliUsageError("public import requires --file", USAGE);
+      rejectArgs(rest, USAGE);
+      const result = importCommunityEvidenceFile(path, configDir);
+      printData(result, wantsJson, [
+        `Community evidence imported: ${result.bundleId}`,
+        `Publisher: ${result.publisherKeyId}`,
+        "Trust: community_untrusted_v1; not locally verified.",
+      ]);
+      return;
+    }
+    case "community": {
+      rejectArgs(rest, USAGE);
+      const result = listCommunityEvidenceContext(configDir);
+      const lines = result.evidence.length > 0
+        ? result.evidence.map((row) =>
+          `${row.bundleId} publisher=${row.publisherKeyId} active=${row.activeRecordCount} revoked=${row.revokedRecordCount}`,
+        )
+        : ["No community evidence"];
+      printData(result, wantsJson, [
+        "Community evidence (untrusted, read-only context; not locally verified)",
+        ...lines,
+      ]);
+      return;
+    }
+    default:
+      throw new CliUsageError("unknown public subcommand", USAGE);
+  }
+}
+
 export async function handleLabCommand(argv: string[], deps: LabCliDeps = {}): Promise<number> {
   return runCliAction(async () => {
     const configDir = deps.configDir ?? getConfigDir();
@@ -232,6 +359,10 @@ export async function handleLabCommand(argv: string[], deps: LabCliDeps = {}): P
 
     try {
       switch (sub) {
+        case "public": {
+          handlePublicLabCommand(rest, wantsJson, configDir);
+          return;
+        }
         case "status": {
           rejectArgs(rest, USAGE);
           const status = queryLabStatus(configDir);
@@ -243,6 +374,9 @@ export async function handleLabCommand(argv: string[], deps: LabCliDeps = {}): P
           const limit = takeIntegerOption(rest, "--limit", { min: 1 });
           rejectArgs(rest, USAGE);
           if (!subjectId) throw new CliUsageError("--subject is required", USAGE);
+          if (!isLabRouteSubjectId(subjectId)) {
+            throw new CliUsageError("--subject must be an exact Lab route subject id", USAGE);
+          }
           const result = queryPassiveProductionSignals(subjectId, limit, configDir);
           printData(result, wantsJson, passiveProductionLines(result));
           return;
@@ -461,7 +595,7 @@ export async function handleLabCommand(argv: string[], deps: LabCliDeps = {}): P
           throw new CliUsageError(`unknown lab subcommand: ${sub}`, USAGE);
       }
     } catch (err) {
-      if (err instanceof CliUsageError) throw err;
+      if (err instanceof CliUsageError || err instanceof RuntimeApiError) throw err;
       if (err instanceof LabProjectionUnavailableError || err instanceof LabProjectionIncompatibleError) {
         throw new LabStateError(labErrorMessage(err));
       }