@vincemakes/kiso-core 0.1.29 → 0.1.30

package/dist/governance/delivery.d.ts

@@ -10,7 +10,7 @@
  *
  * Producers are declared on tools (`delivers`, tools/tool.ts); the verdict
  * counts producer calls that completed (non-error results), against a
- * delivery claim in the text. The canonical lie — "已生成文档" with zero
+ * delivery claim in the text. The canonical lie — "generated-document" with zero
  * producer calls and a clean completed terminal — fails here.
  *
  * In M3.5 the emission side (artifact URLs extracted from results) joins;

package/dist/governance/delivery.js

@@ -10,13 +10,13 @@
  *
  * Producers are declared on tools (`delivers`, tools/tool.ts); the verdict
  * counts producer calls that completed (non-error results), against a
- * delivery claim in the text. The canonical lie — "已生成文档" with zero
+ * delivery claim in the text. The canonical lie — "generated-document" with zero
  * producer calls and a clean completed terminal — fails here.
  *
  * In M3.5 the emission side (artifact URLs extracted from results) joins;
  * today a completed producer IS the emission.
  */
-const CLAIM_PATTERN = /交付|已生成|已创建|已完成|completed|delivered|done/i;
+const CLAIM_PATTERN = /created|completed|delivered|done/i;
 export function analyzeDelivery(events, config) {
     const producerCalls = [];
     const completedProducers = [];

package/dist/kernel/ledger.d.ts

@@ -18,7 +18,7 @@
  *   started, no terminal event yet   → "uncertain"   (interrupted: human)
  *   succeeded                        → "succeeded"   (confirmed, never re-run)
  *   failed (any)                     → "failed"      (a complete receipt IS
- *                                       the outcome — 裁决 #12 / ADR-0038;
+ *                                       the outcome — ruling #12 / ADR-0038;
  *                                       safeToRetry stays on the event for
  *                                       history, it no longer feeds status)
  *   resolved "rerun"                 → "rerun"       (human cleared it)

package/dist/kernel/ledger.js

@@ -18,7 +18,7 @@
  *   started, no terminal event yet   → "uncertain"   (interrupted: human)
  *   succeeded                        → "succeeded"   (confirmed, never re-run)
  *   failed (any)                     → "failed"      (a complete receipt IS
- *                                       the outcome — 裁决 #12 / ADR-0038;
+ *                                       the outcome — ruling #12 / ADR-0038;
  *                                       safeToRetry stays on the event for
  *                                       history, it no longer feeds status)
  *   resolved "rerun"                 → "rerun"       (human cleared it)
@@ -50,7 +50,7 @@ export function executionLedger(events) {
                 if (prior) {
                     ledger.set(ev.executionId, {
                         ...prior,
-                        // 裁决 #12 (ADR-0038): a complete receipt IS the outcome —
+                        // ruling #12 (ADR-0038): a complete receipt IS the outcome —
                         // failed is "failed", never "uncertain"; uncertainty
                         // belongs to the crash window alone (started, no receipt).
                         status: "failed",

package/dist/kernel/loop.d.ts

@@ -17,13 +17,13 @@
  *   assemble (onUserMessage / onPreLlm)
  *     → adapter.stream(): events yielded straight through; every validated
  *       and policy-allowed tool call LAUNCHES its execution immediately
- *       (流中执行) — the executions run concurrently under a window of 4
+ *       (streaming execution) — the executions run concurrently under a window of 4
  *       (0.1.26, ADR-0024 Amd), their events queued and drained between
  *       stream events (completion order; the projection re-orders the
- *       results by call order — 字节纪律)
+ *       results by call order — the byte discipline)
  *     → the turn settles: the launched executions finish (receipts land
  *       before any terminal), the ask-gated successors follow the human's
- *       verdict (保守序)
+ *       verdict (the conservative order)
  *   no tool calls / maxTurns / abort / max_tokens → terminal event, return
  *
  * Retry lives HERE and only here (ADR-0005): a retryable StructuredError
@@ -71,7 +71,7 @@ export interface LoopConfig {
         readonly thresholdTokens: number;
     };
     /**
-     * C 区: MICROCOMPACT — when the projected context exceeds the threshold,
+     * C area: MICROCOMPACT — when the projected context exceeds the threshold,
      * append ONE durable `microcompacted` boundary (clearing compactable tool
      * results older than the recent turns). The decision is a persisted fact:
      * the projection derives the same cleared view from the same events,
@@ -93,20 +93,20 @@ export interface LoopConfig {
      */
     readonly resolveApproval?: (decisionId: string) => Promise<PermissionDecision>;
     /**
-     * 第四轮(对抗): a verdict the human ALREADY gave before an abort landed.
+     * round 4 (adversarial): a verdict the human ALREADY gave before an abort landed.
      * The abort path consults this BEFORE yielding the aborted terminal: a
      * consumed verdict must be recorded (exactly once), never lost — the
      * human's decision outranks the abort.
      */
     readonly approvalVerdict?: (decisionId: string) => boolean | undefined;
     /**
-     * C 组: the channel that resolves a failed NON-idempotent execution.
+     * C group: the channel that resolves a failed NON-idempotent execution.
      * The loop persists `uncertain_pending`, yields it, and AWAITS the
      * human verdict — no next model turn, no sibling tool, no auto-retry.
      * Absent, the failure is recorded `abandoned` (never retried).
      */
     readonly resolveUncertainty?: (executionId: string) => Promise<"rerun" | "abandoned">;
-    /** 第四轮(对抗): the uncertainty twin of `approvalVerdict`. */
+    /** round 4 (adversarial): the uncertainty twin of `approvalVerdict`. */
     readonly uncertaintyVerdict?: (executionId: string) => "rerun" | "abandoned" | undefined;
     /**
      * E1: extension approval policies, tagged by their owning extension —

package/dist/kernel/loop.js

@@ -17,13 +17,13 @@
  *   assemble (onUserMessage / onPreLlm)
  *     → adapter.stream(): events yielded straight through; every validated
  *       and policy-allowed tool call LAUNCHES its execution immediately
- *       (流中执行) — the executions run concurrently under a window of 4
+ *       (streaming execution) — the executions run concurrently under a window of 4
  *       (0.1.26, ADR-0024 Amd), their events queued and drained between
  *       stream events (completion order; the projection re-orders the
- *       results by call order — 字节纪律)
+ *       results by call order — the byte discipline)
  *     → the turn settles: the launched executions finish (receipts land
  *       before any terminal), the ask-gated successors follow the human's
- *       verdict (保守序)
+ *       verdict (the conservative order)
  *   no tool calls / maxTurns / abort / max_tokens → terminal event, return
  *
  * Retry lives HERE and only here (ADR-0005): a retryable StructuredError
@@ -72,7 +72,7 @@ export async function* loop(config) {
     };
     const aborted = () => signal?.aborted === true;
     // Assemble: the incoming user message may be rewritten or vetoed.
-    // C 组: the outcome is PERSISTED as a user_input_replaced event — the
+    // C group: the outcome is PERSISTED as a user_input_replaced event — the
     // projection renders the final replacement AT THE INPUT'S POSITION (or
     // nothing, for a true veto), so the rewritten fact is the ONLY fact
     // every later turn of the run sees.
@@ -82,13 +82,13 @@ export async function* loop(config) {
         const last = messages.at(-1);
         if (last?.role === "user") {
             const inputEvent = [...log.all].reverse().find((e) => e.type === "user_input");
-            // 六: the hook runs AT MOST ONCE per input. A replacement that
+            // round 6: the hook runs AT MOST ONCE per input. A replacement that
             // ALREADY exists (persisted before a crash, or before a resume)
             // means the hook already spoke for this input — it must never
             // run again, and the run continues from the durable fact.
             const replacement = log.all.find((e) => e.type === "user_input_replaced" && e.replaces === inputEvent?.seq);
             if (replacement !== undefined) {
-                // 六/第五轮(P1-7): the hook ALREADY spoke for this input — a
+                // round 6/round 5 (P1-7): the hook ALREADY spoke for this input — a
                 // durable null content is a TRUE veto: restore the vetoed
                 // flag so the provider is NEVER called, even when earlier
                 // history exists (previously only an empty history happened
@@ -98,7 +98,7 @@ export async function* loop(config) {
             }
             if (replacement === undefined && inputEvent) {
                 const rewritten = await hooks.onUserMessage(last, {});
-                // 一: the rewrite/veto is a NORMAL stream event — persisted by
+                // round 1: the rewrite/veto is a NORMAL stream event — persisted by
                 // the harness and visible to consumers, never a hidden append.
                 const replaced = log.append({
                     type: "user_input_replaced",
@@ -109,11 +109,11 @@ export async function* loop(config) {
                 messages = derive();
                 yield replaced;
                 if (rewritten === null)
-                    vetoed = true; // 三: a true veto ends the run
+                    vetoed = true; // round 3: a true veto ends the run
             }
         }
     }
-    // 三: a true veto ends the run — the provider is NEVER called, even
+    // round 3: a true veto ends the run — the provider is NEVER called, even
     // when earlier history exists.
     if (vetoed || messages.length === 0) {
         yield await terminal({ kind: "completed" });
@@ -123,7 +123,7 @@ export async function* loop(config) {
     // showed the sequential ledger is the bottleneck): the windowed parallel
     // batching returns, this time with the ledger events emitted per call in
     // deterministic order. The model stream and the tool executions run
-    // CONCURRENTLY (流中执行): a tool_call_end validated and allowed by the
+    // CONCURRENTLY (streaming execution): a tool_call_end validated and allowed by the
     // policy chain launches its execution immediately; the events land
     // through a queue the stream loop drains on every stream event — their
     // seq order is the COMPLETION order (started/receipt/result land when
@@ -132,13 +132,13 @@ export async function* loop(config) {
     // turn's results by CALL order (project.ts flushResults) — the
     // completion order only affects the landing moment, never the derived
     // messages. The window caps concurrent executions; the ask gate holds
-    // an ask AND the calls after it until the human decides (保守序 — the
+    // an ask AND the calls after it until the human decides (the conservative order — the
     // context may have changed when the human approves); the STARTED event
     // is acked by the drain so the handler never runs before its receipt is
     // persisted (write-ahead preserved). A voided turn (forged event,
     // post-stop violation, a non-compatible stop reason) fires the violated
-    // signal: started executions finish and their receipts land (已开跑照落
-    // receipt), not-started ones bail without a started event (abort 语义 —
+    // signal: started executions finish and their receipts land (already-started executions still land their
+    // receipt), not-started ones bail without a started event (abort semantics —
     // clean, never uncertain).
     const WINDOW_SIZE = 4;
     // The execution event queue. The drain (below) appends + yields each
@@ -195,7 +195,7 @@ export async function* loop(config) {
     let launchError = null;
     let violated = false;
     // The violated signal: rejects when the turn is voided — the paused
-    // ask-branches bail (abort 语义 for not-started executions). Typed
+    // ask-branches bail (abort semantics for not-started executions). Typed
     // `never` so the ask race resolves to the human decision alone.
     let violatedReject = () => { };
     const violatedP = new Promise((_, reject) => {
@@ -261,7 +261,7 @@ export async function* loop(config) {
                         return;
                     }
                 }
-                // 保守序: the calls AFTER an ask wait for its human
+                // the conservative order: the calls AFTER an ask wait for its human
                 // resolution (the askGate is the ask's pause promise —
                 // resolved by default, released by the ask branch above).
                 // The context may have changed when the human approves.
@@ -293,7 +293,7 @@ export async function* loop(config) {
             return;
         }
         turns += 1;
-        // ── C 区: one-shot microcompact boundary when over the threshold ──
+        // ── C area: one-shot microcompact boundary when over the threshold ──
         if (config.microcompact !== undefined && estimateTokens(messages) > config.microcompact.thresholdTokens) {
             const beforeSeq = microcompactBoundarySeq(log.all, config.microcompact.keepResults ?? KEEP_COMPACTABLE_RESULTS);
             if (beforeSeq !== undefined) {
@@ -316,11 +316,11 @@ export async function* loop(config) {
         let stopCount = 0;
         let streamed = false;
         let attempts = 0;
-        // 五: the turn is a strict protocol — once the provider stops, ANY
+        // round 5: the turn is a strict protocol — once the provider stops, ANY
         // further event (delta, tool call, usage, thinking) is a violation.
         let sawStop = false;
         let postStopViolation = false;
-        // 五: the adapter may only produce its OWN event kinds — a
+        // round 5: the adapter may only produce its OWN event kinds — a
         // kernel-owned event (terminal, tool_execution_*, permission_*,
         // user_input, …) from the stream is a FORGERY and must never reach
         // the log.
@@ -346,10 +346,10 @@ export async function* loop(config) {
                     streamed = true;
                     // 0.1.26: the launched executions' events land first —
                     // the completion order; the projection re-orders the
-                    // results by call order (字节纪律).
+                    // results by call order (the byte discipline).
                     for await (const q of drainExec())
                         yield q;
-                    // 五: the trust gate — a kernel-owned event from the
+                    // round 5: the trust gate — a kernel-owned event from the
                     // adapter is a forgery: it is never appended (never
                     // persisted), and the turn ends with a unique
                     // invalid_request terminal below.
@@ -359,7 +359,7 @@ export async function* loop(config) {
                         violatedReject();
                         break;
                     }
-                    // 五: a delta/tool call/usage arriving AFTER the provider's
+                    // round 5: a delta/tool call/usage arriving AFTER the provider's
                     // stop is a protocol error — the violating event is never
                     // appended, and the turn ends with an error terminal (the
                     // pending tools must NOT execute).
@@ -376,7 +376,7 @@ export async function* loop(config) {
                     }
                     if (ev.type === "tool_call_end") {
                         pending.push(ev);
-                        // 流中执行: the call launches immediately — the decide
+                        // streaming execution: the call launches immediately — the decide
                         // and the ledgered run proceed in parallel with the
                         // model stream.
                         launch(ev);
@@ -408,12 +408,12 @@ export async function* loop(config) {
                 return;
             }
         }
-        // ── The voided-terminal computation (五 / C 组) ────────────────────
+        // ── The voided-terminal computation (round 5 / C group) ────────────────────
         // A forged kernel-owned event, a post-stop event, or a
         // non-compatible stop reason voids the turn: the launched
-        // executions still finish and their receipts land (已开跑照落
+        // executions still finish and their receipts land (already-started executions still land their
         // receipt — the side effects happened), the not-started bail
-        // (abort 语义), then the terminal.
+        // (abort semantics), then the terminal.
         let voided = null;
         if (forgedEvent) {
             voided = {
@@ -454,7 +454,7 @@ export async function* loop(config) {
             yield await terminal({ kind: "aborted", by: "user" });
             return;
         }
-        // ── C 组: the turn is verified. 0.1.26 (流中执行): the calls were
+        // ── C group: the turn is verified. 0.1.26 (streaming execution): the calls were
         // ALREADY launched at tool_call_end, so a non-compatible stop reason
         // VOIDS the turn instead of preventing the execution.
         if (voided === null && pending.length > 0) {
@@ -501,9 +501,9 @@ export async function* loop(config) {
             }
         }
         // ── The turn settles: a void fires the violated signal — the
-        //    not-started executions bail (abort 语义 — no started, no
+        //    not-started executions bail (abort semantics — no started, no
         //    receipt, never uncertain); the started ones finish and their
-        //    receipts land BEFORE the terminal or the next turn (已开跑照落
+        //    receipts land BEFORE the terminal or the next turn (already-started executions still land their
         //    receipt). The drain yields every queued event; the STARTED
         //    ack resolves as the consumer persists (write-ahead), so the
         //    launches advance DURING the drain — a 10ms settle poll covers
@@ -578,7 +578,7 @@ function terminalForStop(reason) {
     }
 }
 /** The tool_result event for a call — the shared shape (executionId rides
- *  it as the durable correlation, 五). */
+ *  it as the durable correlation, round 5). */
 function resultEvent(call, result, executionId) {
     return {
         type: "tool_result",
@@ -589,7 +589,7 @@ function resultEvent(call, result, executionId) {
         // the runtime guard keeps a JS tool's illegal combination out of
         // the persisted event too).
         ...(result.isError && result.errorKind ? { errorKind: result.errorKind } : {}),
-        // 五: a live tool's tags are preserved losslessly (do-not-compact,
+        // round 5: a live tool's tags are preserved losslessly (do-not-compact,
         // billing receipts, trace anchors) — never dropped at the loop.
         ...(result.tags !== undefined ? { tags: result.tags } : {}),
         ...(executionId !== undefined ? { executionId } : {}),
@@ -634,7 +634,7 @@ async function decideCall(call, registry, hooks, ctx, log, resolveApproval, reso
         throw ABORTED;
     // ── E1: the extension policy chain, decided BEFORE the human flow ─────
     // A durable POLICY decision for THIS call takes effect on resume — the
-    // chain never re-runs when its verdict is already in the log (同构
+    // chain never re-runs when its verdict is already in the log (isomorphic
     // alreadyReplaced: the persisted fact speaks for the call). The match is
     // the same logical call: same callId, decidedBy set (a policy verdict,
     // never a human's), and input identical to the original tool_call_end —
@@ -660,7 +660,7 @@ async function decideCall(call, registry, hooks, ctx, log, resolveApproval, reso
                 v = await raceAbort(Promise.resolve(policy.decide(payload, ctx)), signal);
             }
             catch {
-                v = { action: "ask" }; // 抛错 = 该扩展计为 ask —— 发声,绝不静默
+                v = { action: "ask" }; // a throwing policy counts as ask — it speaks, never silently
             }
             if (v.action === "abstain")
                 continue; // no opinion — not a verdict
@@ -678,10 +678,10 @@ async function decideCall(call, registry, hooks, ctx, log, resolveApproval, reso
             chainVerdict = { action: "deny", reason: deniedReason ?? "denied" };
         }
         else if (chainVerdict === undefined && anySpoke) {
-            chainVerdict = { action: "allow" }; // 全发声者皆 allow
+            chainVerdict = { action: "allow" }; // every speaker allows
         }
         else if (chainVerdict === undefined) {
-            // 全员 abstain (ADR-0042): NO policy speaks — the call falls to
+            // an all-abstain (ADR-0042): NO policy speaks — the call falls to
             // the ask flow below, never to a silent auto-approve. The human
             // decides; absent a channel, humanPause's honest denial.
             chainVerdict = { action: "ask" };
@@ -707,7 +707,7 @@ async function decideCall(call, registry, hooks, ctx, log, resolveApproval, reso
         return { action: "deny", result: resultEvent(call, denialResult(durable.reason ?? "denied")) };
     }
     if (chainVerdict?.action === "ask") {
-        // 裁决 A (E1 ask 语义修正): an ask means "a HUMAN must decide" — it
+        // ruling A (the E1 ask semantics fix): an ask means "a HUMAN must decide" — it
         // routes DIRECTLY to the human approval pause, never through
         // onPreTool: a static automated policy (e.g. the CLI's default deny
         // for unknown tools) must not answer for the human. No approval
@@ -718,10 +718,10 @@ async function decideCall(call, registry, hooks, ctx, log, resolveApproval, reso
         }
         return { action: "ask", decisionId: nextDecisionId() };
     }
-    // Permission negotiation — defer is a REAL pause (Phase D). C 组: the
+    // Permission negotiation — defer is a REAL pause (Phase D). C group: the
     // hook itself is cancelable (a slow policy query must not outlive an
     // abort), and the signal is re-checked after it returns. Runs only when
-    // the policy chain did not run at all (裁决 A: an ask was already
+    // the policy chain did not run at all (ruling A: an ask was already
     // resolved by the human pause above — the static hook never speaks for
     // it, and a durable decision already spoke for the call).
     if (durable === undefined && chainVerdict === undefined && hooks.onPreTool) {
@@ -738,7 +738,7 @@ async function decideCall(call, registry, hooks, ctx, log, resolveApproval, reso
     return { action: "allow" };
 }
 /**
- * The human approval pause (Phase D / 裁决 A): register the resolver
+ * The human approval pause (Phase D / ruling A): register the resolver
  * BEFORE announcing the request (a consumer that answers the moment it
  * sees the event must find the resolver already waiting — no deadlock
  * between push and await), persist the request (via push), await the
@@ -767,7 +767,7 @@ async function humanPause(call, decisionId, hooks, log, resolveApproval, resolve
     }
     catch (err) {
         if (err === ABORTED) {
-            // 第四轮(对抗): the human may have answered in the same instant
+            // round 4 (adversarial): the human may have answered in the same instant
             // the abort landed — a CONSUMED verdict must be recorded
             // (exactly once), never lost; the abort then ends the run with
             // its honest aborted terminal.
@@ -791,7 +791,7 @@ async function humanPause(call, decisionId, hooks, log, resolveApproval, resolve
         push({
             type: "permission_decided",
             decisionId,
-            callId: call.callId, // binds the decision to the invocation (B 组)
+            callId: call.callId, // binds the decision to the invocation (B group)
             decision: finalDecision.action === "allow" ? "approved" : "denied",
             ...(finalDecision.action === "deny" && finalDecision.reason !== undefined
                 ? { reason: finalDecision.reason }
@@ -808,7 +808,7 @@ async function humanPause(call, decisionId, hooks, log, resolveApproval, resolve
  */
 async function runLedgered(call, registry, hooks, ctx, signal, push) {
     const tool = registry.get(call.name); // validated + decided by decideCall
-    // C 组: the signal is re-checked immediately before the started event —
+    // C group: the signal is re-checked immediately before the started event —
     // an abort that landed in any permission path must not let the side
     // effect begin.
     if (signal?.aborted)
@@ -830,7 +830,7 @@ async function runLedgered(call, registry, hooks, ctx, signal, push) {
     });
     let result;
     try {
-        // C 组: re-checked again right before the handler — the handler also
+        // C group: re-checked again right before the handler — the handler also
         // observes ctx.signal, but the gate itself must not invoke it after
         // a cancel.
         result = signal?.aborted
@@ -847,7 +847,7 @@ async function runLedgered(call, registry, hooks, ctx, signal, push) {
     if (hooks.onPostTool) {
         result = await hooks.onPostTool({ callId: call.callId, name: call.name, input: call.input ?? {} }, result, ctx);
     }
-    // 裁决 #12 修正一: a non-idempotent failure's side effects may have
+    // ruling #12 correction one: a non-idempotent failure's side effects may have
     // partially applied — an honest note rides the RESULT (and the failed
     // receipt below, losslessly — a crash-window repair of the tool_result
     // reproduces the normal path). Idempotent failures carry no note; the
@@ -863,7 +863,7 @@ async function runLedgered(call, registry, hooks, ctx, signal, push) {
         // Area 3: only a tool that PROVED safe-to-retry (idempotent) gets a
         // clean failure; a non-idempotent failure may have produced a side
         // effect and is uncertain until a human decides.
-        // 八: the tags ride on the RECEIPT too — a crash-window repair of the
+        // round 8: the tags ride on the RECEIPT too — a crash-window repair of the
         // tool_result reproduces the normal path losslessly.
         push({
             type: "tool_execution_failed",
@@ -893,7 +893,7 @@ async function runLedgered(call, registry, hooks, ctx, signal, push) {
 const ABORTED = Symbol("kiso-aborted-during-approval");
 /**
  * Wait for a human decision (approval or uncertain verdict), but WAKE on
- * abort (Area 4 / C 组): a cancel during the wait must end the run, not
+ * abort (Area 4 / C group): a cancel during the wait must end the run, not
  * leave the iterator hung. Throws ABORTED; the loop converts it to an
  * `aborted` terminal.
  */
@@ -956,14 +956,14 @@ function sleep(ms, signal) {
     });
 }
 /**
- * C 区 (自举 #3): the DEFAULT for how many of the NEWEST compactable tool
+ * C area (bootstrap #3): the DEFAULT for how many of the NEWEST compactable tool
  * results survive a microcompact boundary (overridable per config via
  * microcompact.keepResults) — the model must keep reasoning over the
  * recent results, whatever turn they belong to.
  */
 const KEEP_COMPACTABLE_RESULTS = 4;
 /**
- * C 区: the boundary seq for a microcompact — drawn by COMPACTABLE-RESULT
+ * C area: the boundary seq for a microcompact — drawn by COMPACTABLE-RESULT
  * recentness, never user turns: a SINGLE user turn that reads several big
  * files (the coding agent's main overflow shape) crosses the threshold and
  * must trigger. The newest `keepResults` still-visible compactable tool
@@ -987,11 +987,11 @@ function microcompactBoundarySeq(events, keepResults) {
         if (ev.type !== "tool_result" || ev.seq <= lastCleared)
             continue;
         const name = callName.get(ev.callId);
-        // 手感批 C6 (P4): the do-not-compact tag makes a result UN-CLEARABLE
+        // the ergonomics batch C6 (P4): the do-not-compact tag makes a result UN-CLEARABLE
         // (the projection keeps it) — the count must EXCLUDE it, exactly like
         // the clearing side. A tagged result counted here would steal a keep
         // window slot forever and could anchor the boundary at a result the
-        // projection refuses to clear (计数与清除口径一致).
+        // projection refuses to clear (the count and the clearing share one rule).
         if (name !== undefined && MICROCOMPACTABLE.has(name) && !(ev.tags ?? []).includes(DO_NOT_COMPACT))
             visible.push(ev.seq);
     }

package/dist/kernel/project.d.ts

@@ -16,8 +16,8 @@
  * Events with no message shape (usage, stop, thinking, terminal, the
  * compaction events' own records) are skipped by the projection;
  * `compacted` applies the EXACT persisted replacements verbatim — it never
- * re-runs the compaction algorithm (a future version could differ, A 组/D
- * 组); `microcompacted` boundaries re-derive the cleared view from the
+ * re-runs the compaction algorithm (a future version could differ, A group/D
+ * group); `microcompacted` boundaries re-derive the cleared view from the
  * stream itself (deterministic and idempotent); `summarized` (ADR-0044)
  * replaces its covered range with one assistant summary message. All
  * three are persisted facts — the replay equals the live run. See ADR-0002.
@@ -26,18 +26,18 @@ import type { Event } from "../protocol/events.js";
 import type { EventInput } from "./event-log.js";
 import type { AssistantBlock, Message, MessageSource } from "../protocol/messages.js";
 /**
- * C 区: tools whose output is eligible for microcompact clearing — reads,
+ * C area: tools whose output is eligible for microcompact clearing — reads,
  * listings, searches, and shell output. write/edit outputs are short and
- * never cleared. Exported so the loop's boundary computation (自举 #3)
+ * never cleared. Exported so the loop's boundary computation (bootstrap #3)
  * counts exactly the results the projection can clear.
  */
 export declare const MICROCOMPACTABLE: Set<string>;
-/** The tag that makes a tool result un-clearable (C 区). */
+/** The tag that makes a tool result un-clearable (C area). */
 export declare const DO_NOT_COMPACT = "do-not-compact";
 /**
  * Rebuild the message array from events. Deterministic and order-sensitive:
  * replaying the same log always produces the same messages — BYTE FOR BYTE
- * (D 区): the same event prefix derives the same message prefix; the only
+ * (D area): the same event prefix derives the same message prefix; the only
  * events that change already-derived messages are `microcompacted`
  * boundaries and `summarized` facts, which are themselves persisted facts
  * (their replay derives the same projection every time).

package/dist/kernel/project.js

@@ -16,23 +16,23 @@
  * Events with no message shape (usage, stop, thinking, terminal, the
  * compaction events' own records) are skipped by the projection;
  * `compacted` applies the EXACT persisted replacements verbatim — it never
- * re-runs the compaction algorithm (a future version could differ, A 组/D
- * 组); `microcompacted` boundaries re-derive the cleared view from the
+ * re-runs the compaction algorithm (a future version could differ, A group/D
+ * group); `microcompacted` boundaries re-derive the cleared view from the
  * stream itself (deterministic and idempotent); `summarized` (ADR-0044)
  * replaces its covered range with one assistant summary message. All
  * three are persisted facts — the replay equals the live run. See ADR-0002.
  */
 /**
- * C 区: tools whose output is eligible for microcompact clearing — reads,
+ * C area: tools whose output is eligible for microcompact clearing — reads,
  * listings, searches, and shell output. write/edit outputs are short and
- * never cleared. Exported so the loop's boundary computation (自举 #3)
+ * never cleared. Exported so the loop's boundary computation (bootstrap #3)
  * counts exactly the results the projection can clear.
  */
 export const MICROCOMPACTABLE = new Set(["read_file", "list_dir", "search_text", "shell"]);
-/** The tag that makes a tool result un-clearable (C 区). */
+/** The tag that makes a tool result un-clearable (C area). */
 export const DO_NOT_COMPACT = "do-not-compact";
 /**
- * C 区: the fixed placeholder for a cleared tool output, derived ONLY from
+ * C area: the fixed placeholder for a cleared tool output, derived ONLY from
  * the event stream (deterministic across replay): the tool's name and its
  * primary argument (the first string-valued field of its input).
  */
@@ -54,7 +54,7 @@ function primaryArg(input) {
 /**
  * Rebuild the message array from events. Deterministic and order-sensitive:
  * replaying the same log always produces the same messages — BYTE FOR BYTE
- * (D 区): the same event prefix derives the same message prefix; the only
+ * (D area): the same event prefix derives the same message prefix; the only
  * events that change already-derived messages are `microcompacted`
  * boundaries and `summarized` facts, which are themselves persisted facts
  * (their replay derives the same projection every time).
@@ -75,9 +75,9 @@ export function projectMessages(events) {
             text = null;
         }
     };
-    // 自举 P1: the reasoning of the turn being built, accumulated from its
+    // bootstrap P1: the reasoning of the turn being built, accumulated from its
     // `thinking` events and attached to the assistant message at flush —
-    // deterministic (same events → same messages → same request body, D 区).
+    // deterministic (same events → same messages → same request body, D area).
     let pendingReasoning = null;
     const flushAssistant = () => {
         pushText();
@@ -96,7 +96,7 @@ export function projectMessages(events) {
         blocks = [];
         assistantSource = undefined;
     };
-    // C 组/六: vetoed/rewritten user inputs. Collect the replacement map
+    // C group/round 6: vetoed/rewritten user inputs. Collect the replacement map
     // first — the FINAL replacement for each input wins (later replacements
     // never produce extra messages), and the replacement renders AT THE
     // INPUT'S OWN POSITION: the original is skipped, the final non-null
@@ -111,7 +111,7 @@ export function projectMessages(events) {
             });
         }
     }
-    // C 区: callId → {name, input} for the microcompact placeholder.
+    // C area: callId → {name, input} for the microcompact placeholder.
     const callMeta = new Map();
     for (const ev of events) {
         if (ev.type === "tool_call_end")
@@ -144,8 +144,8 @@ export function projectMessages(events) {
     // physical seq order is the COMPLETION order (started/receipt/result land
     // when each execution finishes — parallel), which must never enter the
     // projection: the same logical turn projects byte-identically whatever
-    // the completion interleaving (字节纪律 — 以 call 序为准,完成序只影响
-    // 落盘时刻). `callOrder` is rebuilt per turn from the tool_call_end
+    // the completion interleaving (the byte discipline — call order is the truth; completion order only affects
+    // the moment of writing). `callOrder` is rebuilt per turn from the tool_call_end
     // events (their seq order IS the call order — the stream order).
     let resultBuf = [];
     const callOrder = new Map();
@@ -188,7 +188,7 @@ export function projectMessages(events) {
                 // first, then its results in call order (the turn boundary).
                 flushAssistant();
                 flushResults();
-                // 六: the final replacement renders HERE, at the input's own
+                // round 6: the final replacement renders HERE, at the input's own
                 // position — the original is skipped, the replacement event
                 // itself produces nothing (a later replacement for the same
                 // input never becomes a second message).
@@ -214,10 +214,10 @@ export function projectMessages(events) {
             }
             case "user_input_replaced":
                 // The replacement already rendered at its input's position —
-                // this event carries no message of its own (六).
+                // this event carries no message of its own (round 6).
                 break;
             case "assistant_start":
-                // D 组: an explicit message boundary — close any open message
+                // D group: an explicit message boundary — close any open message
                 // and begin a new one (adjacent assistants stay separate).
                 flushAssistant();
                 flushResults();
@@ -304,7 +304,7 @@ export function projectMessages(events) {
                     ...(ev.source !== undefined ? { source: ev.source } : {}),
                     ...(ev.tags !== undefined ? { tags: ev.tags } : {}),
                 };
-                // 五: the originating event's seq rides on the message as a
+                // round 5: the originating event's seq rides on the message as a
                 // NON-ENUMERABLE correlation field — the stable identity
                 // compaction uses to name WHICH result it replaced. Deep
                 // equality with seed messages (which carry no such field)
@@ -322,7 +322,7 @@ export function projectMessages(events) {
                 flushAssistant();
                 flushResults(); // the results must be in `out` before the replacement pass
                 flushAssistant();
-                // C 区: replace every eligible OLD tool result with the fixed
+                // C area: replace every eligible OLD tool result with the fixed
                 // placeholder. Eligibility: the result's own event seq <= the
                 // boundary, its tool in the whitelist, and no do-not-compact
                 // tag. Deterministic — the boundary event IS the decision.
@@ -346,10 +346,10 @@ export function projectMessages(events) {
                 flushResults(); // the results must be in `out` before the replacement pass
                 flushAssistant();
                 // Apply the EXACT persisted replacements — never re-run the
-                // compaction algorithm (a future version could differ). 五:
+                // compaction algorithm (a future version could differ). round 5:
                 // v2 entries are keyed by the replaced tool-result EVENT's
                 // seq, so only the specific result is rewritten — never a
-                // same-callId sibling from another turn or run. 第四轮: v1
+                // same-callId sibling from another turn or run. round 4: v1
                 // entries (round-three sessions, no eventSeq) replay with v1
                 // semantics — every tool result with that callId is replaced,
                 // exactly as the old framework did.
@@ -369,7 +369,7 @@ export function projectMessages(events) {
                 break;
             }
             case "thinking":
-                // 自举 P1: accumulate the turn's reasoning — the flush (an
+                // bootstrap P1: accumulate the turn's reasoning — the flush (an
                 // empty one at the turn's start) keeps the pending text, and
                 // the assistant message that follows carries it. 0.1.26: the
                 // assistant flush is guarded on the buffered results (a
@@ -440,9 +440,9 @@ export function messagesToEvents(messages) {
                 break;
             }
             case "assistant": {
-                // D 组: an explicit assistant_start/assistant_end pair frames
+                // D group: an explicit assistant_start/assistant_end pair frames
                 // the message — adjacent and empty assistants round-trip.
-                // 自举 P1: the reasoning re-enters the log as its ORIGINAL
+                // bootstrap P1: the reasoning re-enters the log as its ORIGINAL
                 // thinking event — the projection re-attaches it identically.
                 if (msg.reasoning !== undefined) {
                     out.push({ type: "thinking", text: msg.reasoning });

package/dist/protocol/adapter.d.ts

@@ -49,7 +49,7 @@ export interface StreamOptions {
     readonly signal?: AbortSignalLike;
 }
 /**
- * The NARROW event set an adapter may produce (五). Everything else in the
+ * The NARROW event set an adapter may produce (round 5). Everything else in the
  * union is kernel-owned — `terminal`, `tool_execution_*`, `permission_*`,
  * `user_input`, `compacted`, `summarized`, `uncertain_pending`,
  * `user_input_replaced`, `assistant_start`/`assistant_end` — and a
@@ -63,7 +63,7 @@ export type AdapterEvent = Extract<Event, {
 /** Runtime whitelist backing the narrowed type — the loop's trust gate. */
 export declare const ADAPTER_EVENT_TYPES: ReadonlySet<string>;
 /**
- * 第五轮(P1-8): the trust gate validates STRUCTURE, not just the type name.
+ * round 5(P1-8): the trust gate validates STRUCTURE, not just the type name.
  * A third-party adapter can emit a legal type with illegal fields (a stop
  * without a reason, a usage with known:true and no token, an array tool
  * input) — persisted, that would poison the next load. The gate reuses the

package/dist/protocol/adapter.js

@@ -31,7 +31,7 @@ export const ADAPTER_EVENT_TYPES = new Set([
     "stop",
 ]);
 /**
- * 第五轮(P1-8): the trust gate validates STRUCTURE, not just the type name.
+ * round 5(P1-8): the trust gate validates STRUCTURE, not just the type name.
  * A third-party adapter can emit a legal type with illegal fields (a stop
  * without a reason, a usage with known:true and no token, an array tool
  * input) — persisted, that would poison the next load. The gate reuses the

package/dist/protocol/events.d.ts

@@ -62,7 +62,7 @@ export interface TextStart {
     readonly source?: import("./messages.js").MessageSource;
 }
 /**
- * The explicit boundary of an assistant message (D 组). Adapters never emit
+ * The explicit boundary of an assistant message (D group). Adapters never emit
  * these (their implicit boundaries — tool_result/user_input/terminal — are
  * enough); the seed encoder uses them so ADJACENT assistant messages and
  * EMPTY assistant messages round-trip losslessly.
@@ -134,12 +134,12 @@ export interface ToolResultEvent {
     readonly seq: number;
     readonly type: "tool_result";
     readonly callId: string;
-    /** Full content — blocks preserved losslessly (D 组). */
+    /** Full content — blocks preserved losslessly (D group). */
     readonly content: string | readonly import("./messages.js").ContentBlock[];
     readonly isError: boolean;
     /** Present only when `isError` is true and the handler classified it. */
     readonly errorKind?: ToolErrorKind;
-    /** The execution that produced this result (B 组) — receipt pairing key. */
+    /** The execution that produced this result (B group) — receipt pairing key. */
     readonly executionId?: string;
     /** Provenance + product tags — preserved losslessly (Area 6). */
     readonly source?: import("./messages.js").MessageSource;
@@ -161,17 +161,17 @@ export interface UserInputEvent {
 /**
  * Compaction happened at this point in the trajectory. The EXACT
  * replacements are persisted; the projection applies them verbatim — it
- * never re-runs a future version of the compaction algorithm (A 组/D 组).
+ * never re-runs a future version of the compaction algorithm (A group/D group).
  * The replay therefore equals the live run byte for byte, independent of
  * algorithm drift.
  *
- * 五: `eventSeq` is the STABLE identity — the seq of the specific
+ * round 5: `eventSeq` is the STABLE identity — the seq of the specific
  * `tool_result` event that was replaced. The provider callId may repeat
  * across runs and is correlation-only; `callId` is kept for traceability.
  * Only THIS turn's NEWLY cleared results are listed, never a cumulative
- * set of already-cleared markers (五).
+ * set of already-cleared markers (round 5).
  *
- * 第四轮: `eventSeq` is OPTIONAL because sessions written by round three
+ * round 4: `eventSeq` is OPTIONAL because sessions written by round three
  * (v1) carry `{callId, content}` entries without it. Those are legal and
  * replay with v1 semantics (replace every tool result with that callId,
  * exactly as the old framework did); records written from now on always
@@ -212,7 +212,7 @@ export interface ToolExecutionSucceeded {
         readonly content: string;
         readonly isError: false;
     };
-    /** 八: the tags ride on the durable RECEIPT so a crash-window repair
+    /** round 8: the tags ride on the durable RECEIPT so a crash-window repair
      *  of the tool_result can reproduce the normal path losslessly. */
     readonly tags?: readonly string[];
 }
@@ -230,7 +230,7 @@ export interface ToolExecutionFailed {
     readonly error: string;
     readonly errorKind?: ToolErrorKind;
     readonly safeToRetry: boolean;
-    /** 八: tags on the durable receipt, preserved across crash-window repair. */
+    /** round 8: tags on the durable receipt, preserved across crash-window repair. */
     readonly tags?: readonly string[];
 }
 /**
@@ -264,7 +264,7 @@ export interface PermissionDecided {
     readonly seq: number;
     readonly type: "permission_decided";
     readonly decisionId: string;
-    /** The invocation this decision binds to (B 组). */
+    /** The invocation this decision binds to (B group). */
     readonly callId?: string;
     readonly decision: "approved" | "denied";
     readonly reason?: string;
@@ -273,7 +273,7 @@ export interface PermissionDecided {
     readonly decidedBy?: string;
 }
 /**
- * A permission request was CLOSED because its run terminated first (B 组):
+ * A permission request was CLOSED because its run terminated first (B group):
  * an aborted/completed/error run's dangling approval is dead — it is never
  * re-presented and a late approve() cannot resurrect the run.
  */
@@ -285,7 +285,7 @@ export interface PermissionExpired {
 }
 /**
  * A non-idempotent execution FAILED and the run PAUSES until a human
- * decides (C 组): no next model turn, no sibling tool, no auto-retry. The
+ * decides (C group): no next model turn, no sibling tool, no auto-retry. The
  * verdict is recorded by the session (resolveUncertain) and the ledger
  * transitions uncertain → rerun/abandoned; the event itself is the durable
  * pause marker.
@@ -299,7 +299,7 @@ export interface UncertainPending {
     readonly error: string;
 }
 /**
- * A user input was VETOED or REWRITTEN by the harness (C 组). `replaces`
+ * A user input was VETOED or REWRITTEN by the harness (C group). `replaces`
  * is the seq of the original user_input; the projection skips the original
  * and, when `content` is non-null, produces the replacement instead — the
  * rewritten fact is the ONLY fact every later turn sees. null content = a
@@ -310,11 +310,11 @@ export interface UserInputReplaced {
     readonly type: "user_input_replaced";
     readonly replaces: number;
     readonly content: string | readonly import("./messages.js").ContentBlock[] | null;
-    /** Provenance of the replacement — preserved from the hook (三). */
+    /** Provenance of the replacement — preserved from the hook (round 3). */
     readonly source?: import("./messages.js").MessageSource;
 }
 /**
- * C 区: a MICROCOMPACT boundary — the durable record of a context-clearing
+ * C area: a MICROCOMPACT boundary — the durable record of a context-clearing
  * decision. `beforeSeq` is the event seq up to which eligible tool results
  * are cleared: the projection replaces every tool_result with seq <=
  * beforeSeq (whose tool is in the compactable whitelist and carries no

package/dist/protocol/events.js

@@ -22,13 +22,13 @@
  * This module is almost types-only: the only runtime value it emits is
  * `isKisoEvent`, the type guard the session store validates records with.
  */
-// ── deep-shape helpers (五): every variant is validated field by field —
+// ── deep-shape helpers (round 5): every variant is validated field by field —
 // legal enums, Terminal union members, Usage known/token combos, content
 // blocks, plain-object inputs, optional fields when present. A record that
 // parses as JSON but violates its variant's shape is corruption, never
 // history.
 const isPlainObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
-/** 九: counts (seq, tokens, turns, status) are non-negative SAFE integers —
+/** round 9: counts (seq, tokens, turns, status) are non-negative SAFE integers —
  *  negative values, NaN, Infinity, and fractional values are rejected. */
 const isNonNegativeInt = (v) => typeof v === "number" && Number.isSafeInteger(v) && v >= 0;
 const STOP_REASONS = new Set([
@@ -68,7 +68,7 @@ const MEDIA_TYPES = new Set(["image/png", "image/jpeg", "image/webp", "image/gif
 /**
  * A ContentBlock: text (text: string) or image (sourceType with the
  * documented payload — url for "url", data + mediaType for "base64").
- * 九: the two payload kinds are STRICTLY EXCLUSIVE — a url block must not
+ * round 9: the two payload kinds are STRICTLY EXCLUSIVE — a url block must not
  * carry data, a base64 block must not carry url.
  */
 function isContentBlock(v) {
@@ -102,7 +102,7 @@ function isErrorKind(v) {
 function isExecutionId(v) {
     return v.executionId === undefined || typeof v.executionId === "string";
 }
-/** A StructuredError — the shape the `error` terminal carries. 九: a
+/** A StructuredError — the shape the `error` terminal carries. round 9: a
  *  status, when present, is a non-negative safe integer (no negatives,
  *  NaN, Infinity, or fractions). */
 function isStructuredError(v) {
@@ -122,7 +122,7 @@ function isTerminal(v) {
         case "max_tokens":
             return true;
         case "max_turns":
-            return isNonNegativeInt(v.turns); // 九: a turn count is a safe integer
+            return isNonNegativeInt(v.turns); // round 9: a turn count is a safe integer
         case "error":
             return isStructuredError(v.error);
         case "aborted":
@@ -134,7 +134,7 @@ function isTerminal(v) {
     }
 }
 /**
- * Usage invariant (Area 6/九): `known: false` means the provider reported
+ * Usage invariant (Area 6/round 9): `known: false` means the provider reported
  * NO usage — every token field is null, never faked as zero. `known: true`
  * means SOME usage was reported — AT LEAST ONE field is a non-negative
  * safe integer; the others are null when the provider did not report
@@ -149,7 +149,7 @@ function isUsage(v) {
     return tokens.some((t) => isNonNegativeInt(t)) && tokens.every((t) => t === null || isNonNegativeInt(t));
 }
 /**
- * Per-variant runtime validation (五): the table is
+ * Per-variant runtime validation (round 5): the table is
  * `satisfies Record<Event["type"], ...>` — adding a variant without a
  * validator here is a compile error (ADR-0003).
  */
@@ -165,7 +165,7 @@ const EVENT_VALIDATORS = {
     tool_result: (v) => typeof v.callId === "string" &&
         isContent(v.content) &&
         typeof v.isError === "boolean" &&
-        // 九: an errorKind is only meaningful on an ERROR result.
+        // round 9: an errorKind is only meaningful on an ERROR result.
         (v.isError === true || v.errorKind === undefined) &&
         isErrorKind(v) &&
         isExecutionId(v) &&
@@ -177,7 +177,7 @@ const EVENT_VALIDATORS = {
     user_input: (v) => isContent(v.content) && isSource(v),
     compacted: (v) => Array.isArray(v.cleared) &&
         v.cleared.every((c) => isPlainObject(c) &&
-            // 第四轮: eventSeq is optional — v1 (round three) entries are
+            // round 4: eventSeq is optional — v1 (round three) entries are
             // {callId, content} and remain legal; v2 entries must carry a
             // valid eventSeq.
             (c.eventSeq === undefined || isNonNegativeInt(c.eventSeq)) &&

package/dist/protocol/extension.d.ts

@@ -2,7 +2,7 @@
  * E1 — extension approval policies: pure types, no runtime.
  *
  * An extension is a named bundle of optional capabilities: hooks (composed
- * AFTER the harness's own — 既有先行), tools (merged into the registry), and
+ * AFTER the harness's own — the existing come first), tools (merged into the registry), and
  * approval policies (the loop's policy chain, decided BEFORE the human
  * flow). This file is types-only: loading and composition live in the
  * runtime package (loadExtensions) and the kernel loop.
@@ -68,13 +68,13 @@ export interface KisoExtension {
         readonly append: string;
     };
     /**
-     * 0.1.26 (MCP 懒连接): an optional LIVE flag — the CLI's banner renders
+     * 0.1.26 (MCP lazy connection): an optional LIVE flag — the CLI's banner renders
      * "name (connecting…)" while it is true. Soft surface: absent = no
      * marker (the default).
      */
     readonly connecting?: boolean;
     /**
-     * 发现#8 (P1): the extension's shutdown action — the closing of external
+     * finding #8 (P1): the extension's shutdown action — the closing of external
      * resources it holds (child processes, connections). The LOADER is
      * responsible for calling it.
      */

package/dist/protocol/extension.js

@@ -2,7 +2,7 @@
  * E1 — extension approval policies: pure types, no runtime.
  *
  * An extension is a named bundle of optional capabilities: hooks (composed
- * AFTER the harness's own — 既有先行), tools (merged into the registry), and
+ * AFTER the harness's own — the existing come first), tools (merged into the registry), and
  * approval policies (the loop's policy chain, decided BEFORE the human
  * flow). This file is types-only: loading and composition live in the
  * runtime package (loadExtensions) and the kernel loop.

package/dist/protocol/messages.d.ts

@@ -72,7 +72,7 @@ export interface AssistantMessage {
     readonly blocks: readonly AssistantBlock[];
     readonly source?: MessageSource;
     /**
-     * 自举 P1: the turn's reasoning, derived deterministically from its
+     * bootstrap P1: the turn's reasoning, derived deterministically from its
      * `thinking` events (DeepSeek's thinking mode requires it back on
      * follow-up requests). Present only when the turn actually reasoned.
      */
@@ -96,7 +96,7 @@ export interface ToolResultMessage {
     /**
      * The seq of the `tool_result` EVENT this message was projected from —
      * the stable identity compaction uses to name WHICH result it replaced
-     * (五: the callId may repeat across runs). DERIVED, never persisted: the
+     * (round 5: the callId may repeat across runs). DERIVED, never persisted: the
      * projection attaches it as a non-enumerable field, so it is invisible
      * to deep equality with seed messages and never survives a re-derive
      * from anywhere but the log.

package/dist/tools/registry.d.ts

@@ -12,7 +12,7 @@
  * model cannot call a tool that is not in its registry — no prompt can
  * achieve that guarantee.
  *
- * 0.1.26 (MCP 懒连接): `registerLive()` adds a LIVE tool source — a
+ * 0.1.26 (MCP lazy connection): `registerLive()` adds a LIVE tool source — a
  * function returning the extension's current tools array. The array grows
  * when the extension's background connections settle (the MCP bridge
  * registers its servers' tools post-connect); the registry consults the

package/dist/tools/registry.js

@@ -12,7 +12,7 @@
  * model cannot call a tool that is not in its registry — no prompt can
  * achieve that guarantee.
  *
- * 0.1.26 (MCP 懒连接): `registerLive()` adds a LIVE tool source — a
+ * 0.1.26 (MCP lazy connection): `registerLive()` adds a LIVE tool source — a
  * function returning the extension's current tools array. The array grows
  * when the extension's background connections settle (the MCP bridge
  * registers its servers' tools post-connect); the registry consults the
@@ -49,7 +49,7 @@ export class ToolRegistry {
     list() {
         // The registered map WINS a name collision against a live source —
         // the same rule get()/has() already follow, applied here too
-        // (0.1.27 失格调查: the agent eagerly registers a sync extension's
+        // (0.1.27 the disqualification investigation: the agent eagerly registers a sync extension's
         // tools AND registers its live source — a skills/subagent/MCP status
         // tool appeared twice in toSpecs() and the real API answered
         // "400 Tool names must be unique"; the identity is the same object,

package/dist/tools/tool.d.ts

@@ -27,7 +27,7 @@ export interface ToolContext {
     readonly meta?: Readonly<Record<string, unknown>>;
 }
 /**
- * 第五轮(P1-9): a DISCRIMINATED union — `errorKind` is structurally
+ * round 5(P1-9): a DISCRIMINATED union — `errorKind` is structurally
  * impossible on a non-error result, matching the persisted-event schema
  * (an isError:false result with an errorKind would be rejected by the
  * store's validator and poison the next load).

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vincemakes/kiso-core",
-  "version": "0.1.29",
-  "description": "kiso(基礎) core — protocol, event log, loop, hooks, modes, permissions, compaction, delivery truth. The 2,000-line kernel at the bottom of the kiso framework.",
+  "version": "0.1.30",
+  "description": "kiso (foundation) core — protocol, event log, loop, hooks, modes, permissions, compaction, delivery truth. The 2,000-line kernel at the bottom of the kiso framework.",
   "type": "module",
   "license": "MIT",
   "exports": {