@cjhyy/code-shell-core 0.7.0 → 0.8.0

package/dist/utils/lockfile.d.ts

@@ -8,8 +8,37 @@
  * Import this module instead of `proper-lockfile` directly. The underlying
  * package is only loaded the first time a lock function is actually called.
  */
-import type { CheckOptions, LockOptions, UnlockOptions } from 'proper-lockfile';
+interface LockRetryOptions {
+    retries?: number;
+    factor?: number;
+    minTimeout?: number;
+    maxTimeout?: number;
+    randomize?: boolean;
+    forever?: boolean;
+    unref?: boolean;
+    maxRetryTime?: number;
+}
+interface LockfilePathOptions {
+    realpath?: boolean;
+    /**
+     * proper-lockfile accepts a callback-style fs implementation. Keep this
+     * structural at the package boundary so Core's declarations do not leak the
+     * untyped CommonJS dependency to TypeScript consumers.
+     */
+    fs?: object;
+    lockfilePath?: string;
+}
+interface CheckOptions extends LockfilePathOptions {
+    stale?: number;
+}
+type UnlockOptions = LockfilePathOptions;
+interface LockOptions extends CheckOptions {
+    update?: number;
+    retries?: number | LockRetryOptions;
+    onCompromised?: (error: Error) => void;
+}
 export declare function lock(file: string, options?: LockOptions): Promise<() => Promise<void>>;
 export declare function lockSync(file: string, options?: LockOptions): () => void;
 export declare function unlock(file: string, options?: UnlockOptions): Promise<void>;
 export declare function check(file: string, options?: CheckOptions): Promise<boolean>;
+export {};

package/dist/utils/lockfile.js

@@ -8,7 +8,7 @@
  * Import this module instead of `proper-lockfile` directly. The underlying
  * package is only loaded the first time a lock function is actually called.
  */
-import { createRequire } from 'node:module';
+import { createRequire } from "node:module";
 // proper-lockfile is CommonJS. This module compiles to ESM (tsc module: ESNext,
 // package "type":"module"), and `require` is NOT a global in ESM — under the
 // Electron main process (an ESM bundle that loads core as an external ESM dep)
@@ -19,7 +19,7 @@ const nodeRequire = createRequire(import.meta.url);
 let _lockfile;
 function getLockfile() {
     if (!_lockfile) {
-        _lockfile = nodeRequire('proper-lockfile');
+        _lockfile = nodeRequire("proper-lockfile");
     }
     return _lockfile;
 }

package/dist/utils/secret-scrubber.d.ts

@@ -0,0 +1,8 @@
+/** Content-level defense in depth for producers that forgot sensitive metadata. */
+export declare function scrubSecrets(text: string): string;
+/**
+ * Recursively scrub JSON-like structured values with key-aware redaction.
+ * Sensitive keys redact their complete value; ordinary strings retain the
+ * free-form defense-in-depth scrub used for logs and tool-result text.
+ */
+export declare function scrubSecretValue(value: unknown): unknown;

package/dist/utils/secret-scrubber.js

@@ -0,0 +1,227 @@
+const SECRET_KEY_SOURCE = "(?:(?:access|refresh|auth|id|bearer|session)[_-]?token|token|api[_-]?key|password|passwd|client[_-]?secret|secret|private[_-]?key|aws[_-]?secret[_-]?access[_-]?key|aws[_-]?access[_-]?key[_-]?id|authorization|bearer)";
+const STRUCTURED_SECRET_RE = new RegExp(`(^|[{,\\[])([ \\t]*(?:-[ \\t]+)?)(["']?)(${SECRET_KEY_SOURCE})\\3([ \\t]*:[ \\t]*)`, "gimu");
+const ARGV_SECRET_RE = new RegExp(`((?:"--${SECRET_KEY_SOURCE}"|'--${SECRET_KEY_SOURCE}')[ \\t\\r\\n]*,[ \\t\\r\\n]*)("(?:\\\\.|[^"\\\\\\r\\n])*"|'(?:\\\\.|[^'\\\\\\r\\n])*')`, "giu");
+const CLI_SECRET_RE = new RegExp(`((?:^|[\\s"'\`])--${SECRET_KEY_SOURCE}(?:[ \\t]*=[ \\t]*|(?:[ \\t]+|\\\\\\r?\\n|\\r?\\n)+))` +
+    `("(?:\\\\.|[^"\\\\\\r\\n])*"|'(?:\\\\.|[^'\\\\\\r\\n])*'|(?:\\\\[^\\r\\n]|[^\\s"'\`;|&])+)`, "gimu");
+const SENSITIVE_NORMALIZED_KEYS = new Set([
+    "password",
+    "passwd",
+    "pwd",
+    "secret",
+    "token",
+    "apikey",
+    "authorization",
+    "auth",
+    "authheader",
+    "bearer",
+    "cookie",
+    "setcookie",
+    "accesstoken",
+    "refreshtoken",
+    "authtoken",
+    "idtoken",
+    "bearertoken",
+    "sessiontoken",
+    "clientsecret",
+    "privatekey",
+    "awssecretaccesskey",
+    "awsaccesskeyid",
+]);
+function isSensitiveKey(key) {
+    const normalized = key.toLowerCase().replace(/[^a-z0-9]/gu, "");
+    // Exact normalized words only. Suffix matching would erase legitimate
+    // design-system evidence such as designToken / color_token.
+    return SENSITIVE_NORMALIZED_KEYS.has(normalized);
+}
+function lineEnd(text, start) {
+    const newline = text.indexOf("\n", start);
+    if (newline < 0)
+        return text.length;
+    return newline > start && text[newline - 1] === "\r" ? newline - 1 : newline;
+}
+function quotedValueEnd(text, start) {
+    const quote = text[start];
+    for (let index = start + 1; index < text.length; index++) {
+        if (text[index] === "\\") {
+            index += 1;
+        }
+        else if (text[index] === quote) {
+            return index + 1;
+        }
+    }
+    return text.length;
+}
+function balancedValueEnd(text, start) {
+    const stack = [];
+    let quote = "";
+    for (let index = start; index < text.length; index++) {
+        const char = text[index];
+        if (quote) {
+            if (char === "\\")
+                index += 1;
+            else if (char === quote)
+                quote = "";
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            quote = char;
+        }
+        else if (char === "[" || char === "{") {
+            stack.push(char === "[" ? "]" : "}");
+        }
+        else if (char === stack.at(-1)) {
+            stack.pop();
+            if (stack.length === 0)
+                return index + 1;
+        }
+    }
+    return text.length;
+}
+function blockScalarEnd(text, valueStart, keyLineStart) {
+    const keyLineEnd = lineEnd(text, valueStart);
+    const indicator = text.slice(valueStart, keyLineEnd).trim();
+    if (!/^[>|](?:[+-]?[1-9]?|[1-9]?[+-]?)[ \t]*(?:#.*)?$/u.test(indicator)) {
+        return undefined;
+    }
+    const keyIndent = text.slice(keyLineStart).match(/^[ \t]*/u)?.[0].length ?? 0;
+    const newlineStart = keyLineEnd < text.length && text[keyLineEnd] === "\r" ? keyLineEnd : keyLineEnd;
+    const newlineEnd = text.indexOf("\n", newlineStart);
+    if (newlineEnd < 0)
+        return { end: text.length, replacement: "[REDACTED]" };
+    let blockEnd = newlineEnd + 1;
+    while (blockEnd < text.length) {
+        const nextEnd = lineEnd(text, blockEnd);
+        const line = text.slice(blockEnd, nextEnd);
+        const indent = line.match(/^[ \t]*/u)?.[0].length ?? 0;
+        if (line.trim() !== "" && indent <= keyIndent)
+            break;
+        const nextNewline = text.indexOf("\n", nextEnd);
+        if (nextNewline < 0)
+            return { end: text.length, replacement: "[REDACTED]" };
+        blockEnd = nextNewline + 1;
+    }
+    return {
+        end: blockEnd,
+        replacement: blockEnd < text.length ? "[REDACTED]\n" : "[REDACTED]",
+    };
+}
+function indentedContinuationEnd(text, currentLineEnd, keyIndent, allowSequenceItems) {
+    const newline = text.indexOf("\n", currentLineEnd);
+    if (newline < 0)
+        return undefined;
+    let nextLineStart = newline + 1;
+    let sawIndentedContent = false;
+    while (nextLineStart < text.length) {
+        const nextEnd = lineEnd(text, nextLineStart);
+        const line = text.slice(nextLineStart, nextEnd);
+        const indent = line.match(/^[ \t]*/u)?.[0].length ?? 0;
+        if (line.trim() !== "") {
+            if (/^[ \t]*[\w.-]+[ \t]*:(?:\s|$)/u.test(line))
+                break;
+            if (!allowSequenceItems && /^[ \t]*-[ \t]+/u.test(line))
+                break;
+            if (indent <= keyIndent)
+                break;
+            sawIndentedContent = true;
+        }
+        const nextNewline = text.indexOf("\n", nextEnd);
+        if (nextNewline < 0) {
+            nextLineStart = text.length;
+            break;
+        }
+        nextLineStart = nextNewline + 1;
+    }
+    if (!sawIndentedContent)
+        return undefined;
+    return {
+        end: nextLineStart,
+        replacement: nextLineStart < text.length ? "[REDACTED]\n" : "[REDACTED]",
+    };
+}
+function redactStructuredSecrets(text) {
+    STRUCTURED_SECRET_RE.lastIndex = 0;
+    let output = "";
+    let copiedThrough = 0;
+    let match;
+    while ((match = STRUCTURED_SECRET_RE.exec(text)) !== null) {
+        const valueStart = match.index + match[0].length;
+        if (valueStart >= text.length)
+            continue;
+        const keyLineStart = text.lastIndexOf("\n", match.index - 1) + 1;
+        const block = blockScalarEnd(text, valueStart, keyLineStart);
+        let valueEnd;
+        let replacement = "[REDACTED]";
+        if (block) {
+            valueEnd = block.end;
+            replacement = block.replacement;
+        }
+        else if (text[valueStart] === '"' || text[valueStart] === "'") {
+            valueEnd = quotedValueEnd(text, valueStart);
+        }
+        else if (text[valueStart] === "[" || text[valueStart] === "{") {
+            valueEnd = balancedValueEnd(text, valueStart);
+        }
+        else {
+            const endOfLine = lineEnd(text, valueStart);
+            const isFlowValue = match[1] !== "";
+            const flowBoundary = isFlowValue ? text.slice(valueStart, endOfLine).search(/[,}\]]/u) : -1;
+            const comment = text.slice(valueStart, endOfLine).search(/[ \t]#/u);
+            valueEnd = endOfLine;
+            if (flowBoundary >= 0)
+                valueEnd = valueStart + flowBoundary;
+            if (comment >= 0)
+                valueEnd = Math.min(valueEnd, valueStart + comment);
+            while (valueEnd > valueStart && /[ \t]/u.test(text[valueEnd - 1]))
+                valueEnd -= 1;
+            const continuation = isFlowValue
+                ? undefined
+                : indentedContinuationEnd(text, endOfLine, match.index + match[1].length + match[2].length - keyLineStart, valueStart === endOfLine);
+            if (continuation) {
+                valueEnd = continuation.end;
+                replacement = continuation.replacement;
+                if (valueStart === endOfLine && !/[ \t]$/u.test(match[0])) {
+                    replacement = ` ${replacement}`;
+                }
+            }
+        }
+        output += text.slice(copiedThrough, valueStart) + replacement;
+        copiedThrough = valueEnd;
+        STRUCTURED_SECRET_RE.lastIndex = valueEnd;
+    }
+    return copiedThrough === 0 ? text : output + text.slice(copiedThrough);
+}
+function redactCliSecrets(text) {
+    const argvRedacted = text.replace(ARGV_SECRET_RE, (_whole, prefix, value) => {
+        const quote = value[0] ?? '"';
+        return `${prefix}${quote}[REDACTED]${quote}`;
+    });
+    return argvRedacted.replace(CLI_SECRET_RE, "$1[REDACTED]");
+}
+/** Content-level defense in depth for producers that forgot sensitive metadata. */
+export function scrubSecrets(text) {
+    const basicRedacted = text
+        .replace(/\b([a-z][a-z0-9+.-]*:\/\/)[^\s/@:]+:[^\s/@]+@/giu, "$1[REDACTED]@")
+        .replace(/([?&](?:(?:access|refresh|auth|id)[_-]?token|token|api[_-]?key|password|passwd|client[_-]?secret|secret)=)[^&#\s]*/giu, "$1[REDACTED]")
+        .replace(/(\bAuthorization\s*:\s*)(?:Bearer|Basic|Token)\s+[^\s,;]+/giu, "$1[REDACTED]")
+        .replace(/(\b(?:Set-Cookie|Cookie)\s*:\s*)[^\r\n]+/giu, "$1[REDACTED]")
+        .replace(/((?:^|[\s"'`;,])(?=[A-Za-z_][A-Za-z0-9_]*\s*=)(?=[A-Za-z0-9_]*(?:KEY|TOKEN|SECRET|PASSWORD|PASSWD|PWD))[A-Za-z_][A-Za-z0-9_]*\s*=\s*)(?:"[^"\r\n]*"|'[^'\r\n]*'|[^\s"'`;]+)/gimu, "$1[REDACTED]");
+    return redactCliSecrets(redactStructuredSecrets(basicRedacted)).replace(/\b(?:sk-[A-Za-z0-9_-]{16,}|gh[pousr]_[A-Za-z0-9]{20,}|github_pat_[A-Za-z0-9_]{20,}|AKIA[0-9A-Z]{16})\b/gu, "[REDACTED]");
+}
+/**
+ * Recursively scrub JSON-like structured values with key-aware redaction.
+ * Sensitive keys redact their complete value; ordinary strings retain the
+ * free-form defense-in-depth scrub used for logs and tool-result text.
+ */
+export function scrubSecretValue(value) {
+    if (typeof value === "string")
+        return scrubSecrets(value);
+    if (Array.isArray(value))
+        return value.map(scrubSecretValue);
+    if (value && typeof value === "object") {
+        return Object.fromEntries(Object.entries(value).map(([key, entry]) => [
+            key,
+            isSensitiveKey(key) ? "[REDACTED]" : scrubSecretValue(entry),
+        ]));
+    }
+    return value;
+}

package/dist/utils/toolDisplay.js

@@ -80,7 +80,7 @@ export function formatToolArgs(toolName, args) {
     const keys = TOOL_ARG_KEYS[toolName] ?? Object.keys(args).slice(0, 2);
     const parts = [];
     for (const k of keys) {
-        let v = args[k];
+        const v = args[k];
         if (v !== undefined && !k.startsWith("__")) {
             let s = String(v);
             if (toolName === "Bash" && k === "command")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cjhyy/code-shell-core",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Core engine for code-shell — agent orchestration, tool execution, hooks, protocol. UI-agnostic.",
   "type": "module",
   "main": "./dist/index.js",
@@ -10,19 +10,34 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
+    "./internal": {
+      "types": "./dist/index.internal.d.ts",
+      "import": "./dist/index.internal.js"
+    },
+    "./panel-app-runtime": {
+      "types": "./dist/panel-apps/runtime.d.ts",
+      "import": "./dist/panel-apps/runtime.js"
+    },
+    "./browser/panel-app-runtime": {
+      "types": "./dist/panel-apps/runtime.d.ts",
+      "import": "./dist/panel-apps/runtime.js"
+    },
+    "./extension": {
+      "types": "./dist/index.extension.d.ts",
+      "import": "./dist/index.extension.js"
+    },
     "./bin/agent-server-stdio": "./dist/cli/agent-server-stdio.js"
   },
   "sideEffects": [
     "./dist/data/*.json",
     "./dist/prompt/sections/*.md"
   ],
-  "//files": "LICENSE/README intentionally omitted: npm/bun always include them in a publish regardless of this list, so the published tarball is unchanged — but listing them makes electron-builder (which follows the workspace symlink when packaging the desktop app) try to copy them from packages/core, tripping its 'file must be under <app>' guard (electron-builder#3238). THIRD_PARTY_NOTICES.md is listed explicitly because third-party attribution must ship with npm tarballs.",
+  "//files": "LICENSE/README intentionally omitted: npm/bun always include them in a publish regardless of this list, so the published tarball is unchanged — but listing them makes electron-builder (which follows the workspace symlink when packaging the desktop app) try to copy them from packages/core, tripping its 'file must be under <app>' guard (electron-builder#3238).",
   "files": [
-    "dist",
-    "THIRD_PARTY_NOTICES.md"
+    "dist"
   ],
   "scripts": {
-    "build": "tsc -p tsconfig.json && bun run copy-assets",
+    "build": "bun run clean && tsc -p tsconfig.json && bun run copy-assets",
     "copy-assets": "node ../../scripts/copy-assets.mjs dist/prompt/sections src/prompt/sections/*.md && node ../../scripts/copy-assets.mjs dist/data src/data/*.json",
     "dev": "bun run copy-assets && tsc -p tsconfig.json --watch --preserveWatchOutput",
     "clean": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\""

package/THIRD_PARTY_NOTICES.md

@@ -1,206 +0,0 @@
-# Third-party notices
-
-This package includes code derived from third-party open source projects.
-
-## OpenAI Codex apply-patch
-
-Files under `src/tool-system/builtin/apply-patch/` contain TypeScript code
-adapted from OpenAI Codex `codex-rs/apply-patch`.
-
-- Source: https://github.com/openai/codex/tree/main/codex-rs/apply-patch
-- License: Apache License 2.0
-- Copyright: Copyright 2025 OpenAI
-
-The CodeShell implementation includes modifications, including a two-phase
-commit/rollback behavior for failed patches.
-
-### Adapted files
-
-| Source (Rust)                      | Target (TypeScript)           | Notes                                               |
-| ---------------------------------- | ----------------------------- | --------------------------------------------------- |
-| `src/seek_sequence.rs`             | `seek-sequence.ts`            | Direct port; same four-pass strategy                |
-| `src/parser.rs`                    | `parser.ts`                   | Direct port of the V4A grammar parser               |
-| `src/lib.rs`                       | `applier.ts`                  | `compute_replacements` algorithm port               |
-| `apply_patch_tool_instructions.md` | tool description (`index.ts`) | Patch-format instructions adapted from the original |
-| `tests/fixtures/scenarios/`        | `tests/fixtures/apply-patch/` | Golden scenarios used for conformance               |
-
-### Apache License 2.0
-
-```
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-```

package/dist/arena/arena.d.ts

@@ -1,43 +0,0 @@
-/**
- * Arena — multi-model collaborative analysis engine.
- *
- * Evidence-Driven Pipeline:
- *   0. Planner            → understand what the user wants (mode, lenses, sources)
- *   1. EvidenceProviders   → collect artifacts from selected sources
- *   2. Strategy + Lens     → compose prompts (mode flow + perspective)
- *   3. ToolSelector        → determine which tools participants can use
- *   4. ParticipantResearch  → each model investigates independently (parallel)
- *   4b. ClaimRegistry      → register findings as claims, populate ledger
- *   5. VerificationReview   → claim-aware cross-review with evidence digests
- *   7. DebateRounds         → contested claims enter structured debate
- *   8. Adjudication         → moderator rules on contested claims
- *   6. ConsensusBuilder     → claim-aware structured consensus
- */
-import type { ArenaConfig, ArenaResultV2 } from "./types.js";
-import type { PlannerFlags } from "./planner.js";
-export declare class Arena {
-    private config;
-    private strategy;
-    private limits;
-    constructor(config: ArenaConfig);
-    /**
-     * Run a full arena session.
-     *
-     * @param topic  - User's topic/request (natural language)
-     * @param flags  - Optional explicit overrides (mode, base, head)
-     */
-    run(topic: string, flags?: PlannerFlags): Promise<ArenaResultV2>;
-    /**
-     * Planning path: merge-oriented review → roadmap consensus → detail expansion.
-     *
-     * Planning mode does NOT enter heavy debate/adjudication. Contested findings
-     * are converted to open questions or dependency risks in the roadmap.
-     */
-    private runPlanningPath;
-    /**
-     * Review/Discussion path: verification review → debate → adjudication → consensus.
-     *
-     * This is the heavy trust loop for claim verification.
-     */
-    private runReviewDiscussionPath;
-}