@code-yeongyu/senpi 2026.11.15-2 → 2026.11.15-3

package/dist/utils/image-mime.js

@@ -0,0 +1,99 @@
+/** Bytes from the start of a file that decide its image type. */
+export const IMAGE_TYPE_SNIFF_BYTES = 4100;
+const PNG_SIGNATURE = [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a];
+export function detectSupportedImageMimeType(buffer) {
+    if (startsWith(buffer, [0xff, 0xd8, 0xff])) {
+        return buffer[3] === 0xf7 ? null : "image/jpeg";
+    }
+    if (startsWith(buffer, PNG_SIGNATURE)) {
+        return isPng(buffer) && !isAnimatedPng(buffer) ? "image/png" : null;
+    }
+    if (startsWithAscii(buffer, 0, "GIF87a") || startsWithAscii(buffer, 0, "GIF89a")) {
+        return "image/gif";
+    }
+    if (startsWithAscii(buffer, 0, "RIFF") && startsWithAscii(buffer, 8, "WEBP")) {
+        return "image/webp";
+    }
+    if (startsWithAscii(buffer, 0, "BM") && isBmp(buffer)) {
+        return "image/bmp";
+    }
+    return null;
+}
+function isPng(buffer) {
+    return (buffer.length >= 16 && readUint32BE(buffer, PNG_SIGNATURE.length) === 13 && startsWithAscii(buffer, 12, "IHDR"));
+}
+function isAnimatedPng(buffer) {
+    let offset = PNG_SIGNATURE.length;
+    while (offset + 8 <= buffer.length) {
+        const chunkLength = readUint32BE(buffer, offset);
+        const chunkTypeOffset = offset + 4;
+        if (startsWithAscii(buffer, chunkTypeOffset, "acTL"))
+            return true;
+        if (startsWithAscii(buffer, chunkTypeOffset, "IDAT"))
+            return false;
+        const nextOffset = offset + 8 + chunkLength + 4;
+        if (nextOffset <= offset || nextOffset > buffer.length)
+            return false;
+        offset = nextOffset;
+    }
+    return false;
+}
+function isBmp(buffer) {
+    if (buffer.length < 26)
+        return false;
+    const declaredFileSize = readUint32LE(buffer, 2);
+    const pixelDataOffset = readUint32LE(buffer, 10);
+    const dibHeaderSize = readUint32LE(buffer, 14);
+    if (declaredFileSize !== 0 && declaredFileSize < 26)
+        return false;
+    if (pixelDataOffset < 14 + dibHeaderSize)
+        return false;
+    if (declaredFileSize !== 0 && pixelDataOffset >= declaredFileSize)
+        return false;
+    let colorPlanes;
+    let bitsPerPixel;
+    if (dibHeaderSize === 12) {
+        colorPlanes = readUint16LE(buffer, 22);
+        bitsPerPixel = readUint16LE(buffer, 24);
+    }
+    else if (dibHeaderSize >= 40 && dibHeaderSize <= 124) {
+        if (buffer.length < 30)
+            return false;
+        colorPlanes = readUint16LE(buffer, 26);
+        bitsPerPixel = readUint16LE(buffer, 28);
+    }
+    else {
+        return false;
+    }
+    return colorPlanes === 1 && [1, 4, 8, 16, 24, 32].includes(bitsPerPixel);
+}
+function readUint16LE(buffer, offset) {
+    return (buffer[offset] ?? 0) + ((buffer[offset + 1] ?? 0) << 8);
+}
+function readUint32BE(buffer, offset) {
+    return ((buffer[offset] ?? 0) * 0x1000000 +
+        ((buffer[offset + 1] ?? 0) << 16) +
+        ((buffer[offset + 2] ?? 0) << 8) +
+        (buffer[offset + 3] ?? 0));
+}
+function readUint32LE(buffer, offset) {
+    return ((buffer[offset] ?? 0) +
+        ((buffer[offset + 1] ?? 0) << 8) +
+        ((buffer[offset + 2] ?? 0) << 16) +
+        (buffer[offset + 3] ?? 0) * 0x1000000);
+}
+function startsWith(buffer, bytes) {
+    if (buffer.length < bytes.length)
+        return false;
+    return bytes.every((byte, index) => buffer[index] === byte);
+}
+function startsWithAscii(buffer, offset, text) {
+    if (buffer.length < offset + text.length)
+        return false;
+    for (let index = 0; index < text.length; index++) {
+        if (buffer[offset + index] !== text.charCodeAt(index))
+            return false;
+    }
+    return true;
+}
+//# sourceMappingURL=image-mime.js.map

package/dist/utils/mime.d.ts

@@ -1,3 +1,3 @@
-export declare function detectSupportedImageMimeType(buffer: Uint8Array): string | null;
+export { detectSupportedImageMimeType } from "./image-mime.ts";
 export declare function detectSupportedImageMimeTypeFromFile(filePath: string): Promise<string | null>;
 //# sourceMappingURL=mime.d.ts.map

package/dist/utils/mime.js

@@ -1,24 +1,6 @@
 import { open } from "node:fs/promises";
-const IMAGE_TYPE_SNIFF_BYTES = 4100;
-const PNG_SIGNATURE = [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a];
-export function detectSupportedImageMimeType(buffer) {
-    if (startsWith(buffer, [0xff, 0xd8, 0xff])) {
-        return buffer[3] === 0xf7 ? null : "image/jpeg";
-    }
-    if (startsWith(buffer, PNG_SIGNATURE)) {
-        return isPng(buffer) && !isAnimatedPng(buffer) ? "image/png" : null;
-    }
-    if (startsWithAscii(buffer, 0, "GIF87a") || startsWithAscii(buffer, 0, "GIF89a")) {
-        return "image/gif";
-    }
-    if (startsWithAscii(buffer, 0, "RIFF") && startsWithAscii(buffer, 8, "WEBP")) {
-        return "image/webp";
-    }
-    if (startsWithAscii(buffer, 0, "BM") && isBmp(buffer)) {
-        return "image/bmp";
-    }
-    return null;
-}
+import { detectSupportedImageMimeType, IMAGE_TYPE_SNIFF_BYTES } from "./image-mime.js";
+export { detectSupportedImageMimeType } from "./image-mime.js";
 export async function detectSupportedImageMimeTypeFromFile(filePath) {
     const fileHandle = await open(filePath, "r");
     try {
@@ -30,81 +12,4 @@ export async function detectSupportedImageMimeTypeFromFile(filePath) {
         await fileHandle.close();
     }
 }
-function isPng(buffer) {
-    return (buffer.length >= 16 && readUint32BE(buffer, PNG_SIGNATURE.length) === 13 && startsWithAscii(buffer, 12, "IHDR"));
-}
-function isAnimatedPng(buffer) {
-    let offset = PNG_SIGNATURE.length;
-    while (offset + 8 <= buffer.length) {
-        const chunkLength = readUint32BE(buffer, offset);
-        const chunkTypeOffset = offset + 4;
-        if (startsWithAscii(buffer, chunkTypeOffset, "acTL"))
-            return true;
-        if (startsWithAscii(buffer, chunkTypeOffset, "IDAT"))
-            return false;
-        const nextOffset = offset + 8 + chunkLength + 4;
-        if (nextOffset <= offset || nextOffset > buffer.length)
-            return false;
-        offset = nextOffset;
-    }
-    return false;
-}
-function isBmp(buffer) {
-    if (buffer.length < 26)
-        return false;
-    const declaredFileSize = readUint32LE(buffer, 2);
-    const pixelDataOffset = readUint32LE(buffer, 10);
-    const dibHeaderSize = readUint32LE(buffer, 14);
-    if (declaredFileSize !== 0 && declaredFileSize < 26)
-        return false;
-    if (pixelDataOffset < 14 + dibHeaderSize)
-        return false;
-    if (declaredFileSize !== 0 && pixelDataOffset >= declaredFileSize)
-        return false;
-    let colorPlanes;
-    let bitsPerPixel;
-    if (dibHeaderSize === 12) {
-        colorPlanes = readUint16LE(buffer, 22);
-        bitsPerPixel = readUint16LE(buffer, 24);
-    }
-    else if (dibHeaderSize >= 40 && dibHeaderSize <= 124) {
-        if (buffer.length < 30)
-            return false;
-        colorPlanes = readUint16LE(buffer, 26);
-        bitsPerPixel = readUint16LE(buffer, 28);
-    }
-    else {
-        return false;
-    }
-    return colorPlanes === 1 && [1, 4, 8, 16, 24, 32].includes(bitsPerPixel);
-}
-function readUint16LE(buffer, offset) {
-    return (buffer[offset] ?? 0) + ((buffer[offset + 1] ?? 0) << 8);
-}
-function readUint32BE(buffer, offset) {
-    return ((buffer[offset] ?? 0) * 0x1000000 +
-        ((buffer[offset + 1] ?? 0) << 16) +
-        ((buffer[offset + 2] ?? 0) << 8) +
-        (buffer[offset + 3] ?? 0));
-}
-function readUint32LE(buffer, offset) {
-    return ((buffer[offset] ?? 0) +
-        ((buffer[offset + 1] ?? 0) << 8) +
-        ((buffer[offset + 2] ?? 0) << 16) +
-        (buffer[offset + 3] ?? 0) * 0x1000000);
-}
-function startsWith(buffer, bytes) {
-    if (buffer.length < bytes.length)
-        return false;
-    return bytes.every((byte, index) => buffer[index] === byte);
-}
-function startsWithAscii(buffer, offset, text) {
-    if (buffer.length < offset + text.length)
-        return false;
-    for (let index = 0; index < text.length; index++) {
-        if (buffer[offset + index] !== text.charCodeAt(index))
-            return false;
-    }
-    return true;
-}
 //# sourceMappingURL=mime.js.map

package/docs/extensions.md

@@ -493,6 +493,12 @@ journaled terminal. Later wakes tagged with the run are admitted again, fences f
 run that has no fence does nothing. A fence alone does not pause the session, so fencing or releasing only a fence
 emits no `session_paused`/`session_resumed` and no `session_hold_changed`; each pause gets exactly one resume.
 
+`ctx.registerRunBackgroundJob({ kind, id, description?, stop })` records a background job under the turn running at
+that moment (outside a turn it records nothing), and returns the release to call once the job ended on its own. An RPC
+`interrupt` with `background: "stop"` calls `stop(turnId)` for each job that turn recorded and names it in its answer;
+`stop` ends the job without waking the session and rejects with the reason it could not. The terminal builtin records
+every background bash session this way.
+
 #### held_wakes_released
 
 `pi.on("held_wakes_released", (event, ctx) => ...)` receives
@@ -2573,7 +2579,7 @@ pi.registerShortcut("ctrl+shift+p", {
 
 Register the operation layer of the device this session's tools run on (a `ToolMachine`, for example from `createToolMachine({ ops })`). Only tools named in `OMO_TOOLS_VIA_DAEMON` use it, today `bash`, and the bash tool reads it when a command runs. With the flag on and no machine registered, bash fails with `DeviceUnavailableError` and never runs locally.
 
-One registration per session: a second one, from any extension, throws `DeviceMachineConflictError` (`code: "device_machine_conflict"`, with `registeredBy` and `attemptedBy`). A registration made by an extension whose factory then throws is discarded with the rest of that load.
+One registration per session: a second one, from any extension, throws `DeviceMachineConflictError` (`code: "device_machine_conflict"`, with `registeredBy` and `attemptedBy`). A registration made by an extension whose factory then throws is discarded with the rest of that load. If another extension registers a device machine while this load's registration is still staged (for example from an event fired during this factory), the conflict is found when the load commits: the factory cannot catch it, and the extension fails to load as a whole with `DeviceMachineConflictError`.
 
 ```typescript
 import { createToolMachine } from "@code-yeongyu/senpi";

package/docs/rpc.md

@@ -4678,6 +4678,20 @@ answers after the turn settled.
 {"type": "response", "command": "interrupt", "success": true, "data": {"interrupted": true, "turnId": "3"}}
 ```
 
+With `"background": "stop"` the command also stops the background jobs the interrupted turn started: each bash
+session that turn ran with `run_in_background`, or that auto-detached from the foreground, while that turn was running.
+Sessions an earlier turn started keep running. The stop happens after the turn settled, and the answer then carries
+`background: { stopped, failed }`: `stopped` names each job as `{ kind: "bash", id, description? }`, and `failed`
+names a job it could not stop with its `reason` (a session on the tool child under `--tool-runtime child`, or one
+still running after TERM then KILL). An idle session, or a `turnId` naming another turn, answers both lists empty.
+A stopped session's exit notice does not start a turn: the model reads `Background terminal session <id> was stopped
+when turn <turnId> was interrupted` at its next turn. Without the field nothing but the turn stops, as before.
+
+```json
+{"type": "interrupt", "turnId": "3", "background": "stop"}
+{"type": "response", "command": "interrupt", "success": true, "data": {"interrupted": true, "turnId": "3", "background": {"stopped": [{"kind": "bash", "id": "bash_1", "description": "sleep 60"}], "failed": []}}}
+```
+
 With `"intent": "stop"` (on `abort` or `interrupt`) the command is a user Stop: the session is paused before the
 turn is stopped, and automatic wakes that arrive later (terminal and monitor notices, detached eval cells, goal
 continuations, task and team deliveries) are kept as notices instead of starting a turn. Only a connection that

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/senpi",
-	"version": "2026.11.15-2",
+	"version": "2026.11.15-3",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"piConfig": {
@@ -63,6 +63,10 @@
 		"./presenter-authority": {
 			"types": "./dist/presenter-authority-slot.d.ts",
 			"import": "./dist/presenter-authority-slot.js"
+		},
+		"./tools-core": {
+			"types": "./dist/tools-core.d.ts",
+			"import": "./dist/tools-core.js"
 		}
 	},
 	"files": [
@@ -92,10 +96,10 @@
 	},
 	"dependencies": {
 		"@earendil-works/chord": "0.99.1",
-		"@earendil-works/pi-agent-core": "npm:@code-yeongyu/senpi-agent-core@2026.11.15-2",
-		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.11.15-2",
-		"@earendil-works/pi-realm-registry": "npm:@code-yeongyu/senpi-realm-registry@2026.11.15-2",
-		"@earendil-works/pi-tui": "npm:@code-yeongyu/senpi-tui@2026.11.15-2",
+		"@earendil-works/pi-agent-core": "npm:@code-yeongyu/senpi-agent-core@2026.11.15-3",
+		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.11.15-3",
+		"@earendil-works/pi-realm-registry": "npm:@code-yeongyu/senpi-realm-registry@2026.11.15-3",
+		"@earendil-works/pi-tui": "npm:@code-yeongyu/senpi-tui@2026.11.15-3",
 		"@silvia-odwyer/photon-node": "0.3.4",
 		"ajv": "8.20.0",
 		"chalk": "6.0.0",
@@ -116,8 +120,8 @@
 		"yaml": "2.9.1",
 		"@anthropic-ai/claude-agent-sdk": "0.3.321",
 		"@anthropic-ai/sdk": "0.127.0",
-		"@code-yeongyu/senpi-codemode": "2026.11.15-2",
-		"@earendil-works/pi-pty": "npm:@code-yeongyu/senpi-pty@2026.11.15-2",
+		"@code-yeongyu/senpi-codemode": "2026.11.15-3",
+		"@earendil-works/pi-pty": "npm:@code-yeongyu/senpi-pty@2026.11.15-3",
 		"@modelcontextprotocol/sdk": "1.32.1",
 		"@mozilla/readability": "0.6.0",
 		"linkedom": "0.18.13",

package/vendor/senpi-machine-ops/files/local-files.js

@@ -1,6 +1,6 @@
 import { constants } from "node:fs";
 import { access, mkdir, open, readdir, readFile, stat, writeFile } from "node:fs/promises";
-import { dirname, isAbsolute } from "node:path";
+import { dirname, isAbsolute, resolve, sep } from "node:path";
 import { MachineOpError } from "../errors.js";
 import { checkPath, gated, resolveOpPath } from "../policy/gate.js";
 import { localGlob } from "./glob.js";
@@ -136,12 +136,20 @@ export function createLocalFileOps(options) {
             }));
         },
         async glob(req, ctx) {
-            const cwd = resolveOpPath(req.cwd ?? ".", ctx);
-            if (ctx.scope.root !== undefined && (isAbsolute(req.pattern) || req.pattern.split(/[\\/]/).includes(".."))) {
-                throw new MachineOpError("policy_denied", "a glob pattern may not leave the scope root");
+            let cwd = resolveOpPath(req.cwd ?? ".", ctx);
+            let pattern = req.pattern;
+            if (ctx.scope.root !== undefined && (isAbsolute(pattern) || pattern.split(/[\\/]/).includes(".."))) {
+                // An absolute or ".." pattern is judged by where its fixed part resolves, like every other path: the
+                // check below allows it inside the scope root and refuses it outside.
+                const split = splitGlobBase(pattern, cwd);
+                if (split === undefined) {
+                    throw new MachineOpError("policy_denied", "a glob pattern may not use '..' after a wildcard");
+                }
+                cwd = split.base;
+                pattern = split.rest;
             }
             await checkPath(cwd, "enumerate", "files.glob", ctx);
-            return gated("files.glob", req, ctx, () => localGlob(req.pattern, cwd, req.limit, ctx.signal, options.resolveFd));
+            return gated("files.glob", req, ctx, () => localGlob(pattern, cwd, req.limit, ctx.signal, options.resolveFd));
         },
         async grep(req, ctx) {
             const path = resolveOpPath(req.path, ctx);
@@ -168,4 +176,25 @@ export function createLocalFileOps(options) {
         },
     };
 }
+const GLOB_SYNTAX = /[*?[\]{}]/;
+/**
+ * Split a glob pattern into the directory its fixed leading segments name (resolved against `cwd`) and the rest,
+ * which starts at the first segment with glob syntax. A pattern with no glob syntax splits before its last segment; one
+ * ending in a separator lists that directory.
+ * Undefined when ".." follows a wildcard: where that lands is known only after matching.
+ */
+function splitGlobBase(pattern, cwd) {
+    const segments = pattern.split(/[\\/]/);
+    const firstGlob = segments.findIndex((segment) => GLOB_SYNTAX.test(segment));
+    const cut = firstGlob === -1 ? segments.length - 1 : firstGlob;
+    const fixed = segments.slice(0, cut);
+    const rest = segments.slice(cut);
+    if (rest.includes(".."))
+        return undefined;
+    // A pattern ending in a separator (`<root>/`, `../dir/`) names a directory: list its entries, as `*` would.
+    if (rest.join("/") === "")
+        return { base: isAbsolute(pattern) ? resolve(sep, ...fixed) : resolve(cwd, ...fixed), rest: "*" };
+    const base = isAbsolute(pattern) ? resolve(sep, ...fixed) : resolve(cwd, ...fixed);
+    return { base, rest: rest.join("/") };
+}
 //# sourceMappingURL=local-files.js.map