@code-yeongyu/senpi 2026.7.11 → 2026.7.13

package/node_modules/@babel/types/lib/validators/validate.js

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = validate;
+exports.validateChild = validateChild;
+exports.validateField = validateField;
+exports.validateInternal = validateInternal;
+var _index = require("../definitions/index.js");
+function validate(node, key, val) {
+  if (!node) return;
+  const fields = _index.NODE_FIELDS[node.type];
+  if (!fields) return;
+  const field = fields[key];
+  validateField(node, key, val, field);
+  validateChild(node, key, val);
+}
+function validateInternal(field, node, key, val, maybeNode) {
+  if (!(field != null && field.validate)) return;
+  if (field.optional && val == null) return;
+  field.validate(node, key, val);
+  if (maybeNode) {
+    var _NODE_PARENT_VALIDATI;
+    const type = val.type;
+    if (type == null) return;
+    (_NODE_PARENT_VALIDATI = _index.NODE_PARENT_VALIDATIONS[type]) == null || _NODE_PARENT_VALIDATI.call(_index.NODE_PARENT_VALIDATIONS, node, key, val);
+  }
+}
+function validateField(node, key, val, field) {
+  if (!(field != null && field.validate)) return;
+  if (field.optional && val == null) return;
+  field.validate(node, key, val);
+}
+function validateChild(node, key, val) {
+  var _NODE_PARENT_VALIDATI2;
+  const type = val == null ? void 0 : val.type;
+  if (type == null) return;
+  (_NODE_PARENT_VALIDATI2 = _index.NODE_PARENT_VALIDATIONS[type]) == null || _NODE_PARENT_VALIDATI2.call(_index.NODE_PARENT_VALIDATIONS, node, key, val);
+}
+
+//# sourceMappingURL=validate.js.map

package/node_modules/@babel/types/lib/validators/validate.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_index","require","validate","node","key","val","fields","NODE_FIELDS","type","field","validateField","validateChild","validateInternal","maybeNode","optional","_NODE_PARENT_VALIDATI","NODE_PARENT_VALIDATIONS","call","_NODE_PARENT_VALIDATI2"],"sources":["../../src/validators/validate.ts"],"sourcesContent":["import {\n  NODE_FIELDS,\n  NODE_PARENT_VALIDATIONS,\n  type FieldOptions,\n} from \"../definitions/index.ts\";\nimport type * as t from \"../index.ts\";\n\nexport default function validate(\n  node: t.Node | undefined | null,\n  key: string,\n  val: unknown,\n): void {\n  if (!node) return;\n\n  const fields = NODE_FIELDS[node.type];\n  if (!fields) return;\n\n  const field = fields[key];\n  validateField(node, key, val, field);\n  validateChild(node, key, val);\n}\n\nexport function validateInternal(\n  field: FieldOptions,\n  node: t.Node | undefined | null,\n  key: string,\n  val: unknown,\n  maybeNode?: 1,\n): void {\n  if (!field?.validate) return;\n  if (field.optional && val == null) return;\n\n  field.validate(node, key, val);\n\n  if (maybeNode) {\n    const type = (val as t.Node).type;\n    if (type == null) return;\n    NODE_PARENT_VALIDATIONS[type]?.(node, key, val);\n  }\n}\n\nexport function validateField(\n  node: t.Node | undefined | null,\n  key: string,\n  val: unknown,\n  field: FieldOptions | undefined | null,\n): void {\n  if (!field?.validate) return;\n  if (field.optional && val == null) return;\n\n  field.validate(node, key, val);\n}\n\nexport function validateChild(\n  node: t.Node | undefined | null,\n  key: string | { toString(): string },\n  val?: unknown,\n) {\n  const type = (val as t.Node)?.type;\n  if (type == null) return;\n  NODE_PARENT_VALIDATIONS[type]?.(node, key, val);\n}\n"],"mappings":";;;;;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAOe,SAASC,QAAQA,CAC9BC,IAA+B,EAC/BC,GAAW,EACXC,GAAY,EACN;EACN,IAAI,CAACF,IAAI,EAAE;EAEX,MAAMG,MAAM,GAAGC,kBAAW,CAACJ,IAAI,CAACK,IAAI,CAAC;EACrC,IAAI,CAACF,MAAM,EAAE;EAEb,MAAMG,KAAK,GAAGH,MAAM,CAACF,GAAG,CAAC;EACzBM,aAAa,CAACP,IAAI,EAAEC,GAAG,EAAEC,GAAG,EAAEI,KAAK,CAAC;EACpCE,aAAa,CAACR,IAAI,EAAEC,GAAG,EAAEC,GAAG,CAAC;AAC/B;AAEO,SAASO,gBAAgBA,CAC9BH,KAAmB,EACnBN,IAA+B,EAC/BC,GAAW,EACXC,GAAY,EACZQ,SAAa,EACP;EACN,IAAI,EAACJ,KAAK,YAALA,KAAK,CAAEP,QAAQ,GAAE;EACtB,IAAIO,KAAK,CAACK,QAAQ,IAAIT,GAAG,IAAI,IAAI,EAAE;EAEnCI,KAAK,CAACP,QAAQ,CAACC,IAAI,EAAEC,GAAG,EAAEC,GAAG,CAAC;EAE9B,IAAIQ,SAAS,EAAE;IAAA,IAAAE,qBAAA;IACb,MAAMP,IAAI,GAAIH,GAAG,CAAYG,IAAI;IACjC,IAAIA,IAAI,IAAI,IAAI,EAAE;IAClB,CAAAO,qBAAA,GAAAC,8BAAuB,CAACR,IAAI,CAAC,aAA7BO,qBAAA,CAAAE,IAAA,CAAAD,8BAAuB,EAASb,IAAI,EAAEC,GAAG,EAAEC,GAAG,CAAC;EACjD;AACF;AAEO,SAASK,aAAaA,CAC3BP,IAA+B,EAC/BC,GAAW,EACXC,GAAY,EACZI,KAAsC,EAChC;EACN,IAAI,EAACA,KAAK,YAALA,KAAK,CAAEP,QAAQ,GAAE;EACtB,IAAIO,KAAK,CAACK,QAAQ,IAAIT,GAAG,IAAI,IAAI,EAAE;EAEnCI,KAAK,CAACP,QAAQ,CAACC,IAAI,EAAEC,GAAG,EAAEC,GAAG,CAAC;AAChC;AAEO,SAASM,aAAaA,CAC3BR,IAA+B,EAC/BC,GAAoC,EACpCC,GAAa,EACb;EAAA,IAAAa,sBAAA;EACA,MAAMV,IAAI,GAAIH,GAAG,oBAAHA,GAAG,CAAaG,IAAI;EAClC,IAAIA,IAAI,IAAI,IAAI,EAAE;EAClB,CAAAU,sBAAA,GAAAF,8BAAuB,CAACR,IAAI,CAAC,aAA7BU,sBAAA,CAAAD,IAAA,CAAAD,8BAAuB,EAASb,IAAI,EAAEC,GAAG,EAAEC,GAAG,CAAC;AACjD","ignoreList":[]}

package/node_modules/@babel/types/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@babel/types",
+  "version": "7.29.7",
+  "description": "Babel Types is a Lodash-esque utility library for AST nodes",
+  "author": "The Babel Team (https://babel.dev/team)",
+  "homepage": "https://babel.dev/docs/en/next/babel-types",
+  "bugs": "https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A%20types%22+is%3Aopen",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-types"
+  },
+  "main": "./lib/index.js",
+  "dependencies": {
+    "@babel/helper-string-parser": "^7.29.7",
+    "@babel/helper-validator-identifier": "^7.29.7"
+  },
+  "devDependencies": {
+    "@babel/generator": "^7.29.7",
+    "@babel/helper-fixtures": "^7.29.7",
+    "@babel/parser": "^7.29.7"
+  },
+  "engines": {
+    "node": ">=6.9.0"
+  },
+  "type": "commonjs",
+  "types": "./lib/index-legacy.d.ts",
+  "typesVersions": {
+    ">=4.1": {
+      "lib/index-legacy.d.ts": [
+        "lib/index.d.ts"
+      ]
+    }
+  }
+}

package/node_modules/@code-yeongyu/senpi-codemode/CHANGELOG.md

@@ -1,16 +1,23 @@
 # Changelog
 
-## [Unreleased]
+## [2026.7.13] - 2026-07-13
 
 ### Added
 
 - Added the source-only `@code-yeongyu/senpi-codemode` workspace package scaffold.
 - Added codemode settings loading, interpreter detection, prompt generation, loopback bridge helpers, and persistent JS/Python/Ruby/Julia kernel building blocks.
+- Added structured kernel status events from the bridge through TUI rendering.
+- Added `agent()` and `output()` bridges that delegate through configured task-tool contracts.
+- Added bounded streaming output with session-adjacent spill files and plain-path notices.
+- Added eval render parity for highlighted cells, status rows, task progress, JSON displays, truncation warnings, and image fallbacks.
+- Added JavaScript import rewriting for persistent eval cells.
 
 ### Changed
 
-- Documented that the current exported extension factory is still a no-op until the `eval` tool and bundled host loading land.
+- Activated the exported extension factory so the bundled package registers and reconfigures the persistent-kernel `eval` tool in Senpi sessions.
 - Improved `eval` TUI rendering with streaming status and timing, bounded expandable previews, width-safe ANSI/CJK/emoji reflow, nested tool-call state, and terminal-aware image fallbacks.
+- Re-register the eval prompt and schema at session start after settings, interpreter availability, and active task-tool names resolve.
+- Recorded the completed oh-my-pi eval-port provenance for this extension; task delegation and artifact handling follow Senpi extension boundaries.
 
 ### Fixed
 
@@ -20,3 +27,4 @@
 - Fixed a temporal-dead-zone crash in the `eval` tool: subprocess kernels (py/rb/jl) emit their `ready` frame synchronously during kernel startup, which invoked the message handler before the `kernel` binding initialized and crashed the whole agent process. The self-referential binding is now hoisted so startup frames no longer throw.
 - Fixed cell-output misattribution on reused persistent kernels: `getKernel` now rebinds the per-cell `onMessage` on every call, so a second (and later) cell's streamed `text`/`display`/`log` output is delivered to that cell instead of the previous one.
 - Fixed the Ruby kernel corrupting its JSONL protocol channel: user `puts`/`print` output is now captured via a redirected `$stdout` and emitted as `text` frames instead of being written directly onto the shared stdout stream.
+- Fixed the Ruby kernel raising `ArgumentError: unknown keywords` on Ruby 3.0+ (e.g. CI's Ruby 3.x, while local Ruby 2.6 masked it): `env()`/`read()`/`write()` passed braceless string-keyed hashes to `__senpi_emit_status`, which Ruby 3 parses as keyword arguments against its `force:` keyword parameter instead of the positional `fields` hash. The field hashes are now wrapped in explicit braces so status emission and final-expression auto-display work identically across Ruby 2.6–3.4.

package/node_modules/@code-yeongyu/senpi-codemode/README.md

@@ -1,38 +1,44 @@
 # @code-yeongyu/senpi-codemode
 
-Source-only senpi extension package for codemode: an in-progress port of
-oh-my-pi feature 01, "Code execution w/ tool-calling".
-
-The current package ships the codemode building blocks: settings loading,
-interpreter detection, bridge protocol/server helpers, prompt text, persistent
-language kernels, and prelude helpers. The exported extension factory is still a
-no-op in this Wave 3 source, so installing this package does not yet register an
-`eval` tool.
+`@code-yeongyu/senpi-codemode` is Senpi's source-only persistent-kernel
+`eval` extension. It registers `eval`, owns one persistent kernel per enabled
+language, and re-registers the tool at session start after configuration,
+interpreter availability, and active task-tool names are known.
+
+## Capabilities
+
+- Persistent JavaScript, Python, Ruby, and Julia cells. State survives later
+  cells in the same language until reset, restart, or session disposal.
+- Loopback, bearer-authenticated kernel bridge with bounded JSONL frames.
+- Structured status events for file operations, environment access, phases,
+  bridge activity, and delegated task progress.
+- Bounded streaming output with head/tail previews, column clamping, and
+  session-adjacent spill files for large streams.
+- TUI and HTML-export rendering for syntax-highlighted cells, status rows,
+  task progress, structured display values, truncation warnings, and image
+  fallbacks.
+- JavaScript import rewriting for supported local modules and package imports
+  in the persistent Node.js worker.
 
 ## Kernels
 
-JavaScript is implemented with a Node.js worker and is always available when the
-package runs on the supported Node version. Python, Ruby, and Julia are optional
-runtime interpreters:
-
-| Language | Default | Interpreter |
-|----------|---------|-------------|
-| `js` | enabled | Node.js worker |
-| `py` | enabled | `python3` or `python` on POSIX; `python`, `py -3`, or `python3` on Windows |
-| `rb` | disabled | `ruby` |
-| `jl` | disabled | `julia` |
+| Language | Default | Runtime | Notes |
+| --- | --- | --- | --- |
+| `js` | enabled | Node.js worker | Requires Node.js 24 or newer; supports top-level `await` and `return`. |
+| `py` | enabled | `python3` or `python` | Optional interpreter detected at session start. |
+| `rb` | disabled | `ruby` | Optional interpreter detected at session start. |
+| `jl` | disabled | `julia` | Optional interpreter detected at session start. |
 
-Missing optional interpreters should be treated as runtime capability gaps, not
-install failures.
+A missing optional interpreter removes that language from the session's `eval`
+schema; it is not an installation failure.
 
 ## Settings
 
-Codemode reads standalone JSON config files. Project config wins over global
-config:
+Configuration is loaded in this order:
 
-1. `.senpi/codemode.json`
+1. `.senpi/codemode.json` in the session working directory
 2. `~/.senpi/agent/codemode.json`
-3. built-in defaults
+3. Built-in defaults
 
 ```json
 {
@@ -43,60 +49,104 @@ config:
     "jl": false
   },
   "cellTimeoutSeconds": 30,
-  "parallelPoolWidth": 4
+  "parallelPoolWidth": 4,
+  "taskTools": {
+    "task": "task",
+    "output": "task_output"
+  },
+  "outputSink": {
+    "headBytes": 20480,
+    "maxColumns": 768
+  },
+  "statusEvents": true
 }
 ```
 
-Invalid JSON or invalid schema falls back to defaults with a warning. These are
-package-local settings; senpi's main `settings.json` has no `codemode` key in the
-current source.
-
-## Prelude API
-
-The prompt and kernels expose a shared prelude contract for cells. Availability
-depends on the language implementation and on whether the future `eval` tool is
-wired into the host.
-
-| Helper | Purpose |
-|--------|---------|
-| `display(value)` | Emit a cell result or rich display payload. |
-| `print(value, ...)` | Emit text output. |
-| `read(path, offset?, limit?)` | Read a text file with optional 1-indexed line slicing. |
-| `write(path, content)` | Write a file, creating parent directories. |
-| `env(key?, value?)` | Read or set environment values inside the kernel. |
-| `tool.<name>(args)` | Call an active senpi tool through the host bridge. |
-| `completion(prompt, ...)` | Request a one-shot host completion. |
-| `parallel(thunks)` | Run thunks through a bounded pool while preserving result order. |
-| `pipeline(items, ...stages)` | Map items through sequential pipeline stages. |
-| `log(message)` | Emit a progress line. |
-| `phase(title)` | Start a progress phase. |
-
-Cells are intended to be incremental: one call is one logical step, and
-top-level state persists per language until reset or kernel restart.
-
-## Security
-
-Kernels run locally with the same user permissions as senpi. The loopback bridge
-binds to `127.0.0.1` and authenticates each request with a per-session bearer
-token. Tool calls routed through `tool.<name>` are designed to pass through
-senpi's normal permission system and extension hook pipeline via
-`pi.executeTool`; that host integration is not yet wired in this package's
-factory in the current source.
-
-## Disable
-
-Because the current factory registers no tools, there is nothing to disable yet.
-After the planned `eval` tool and bundled loader land, the intended disable
-surfaces are:
-
-- `--exclude-tools eval`
-- `disabledBuiltinExtensions: ["codemode"]` in senpi settings
-
-## Troubleshooting
-
-| Symptom | Check |
-|---------|-------|
-| Python, Ruby, or Julia cells are unavailable | Confirm the interpreter is installed and visible on `PATH`; optional interpreters are not npm dependencies. |
-| A cell times out | Increase `cellTimeoutSeconds` or the future per-call timeout only for genuinely long work. |
-| State disappeared | The language kernel was reset, restarted, or crashed; rerun only the setup needed for that language. |
-| `tool.<name>` or `completion()` is unavailable | The host `eval` tool integration is deferred in the current Wave 3 source. |
+| Key | Default | Effect |
+| --- | --- | --- |
+| `languages` | `py`/`js` enabled; `rb`/`jl` disabled | Selects desired languages before interpreter detection. |
+| `cellTimeoutSeconds` | `30` | Idle timeout for one cell unless the call supplies `timeout`. |
+| `parallelPoolWidth` | `4` | Maximum concurrent `parallel()` thunks. |
+| `taskTools.task` | `"task"` | Registered tool name used by `agent()`. |
+| `taskTools.output` | `"task_output"` | Registered tool name used by `output()`. |
+| `outputSink.headBytes` | `20480` | Bytes retained from the beginning of a middle-truncated preview; `0` disables it. |
+| `outputSink.maxColumns` | `768` | Maximum rendered output columns; `0` disables column clamping. |
+| `statusEvents` | `true` | Enables kernel status-event forwarding and rendering. |
+
+`SENPI_CODEMODE_PY`, `SENPI_CODEMODE_JS`, `SENPI_CODEMODE_RB`, and
+`SENPI_CODEMODE_JL` override the corresponding file setting. `1` or `true`
+enables; `0` or `false` disables. Any other value leaves the file setting in
+effect.
+
+Malformed JSON or invalid settings fall back to defaults with a warning.
+
+## Cell helpers
+
+Python, JavaScript, Ruby, and Julia expose the same conceptual helpers. Python,
+Ruby, and Julia use trailing keyword options; JavaScript uses one trailing
+options object and asynchronous helpers are `await`-able.
+
+| Helper | Contract |
+| --- | --- |
+| `display(value)` | Emits text, structured JSON, markdown, or supported image display data. |
+| `print(value, ...)` | Emits text output. |
+| `read(path, offset?, limit?)` | Reads text with 1-indexed line slicing. `local://` paths resolve under the session artifact root. |
+| `write(path, content)` | Creates parent directories and writes text. `local://` paths persist in the session artifact root. |
+| `env(key?, value?)` | Reads all kernel environment values, one value, or sets one value. |
+| `tool.<name>(args)` | Invokes an active Senpi tool through the normal `pi.executeTool` pipeline. |
+| `completion(prompt, model?, system?, schema?)` | Requests a one-shot host completion; `schema` asks the host to parse structured output. |
+| `agent(prompt, ...)` | Delegates to the configured active `taskTools.task` tool. Supports background handles and structured JSON results. |
+| `output(ids, format?, offset?, limit?)` | Delegates transcript retrieval to the configured active `taskTools.output` tool. |
+| `parallel(thunks)` | Runs thunks through the configured bounded pool while preserving input order. |
+| `pipeline(items, ...stages)` | Applies stages left to right with a barrier between stages. |
+| `log(message)` / `phase(title)` | Emits progress text and starts a status phase. |
+
+`agent()` is available only when the configured task tool is active in the
+session. `output()` similarly requires the configured task-output tool. Missing
+tools produce a clear availability error instead of importing an orchestration
+package. `agent()` delegates through the tool contract, so task-engine
+permissions, progress updates, and transcripts remain owned by that engine.
+`isolated`, `apply`, and `merge` are accepted for compatibility but emit a
+warning because this task-engine integration has no isolation model.
+
+## Output and artifacts
+
+Cell output is streamed while the cell runs. Large streams spill to an absolute
+file after the default 50 KiB threshold. With a session file such as
+`/path/session.jsonl`, artifacts live in `/path/session-artifacts/`; sessions
+without a file use a unique temporary directory. Truncated results include a
+plain-path notice such as `[Full output: /absolute/path/eval-….log]`.
+
+## Deliberate differences from oh-my-pi
+
+- There is no `budget` helper.
+- There is no `artifact://` protocol. Spill references are ordinary absolute
+  file paths.
+- `agent()` and `output()` compose registered task tools through
+  `pi.executeTool`; this package does not import a task-engine workspace
+  package.
+- Task transcript formats are limited to full (`raw`) and trailing (`tail`)
+  output. Query, JSON, and stripped metadata formats are task-engine concerns.
+
+## Security and lifecycle
+
+Kernels run locally with the invoking user's permissions. The bridge listens on
+loopback only and authenticates each session with a random bearer token.
+Session generations fence retired kernels and callbacks; each cell settles once
+across completion, errors, cancellation, timeout, bridge failure, or a kernel
+crash.
+
+## Validation
+
+```bash
+cd packages/senpi-codemode
+npm test
+
+cd ../..
+npm run check
+```
+
+Direct real-surface QA drivers live in `scripts/qa-*.ts`: kernel cells
+(`qa-py-cell.ts`, `qa-js-cell.ts`, `qa-rb-cell.ts`, `qa-jl-cell.ts`), end-to-end
+extension execution (`qa-e2e-eval.ts`), and renderer output
+(`qa-render-dump.ts`).

package/node_modules/@code-yeongyu/senpi-codemode/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/senpi-codemode",
-	"version": "2026.7.11",
+	"version": "2026.7.13",
 	"description": "Source-only senpi extension package for codemode evaluation tools",
 	"type": "module",
 	"main": "./src/index.ts",
@@ -29,14 +29,15 @@
 		"access": "public"
 	},
 	"dependencies": {
-		"@earendil-works/pi-ai": "^2026.7.11",
+		"@babel/parser": "7.29.7",
+		"@earendil-works/pi-ai": "^2026.7.13",
 		"typebox": "1.1.38"
 	},
 	"peerDependencies": {
 		"@code-yeongyu/senpi": "*"
 	},
 	"devDependencies": {
-		"@code-yeongyu/senpi": "2026.7.11"
+		"@code-yeongyu/senpi": "2026.7.13"
 	},
 	"keywords": [
 		"senpi",

package/node_modules/@code-yeongyu/senpi-codemode/src/bridge/protocol.ts

@@ -11,9 +11,14 @@ const bridgeErrorSchema = Type.Object({
 	code: Type.Optional(Type.String()),
 });
 
+const statusEventSchema = Type.Object({ op: Type.String() }, { additionalProperties: true });
+
 const connectionConfigSchema = Type.Object({
 	port: Type.Integer({ minimum: 1, maximum: 65_535 }),
 	token: Type.String({ minLength: 1 }),
+	localRoots: Type.Optional(Type.Record(Type.String(), Type.String())),
+	artifactsDir: Type.Optional(Type.String()),
+	parallelPoolWidth: Type.Optional(Type.Integer({ minimum: 1 })),
 });
 
 const hostToKernelMessageSchema = Type.Union([
@@ -70,6 +75,7 @@ const kernelToHostMessageSchema = Type.Union([
 	}),
 	Type.Object({ type: Type.Literal("log"), message: Type.String() }),
 	Type.Object({ type: Type.Literal("phase"), title: Type.String() }),
+	Type.Object({ type: Type.Literal("status"), event: statusEventSchema }),
 	Type.Object({
 		type: Type.Literal("result"),
 		cellId: Type.String({ minLength: 1 }),
@@ -89,11 +95,18 @@ const kernelToHostMessageSchema = Type.Union([
 
 const bridgeMessageSchema = Type.Union([hostToKernelMessageSchema, kernelToHostMessageSchema]);
 
+export type EvalStatusEvent = { op: string } & Record<string, unknown>;
 export type BridgeError = Static<typeof bridgeErrorSchema>;
 export type BridgeConnectionConfig = Static<typeof connectionConfigSchema>;
 export type HostToKernelMessage = Static<typeof hostToKernelMessageSchema>;
-export type KernelToHostMessage = Static<typeof kernelToHostMessageSchema>;
-export type BridgeMessage = Static<typeof bridgeMessageSchema>;
+type KernelToHostMessageSchema = Static<typeof kernelToHostMessageSchema>;
+type BridgeMessageSchema = Static<typeof bridgeMessageSchema>;
+export type KernelToHostMessage =
+	| Exclude<KernelToHostMessageSchema, { type: "status" }>
+	| { type: "status"; event: EvalStatusEvent };
+export type BridgeMessage =
+	| Exclude<BridgeMessageSchema, { type: "status" }>
+	| { type: "status"; event: EvalStatusEvent };
 
 export type BridgeDecodeErrorCode =
 	| "empty_frame"

package/node_modules/@code-yeongyu/senpi-codemode/src/bridge/reserved.ts

@@ -0,0 +1,9 @@
+/** Cross-kernel bridge names shared by preludes and host adapters. */
+/** Canonical oh-my-pi agent bridge tool name. */
+export const RESERVED_AGENT_TOOL = "__agent__" as const;
+/** ADAPTATION: senpi delegates output through a reserved kernel-side tool name. */
+export const RESERVED_OUTPUT_TOOL = "__output__" as const;
+/** Canonical oh-my-pi eval-timeout pause operation. */
+export const TIMEOUT_PAUSE_OP = "timeout-pause" as const;
+/** Canonical oh-my-pi eval-timeout resume operation. */
+export const TIMEOUT_RESUME_OP = "timeout-resume" as const;

package/node_modules/@code-yeongyu/senpi-codemode/src/bridges/agent-bridge.ts

@@ -0,0 +1,197 @@
+import type { AgentToolResult } from "@code-yeongyu/senpi";
+import { type Static, Type } from "typebox";
+import { Check, Errors } from "typebox/value";
+import type { EvalStatusEvent, ExecuteTool } from "../tool/types.ts";
+
+const agentArgsSchema = Type.Object(
+	{
+		prompt: Type.String({ minLength: 1 }),
+		agent: Type.Optional(Type.String({ minLength: 1 })),
+		model: Type.Optional(Type.String({ minLength: 1 })),
+		label: Type.Optional(Type.String()),
+		schema: Type.Optional(Type.Unknown()),
+		handle: Type.Optional(Type.Boolean()),
+		isolated: Type.Optional(Type.Boolean()),
+		apply: Type.Optional(Type.Boolean()),
+		merge: Type.Optional(Type.Boolean()),
+	},
+	{ additionalProperties: false },
+);
+
+const unsupportedIsolationWarning = "isolated/apply/merge unsupported (no isolation in task engine)";
+const taskIdPattern = /\bst_[A-Za-z0-9_-]+\b/;
+const droppedOptionNames = ["isolated", "apply", "merge"] as const;
+
+type AgentArgs = Static<typeof agentArgsSchema>;
+type TaskParams = {
+	readonly prompt: string;
+	readonly subagent_type?: string;
+	readonly model?: string;
+	readonly name?: string;
+	readonly run_in_background: boolean;
+};
+type ProgressContext = { readonly fallbackId: string; readonly warning?: string };
+
+export type AgentExecuteTool = ExecuteTool & {
+	readonly isToolAvailable?: (name: string) => boolean;
+};
+
+export interface RunEvalAgentOptions {
+	readonly callId: string;
+	readonly taskToolName: string;
+	readonly executeTool: AgentExecuteTool;
+	readonly signal?: AbortSignal;
+	readonly emitStatus?: (event: EvalStatusEvent) => void;
+}
+
+export type EvalAgentResult =
+	| { readonly text: string }
+	| { readonly text: string; readonly data: unknown }
+	| { readonly text: string; readonly parseError: string }
+	| { readonly text: string; readonly id: string; readonly handle: string };
+
+class AgentArgumentsError extends Error {
+	readonly name = "AgentArgumentsError";
+
+	constructor(summary: string) {
+		super(`agent() received invalid arguments: ${summary}`);
+	}
+}
+
+class AgentUnavailableError extends Error {
+	readonly name = "AgentUnavailableError";
+
+	constructor(toolName: string) {
+		super(`agent() unavailable: no "${toolName}" tool is registered in this session`);
+	}
+}
+
+class AgentHandleError extends Error {
+	readonly name = "AgentHandleError";
+
+	constructor() {
+		super("agent() background task result did not include a task id");
+	}
+}
+
+export async function runEvalAgent(args: unknown, options: RunEvalAgentOptions): Promise<EvalAgentResult> {
+	const parsed = parseAgentArgs(args);
+	const structured = Object.hasOwn(parsed, "schema");
+	const warning = droppedOptionsWarning(parsed);
+	const fallbackId = parsed.label ?? options.callId;
+	if (warning) options.emitStatus?.({ op: "agent", id: fallbackId, status: "running", warning });
+
+	// omp assertNotPlanMode intentionally dropped: senpi has no plan mode
+	// senpi-task children lose task tools, so recursion self-gates without a depth counter.
+	if (options.executeTool.isToolAvailable?.(options.taskToolName) === false) {
+		throw new AgentUnavailableError(options.taskToolName);
+	}
+
+	let result: AgentToolResult<unknown>;
+	try {
+		result = await options.executeTool(options.taskToolName, toTaskParams(parsed, structured), {
+			...(options.signal ? { signal: options.signal } : {}),
+			...(options.emitStatus
+				? {
+						onUpdate: (update: AgentToolResult<unknown>) =>
+							options.emitStatus?.(toProgressEvent(update, { fallbackId, ...(warning ? { warning } : {}) })),
+					}
+				: {}),
+		});
+	} catch (error) {
+		if (isUnavailableToolError(error)) throw new AgentUnavailableError(options.taskToolName);
+		throw error;
+	}
+
+	const text = resultText(result);
+	if (parsed.handle === true) {
+		const id = resultTaskId(result, text);
+		if (!id) throw new AgentHandleError();
+		return { text, id, handle: `agent://${id}` };
+	}
+	if (!structured) return { text };
+	return parseStructuredText(text);
+}
+
+function parseAgentArgs(value: unknown): AgentArgs {
+	if (Check(agentArgsSchema, value)) return value;
+	const summary = Errors(agentArgsSchema, value)
+		.map((error) => `${error.instancePath || "/"} ${error.message}`)
+		.join("; ");
+	throw new AgentArgumentsError(summary || "invalid value");
+}
+
+function toTaskParams(args: AgentArgs, structured: boolean): TaskParams {
+	return {
+		prompt: structured
+			? `${args.prompt}\n\nRespond ONLY with JSON matching this JSON-Schema:\n${JSON.stringify(args.schema)}`
+			: args.prompt,
+		...(args.agent === undefined ? {} : { subagent_type: args.agent }),
+		...(args.model === undefined ? {} : { model: args.model }),
+		...(args.label === undefined ? {} : { name: args.label }),
+		run_in_background: args.handle === true,
+	};
+}
+
+function parseStructuredText(text: string): EvalAgentResult {
+	try {
+		const data: unknown = JSON.parse(text);
+		return { text, data };
+	} catch (error) {
+		if (error instanceof SyntaxError) return { text, parseError: error.message };
+		throw error;
+	}
+}
+
+function droppedOptionsWarning(args: AgentArgs): string | undefined {
+	return droppedOptionNames.some((name) => Object.hasOwn(args, name)) ? unsupportedIsolationWarning : undefined;
+}
+
+function toProgressEvent(update: AgentToolResult<unknown>, context: ProgressContext): EvalStatusEvent {
+	const details = isRecord(update.details) ? update.details : undefined;
+	const id = firstString(details, ["task_id", "taskId", "id"]) ?? context.fallbackId;
+	const status = firstString(details, ["status"]) ?? "running";
+	const agent = firstString(details, ["subagent_type", "agent"]);
+	return {
+		op: "agent",
+		id,
+		status,
+		...(agent === undefined ? {} : { agent }),
+		...(context.warning === undefined ? {} : { warning: context.warning }),
+	};
+}
+
+function resultText(result: AgentToolResult<unknown>): string {
+	return result.content
+		.filter((part): part is Extract<(typeof result.content)[number], { type: "text" }> => part.type === "text")
+		.map((part) => part.text)
+		.join("\n");
+}
+
+function resultTaskId(result: AgentToolResult<unknown>, text: string): string | undefined {
+	const details = isRecord(result.details) ? result.details : undefined;
+	const detailId = firstString(details, ["task_id", "taskId", "id"]);
+	if (detailId) return detailId;
+	return text.match(taskIdPattern)?.[0];
+}
+
+function firstString(
+	record: Readonly<Record<string, unknown>> | undefined,
+	keys: readonly string[],
+): string | undefined {
+	if (!record) return undefined;
+	for (const key of keys) {
+		const value = record[key];
+		if (typeof value === "string" && value.length > 0) return value;
+	}
+	return undefined;
+}
+
+function isUnavailableToolError(error: unknown): boolean {
+	if (!isRecord(error)) return false;
+	return error.code === "unknown_tool" || error.code === "inactive_tool";
+}
+
+function isRecord(value: unknown): value is Readonly<Record<string, unknown>> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}