@hachej/boring-agent 0.4.37 → 0.4.39

package/dist/artifact-descriptor.d.ts

@@ -0,0 +1,33 @@
+import type { ResourceLocator } from '@hachej/boring-files';
+import type { TaskArtifactDescriptor } from './task-artifacts.js';
+export type PresentedArtifact = ArtifactDescriptor | TaskArtifactDescriptor;
+/** Parse file or host-task presentation without treating a record as a workspace file. */
+export declare function parsePresentedArtifact(value: unknown): PresentedArtifact | undefined;
+export declare const ARTIFACT_TYPES: readonly ["markdown", "html", "svg", "code", "canvas"];
+export type ArtifactType = typeof ARTIFACT_TYPES[number];
+/**
+ * What a tool result carries under its `artifact` key. The descriptor of `present` points at a workspace file (`target`), names the
+ * revision shown and carries no `id` or `ordinal` (both stay optional for hosts that number their own versions).
+ */
+export interface ArtifactDescriptor {
+    readonly schema: 'boring.artifact';
+    readonly version: 1;
+    readonly id?: string;
+    readonly title: string;
+    readonly type: ArtifactType;
+    readonly mediaType: string;
+    readonly language?: string;
+    readonly target: ResourceLocator;
+    readonly revision: string;
+    readonly ordinal?: number;
+}
+export type ArtifactDescriptorInput = Omit<ArtifactDescriptor, 'schema' | 'version'>;
+/** Build a descriptor, refusing anything `parseArtifact` would refuse. */
+export declare function createArtifactDescriptor(input: ArtifactDescriptorInput): ArtifactDescriptor;
+/**
+ * Strict shape check of an untrusted value (a model-visible tool result, a stored reference). Returns a fresh copy or
+ * undefined. This function has no Pi runtime dependency; `registry/pi-artifacts/artifact.ts` carries the same validator for
+ * the browser, because a copied registry item cannot import this package.
+ */
+export declare function parseArtifact(value: unknown): ArtifactDescriptor | undefined;
+//# sourceMappingURL=artifact-descriptor.d.ts.map

package/dist/artifact-descriptor.js

@@ -0,0 +1,59 @@
+import { parseTaskArtifact } from './task-artifacts.js';
+/** Parse file or host-task presentation without treating a record as a workspace file. */
+export function parsePresentedArtifact(value) { return parseArtifact(value) ?? parseTaskArtifact(value); }
+export const ARTIFACT_TYPES = ['markdown', 'html', 'svg', 'code', 'canvas'];
+const ID = /^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/;
+const LANGUAGE = /^[A-Za-z0-9+#._-]{1,32}$/;
+const isObject = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
+const hasOnly = (value, keys) => Object.keys(value).every(key => keys.includes(key));
+/** Build a descriptor, refusing anything `parseArtifact` would refuse. */
+export function createArtifactDescriptor(input) {
+    const descriptor = { schema: 'boring.artifact', version: 1, ...input };
+    const parsed = parseArtifact(descriptor);
+    if (!parsed)
+        throw new TypeError('Invalid artifact descriptor');
+    return parsed;
+}
+/**
+ * Strict shape check of an untrusted value (a model-visible tool result, a stored reference). Returns a fresh copy or
+ * undefined. This function has no Pi runtime dependency; `registry/pi-artifacts/artifact.ts` carries the same validator for
+ * the browser, because a copied registry item cannot import this package.
+ */
+export function parseArtifact(value) {
+    if (!isObject(value) || !hasOnly(value, ['schema', 'version', 'id', 'title', 'type', 'mediaType', 'language', 'target', 'revision', 'ordinal']))
+        return undefined;
+    const { id, title, type, mediaType, language, target, revision, ordinal } = value;
+    if (value['schema'] !== 'boring.artifact' || value['version'] !== 1)
+        return undefined;
+    if (id !== undefined && (typeof id !== 'string' || !ID.test(id)))
+        return undefined;
+    if (typeof title !== 'string' || !title.trim() || title.length > 200)
+        return undefined;
+    if (typeof type !== 'string' || !ARTIFACT_TYPES.includes(type))
+        return undefined;
+    if (typeof mediaType !== 'string' || !/^[a-z0-9][a-z0-9!#$&^_.+-]*\/[a-z0-9][a-z0-9!#$&^_.+-]*$/i.test(mediaType))
+        return undefined;
+    if (language !== undefined && (typeof language !== 'string' || !LANGUAGE.test(language)))
+        return undefined;
+    if (typeof revision !== 'string' || !revision || revision.length > 256)
+        return undefined;
+    if (ordinal !== undefined && (typeof ordinal !== 'number' || !Number.isSafeInteger(ordinal) || ordinal < 1))
+        return undefined;
+    if (!isObject(target) || !hasOnly(target, ['resource', 'view']) || !isObject(target['resource']) || !hasOnly(target['resource'], ['providerId', 'path']))
+        return undefined;
+    const { providerId, path } = target['resource'];
+    if (typeof providerId !== 'string' || !providerId || typeof path !== 'string' || !path || path.length > 512)
+        return undefined;
+    const view = target['view'];
+    if (!isObject(view))
+        return undefined;
+    let parsedView;
+    if (view['kind'] === 'published' && hasOnly(view, ['kind']))
+        parsedView = { kind: 'published' };
+    else if (view['kind'] === 'working' && hasOnly(view, ['kind', 'viewId']) && typeof view['viewId'] === 'string' && view['viewId'])
+        parsedView = { kind: 'working', viewId: view['viewId'] };
+    else
+        return undefined;
+    return { schema: 'boring.artifact', version: 1, ...(id === undefined ? {} : { id }), title, type: type, mediaType, ...(language === undefined ? {} : { language: language }),
+        target: { resource: { providerId, path }, view: parsedView }, revision, ...(ordinal === undefined ? {} : { ordinal }) };
+}

package/dist/artifacts.d.ts

@@ -1,44 +1,15 @@
 import type { ToolExecutionApi } from '@earendil-works/pi-durable';
 import { Type } from '@earendil-works/pi-ai';
 import type { Context } from '@earendil-works/chord';
-import type { ResourceAccess, ResourceLocator } from '@hachej/boring-files';
+import type { ResourceAccess } from '@hachej/boring-files';
 import type { WorkspaceBinding, WorkspaceResolver } from './workspaces.js';
-import type { TaskArtifactDescriptor } from './task-artifacts.js';
 export { createTaskArtifact, parseTaskArtifact, parseTaskSubject, taskSubjectKey } from './task-artifacts.js';
 export type { TaskArtifactDescriptor, TaskSubject } from './task-artifacts.js';
-export type PresentedArtifact = ArtifactDescriptor | TaskArtifactDescriptor;
-/** Parse file or host-task presentation without treating a record as a workspace file. */
-export declare function parsePresentedArtifact(value: unknown): PresentedArtifact | undefined;
+export { ARTIFACT_TYPES, createArtifactDescriptor, parseArtifact, parsePresentedArtifact } from './artifact-descriptor.js';
+export type { ArtifactDescriptor, ArtifactDescriptorInput, ArtifactType, PresentedArtifact } from './artifact-descriptor.js';
 import type { ViewOpenOptions } from './view-open.js';
 export { answerViewOpen, parseViewOpenAnswer, VIEW_OPEN_TIMEOUT_MS } from './view-open.js';
 export type { ViewOpenAnswer, ViewOpenOptions, ViewOpenOutcome } from './view-open.js';
-export declare const ARTIFACT_TYPES: readonly ["markdown", "html", "svg", "code", "canvas"];
-export type ArtifactType = typeof ARTIFACT_TYPES[number];
-/**
- * What a tool result carries under its `artifact` key. The descriptor of `present` points at a workspace file (`target`), names the
- * revision shown and carries no `id` or `ordinal` (both stay optional for hosts that number their own versions).
- */
-export interface ArtifactDescriptor {
-    readonly schema: 'boring.artifact';
-    readonly version: 1;
-    readonly id?: string;
-    readonly title: string;
-    readonly type: ArtifactType;
-    readonly mediaType: string;
-    readonly language?: string;
-    readonly target: ResourceLocator;
-    readonly revision: string;
-    readonly ordinal?: number;
-}
-export type ArtifactDescriptorInput = Omit<ArtifactDescriptor, 'schema' | 'version'>;
-/** Build a descriptor, refusing anything `parseArtifact` would refuse. */
-export declare function createArtifactDescriptor(input: ArtifactDescriptorInput): ArtifactDescriptor;
-/**
- * Strict shape check of an untrusted value (a model-visible tool result, a stored reference). Returns a fresh copy or
- * undefined. This function has no Pi runtime dependency; `registry/pi-artifacts/artifact.ts` carries the same validator for
- * the browser, because a copied registry item cannot import this package.
- */
-export declare function parseArtifact(value: unknown): ArtifactDescriptor | undefined;
 export interface PresentToolOptions {
     /**
      * The workspace of each call, resolved like Pi's environment (`@hachej/boring-agent/workspaces`), or one binding `{ files, root }`; absent: the

package/dist/artifacts.js

@@ -2,10 +2,10 @@ import { defineTool } from '@earendil-works/pi-durable';
 import { Type } from '@earendil-works/pi-ai';
 import { workspacePath } from '@hachej/boring-files/file-types';
 import { asWorkspaceResolver, workspaceFor } from './workspaces.js';
-import { createTaskArtifact, parseTaskArtifact, parseTaskSubject } from './task-artifacts.js';
+import { createTaskArtifact, parseTaskSubject } from './task-artifacts.js';
 export { createTaskArtifact, parseTaskArtifact, parseTaskSubject, taskSubjectKey } from './task-artifacts.js';
-/** Parse file or host-task presentation without treating a record as a workspace file. */
-export function parsePresentedArtifact(value) { return parseArtifact(value) ?? parseTaskArtifact(value); }
+import { createArtifactDescriptor } from './artifact-descriptor.js';
+export { ARTIFACT_TYPES, createArtifactDescriptor, parseArtifact, parsePresentedArtifact } from './artifact-descriptor.js';
 import { PRESENT_TOOL, awaitTaskViewOpen, awaitViewOpen } from './view-open.js';
 export { answerViewOpen, parseViewOpenAnswer, VIEW_OPEN_TIMEOUT_MS } from './view-open.js';
 /*
@@ -14,62 +14,6 @@ export { answerViewOpen, parseViewOpenAnswer, VIEW_OPEN_TIMEOUT_MS } from './vie
  * file tools and calls `present(path)`, which keeps the shown revision in the workspace provider's history and returns a
  * descriptor pointing at the file. There is no store of artifacts and no index. Nothing is executed here.
  */
-export const ARTIFACT_TYPES = ['markdown', 'html', 'svg', 'code', 'canvas'];
-const ID = /^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/;
-const LANGUAGE = /^[A-Za-z0-9+#._-]{1,32}$/;
-const isObject = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
-const hasOnly = (value, keys) => Object.keys(value).every(key => keys.includes(key));
-/** Build a descriptor, refusing anything `parseArtifact` would refuse. */
-export function createArtifactDescriptor(input) {
-    const descriptor = { schema: 'boring.artifact', version: 1, ...input };
-    const parsed = parseArtifact(descriptor);
-    if (!parsed)
-        throw new TypeError('Invalid artifact descriptor');
-    return parsed;
-}
-/**
- * Strict shape check of an untrusted value (a model-visible tool result, a stored reference). Returns a fresh copy or
- * undefined. This function has no Pi runtime dependency; `registry/pi-artifacts/artifact.ts` carries the same validator for
- * the browser, because a copied registry item cannot import this package.
- */
-export function parseArtifact(value) {
-    if (!isObject(value) || !hasOnly(value, ['schema', 'version', 'id', 'title', 'type', 'mediaType', 'language', 'target', 'revision', 'ordinal']))
-        return undefined;
-    const { id, title, type, mediaType, language, target, revision, ordinal } = value;
-    if (value['schema'] !== 'boring.artifact' || value['version'] !== 1)
-        return undefined;
-    if (id !== undefined && (typeof id !== 'string' || !ID.test(id)))
-        return undefined;
-    if (typeof title !== 'string' || !title.trim() || title.length > 200)
-        return undefined;
-    if (typeof type !== 'string' || !ARTIFACT_TYPES.includes(type))
-        return undefined;
-    if (typeof mediaType !== 'string' || !/^[a-z0-9][a-z0-9!#$&^_.+-]*\/[a-z0-9][a-z0-9!#$&^_.+-]*$/i.test(mediaType))
-        return undefined;
-    if (language !== undefined && (typeof language !== 'string' || !LANGUAGE.test(language)))
-        return undefined;
-    if (typeof revision !== 'string' || !revision || revision.length > 256)
-        return undefined;
-    if (ordinal !== undefined && (typeof ordinal !== 'number' || !Number.isSafeInteger(ordinal) || ordinal < 1))
-        return undefined;
-    if (!isObject(target) || !hasOnly(target, ['resource', 'view']) || !isObject(target['resource']) || !hasOnly(target['resource'], ['providerId', 'path']))
-        return undefined;
-    const { providerId, path } = target['resource'];
-    if (typeof providerId !== 'string' || !providerId || typeof path !== 'string' || !path || path.length > 512)
-        return undefined;
-    const view = target['view'];
-    if (!isObject(view))
-        return undefined;
-    let parsedView;
-    if (view['kind'] === 'published' && hasOnly(view, ['kind']))
-        parsedView = { kind: 'published' };
-    else if (view['kind'] === 'working' && hasOnly(view, ['kind', 'viewId']) && typeof view['viewId'] === 'string' && view['viewId'])
-        parsedView = { kind: 'working', viewId: view['viewId'] };
-    else
-        return undefined;
-    return { schema: 'boring.artifact', version: 1, ...(id === undefined ? {} : { id }), title, type: type, mediaType, ...(language === undefined ? {} : { language: language }),
-        target: { resource: { providerId, path }, view: parsedView }, revision, ...(ordinal === undefined ? {} : { ordinal }) };
-}
 const reply = (value) => ({ output: [{ type: 'text', text: JSON.stringify(value) }] });
 const decode = (bytes) => { try {
     return new TextDecoder('utf-8', { fatal: true, ignoreBOM: true }).decode(bytes);

package/dist/room.d.ts

@@ -1,6 +1,8 @@
 import type { Conversation, ConversationId, EntryRecord, Harness } from '@earendil-works/pi-durable';
 import type { Context } from '@earendil-works/chord';
 import type { AskUserAnswer } from './ask-user.js';
+import type { PresentedArtifact } from './artifact-descriptor.js';
+export type { PresentedArtifact } from './artifact-descriptor.js';
 /**
  * A shared room on pi-durable: people and agents in one session that never runs a model. Every entry is a passive write
  * keyed by a namespaced `requestId` (CH-20); `roomView` is the only reader (CH-24); `wakeFor` alone decides which agent
@@ -41,6 +43,7 @@ export type RoomEntryData = {
         attachments: {
             path: string;
         }[];
+        artifacts?: PresentedArtifact[];
         steps: RoomStep[];
     };
     /** The target stays stored and reads as « message supprimé » (CH-6). */
@@ -66,6 +69,7 @@ export type RoomEntryData = {
         prompt: string;
         options: string[];
         allowFreeText: boolean;
+        artifacts?: PresentedArtifact[];
     };
     'room.action': {
         author: string;
@@ -109,6 +113,7 @@ export type RoomItem = {
     attachments: {
         path: string;
     }[];
+    artifacts?: PresentedArtifact[];
     steps: RoomStep[];
     mine: boolean;
     removed: boolean;
@@ -135,6 +140,7 @@ export type RoomItem = {
     options: string[];
     allowFreeText: boolean;
     answered: boolean;
+    artifacts?: PresentedArtifact[];
 } | {
     kind: 'system';
     id: number;
@@ -218,12 +224,14 @@ export type RoomRefusal = {
 export type RoomReply = {
     readonly text: string;
     readonly steps?: readonly RoomStep[];
+    readonly artifacts?: readonly PresentedArtifact[];
 };
 export type RoomQuestionDraft = {
     readonly callId: string;
     readonly prompt: string;
     readonly options: readonly string[];
     readonly allowFreeText: boolean;
+    readonly artifacts?: readonly PresentedArtifact[];
 };
 export interface Room {
     /** The native conversation of a room conversation name, created on first use. */
@@ -261,6 +269,7 @@ export interface PendingQuestion {
     readonly prompt: string;
     readonly options: readonly string[];
     readonly allowFreeText: boolean;
+    readonly artifacts?: readonly PresentedArtifact[];
 }
 /** `ask_user` calls of the active transcript that have no tool result yet, oldest first. */
 export declare function pendingQuestions(entries: readonly EntryRecord[]): PendingQuestion[];
@@ -272,6 +281,9 @@ export type RoomFrame = {
     readonly type: 'step';
     readonly label: string;
     readonly status: 'running' | 'done';
+} | {
+    readonly type: 'artifact';
+    readonly artifact: PresentedArtifact;
 };
 /** The agent's door into the room, bound to the agent by its host: the agent id is never an argument. */
 export interface RoomPort {

package/dist/room.js

@@ -1,6 +1,7 @@
 import { defineDoc } from '@earendil-works/pi-durable';
 import { withAbortSignal } from '@earendil-works/chord/context';
 import { ASK_USER_TOOL, answerUserQuestion, askUserQuestionId } from './ask-user.js';
+import { parsePresentedArtifact } from './artifact-descriptor.js';
 /**
  * A shared room on pi-durable: people and agents in one session that never runs a model. Every entry is a passive write
  * keyed by a namespaced `requestId` (CH-20); `roomView` is the only reader (CH-24); `wakeFor` alone decides which agent
@@ -51,6 +52,7 @@ export function roomView(entries, cards, viewer) {
             items.push({
                 kind: 'message', id, author: data.author, ...(data.via ? { via: data.via } : {}), ...(data.for ? { for: data.for } : {}),
                 text: gone ? ROOM.removed : data.text, mentions: [...data.mentions], ...(data.replyTo !== undefined ? { replyTo: data.replyTo } : {}),
+                ...(data.artifacts ? { artifacts: gone ? [] : descriptors(data.artifacts) } : {}),
                 attachments: gone ? [] : data.attachments.map(({ path }) => ({ path })), steps: gone ? [] : data.steps.map(({ label, status }) => ({ label, status })),
                 mine: data.author === viewer.id || data.via === viewer.id, removed: gone,
             });
@@ -64,7 +66,7 @@ export function roomView(entries, cards, viewer) {
             items.push({ kind: 'pin', id, author: data.author, title: data.title, line: data.line, anchor: data.anchor, mine: data.author === viewer.id });
         }
         else if (kind === 'room.question') {
-            items.push({ kind: 'question', id, author: data.author, callId: data.callId, prompt: data.prompt, options: [...data.options], allowFreeText: data.allowFreeText, answered: answered.has(id) });
+            items.push({ kind: 'question', id, author: data.author, callId: data.callId, prompt: data.prompt, options: [...data.options], allowFreeText: data.allowFreeText, answered: answered.has(id), ...(data.artifacts ? { artifacts: descriptors(data.artifacts) } : {}) });
         }
         else if (kind === 'room.system') {
             items.push({ kind: 'system', id, line: data.line });
@@ -185,11 +187,11 @@ export function createRoom(options) {
         }),
         settle: (agent, wakeId, reply) => onWake(agent, wakeId, {
             requestId: `wake:${wakeId}`, kind: 'room.message',
-            data: { author: agent, text: reply.text, mentions: [], attachments: [], steps: (reply.steps ?? []).map(({ label, status }) => ({ label, status })) },
+            data: { author: agent, text: reply.text, mentions: [], attachments: [], ...(reply.artifacts ? { artifacts: descriptors(reply.artifacts) } : {}), steps: (reply.steps ?? []).map(({ label, status }) => ({ label, status })) },
         }, true),
         question: (agent, wakeId, question) => onWake(agent, wakeId, {
             requestId: `q:${question.callId}`, kind: 'room.question',
-            data: { author: agent, callId: question.callId, prompt: question.prompt, options: [...question.options], allowFreeText: question.allowFreeText },
+            data: { author: agent, callId: question.callId, prompt: question.prompt, options: [...question.options], allowFreeText: question.allowFreeText, ...(question.artifacts ? { artifacts: descriptors(question.artifacts) } : {}) },
         }, false),
         resend: async () => {
             const at = now();
@@ -257,6 +259,40 @@ function answerText(entry) {
     return (entry?.model ?? []).flatMap(message => message.role === 'assistant' ? message.content : [])
         .flatMap(part => part.type === 'text' ? [part.text] : []).join('\n\n').trim();
 }
+/** Exact resource/view/revision identity, not a path guessed from an assistant's prose. */
+const descriptorKey = (artifact) => JSON.stringify(artifact.type === 'task' ? artifact.subject : [artifact.target, artifact.revision]);
+const descriptors = (values) => {
+    const unique = new Map();
+    for (const value of values) {
+        const artifact = parsePresentedArtifact(value);
+        if (artifact)
+            unique.set(descriptorKey(artifact), artifact);
+    }
+    return [...unique.values()];
+};
+/** Only successful native present results paired with their actual invocation may project descriptors. */
+function presented(entries) {
+    const calls = new Map();
+    const found = [];
+    for (const entry of entries)
+        for (const message of entry.model ?? []) {
+            if (message.role === 'assistant')
+                for (const part of message.content) {
+                    if (part.type === 'toolCall')
+                        calls.set(part.id, part.name);
+                }
+            if (message.role !== 'toolResult' || message.isError || message.toolName !== 'present' || calls.get(message.toolCallId) !== 'present')
+                continue;
+            try {
+                const value = JSON.parse(message.content.flatMap(part => part.type === 'text' ? [part.text] : []).join(''));
+                const artifact = value && typeof value === 'object' ? parsePresentedArtifact(value['artifact']) : undefined;
+                if (artifact)
+                    found.push(artifact);
+            }
+            catch { /* A failed or malformed present has no descriptor, only its ordinary step. */ }
+        }
+    return descriptors(found);
+}
 const framesOf = (entries) => entries.flatMap(entry => (entry.model ?? []).flatMap((message) => {
     if (message.role === 'toolResult')
         return [{ type: 'step', label: message.toolName, status: 'done' }];
@@ -299,6 +335,7 @@ export function createRoomTurn(options) {
     async function follow(wakeId, known) {
         const watch = await conversation.watch(context);
         const sent = new Map();
+        const sentArtifacts = new Set();
         let from = known;
         let submission;
         let live = '';
@@ -340,6 +377,14 @@ export function createRoomTurn(options) {
                         live = text;
                     }
                 }
+                const artifacts = presented(own);
+                for (const artifact of artifacts) {
+                    const key = descriptorKey(artifact);
+                    if (!sentArtifacts.has(key)) {
+                        frames.push({ type: 'artifact', artifact });
+                        sentArtifacts.add(key);
+                    }
+                }
                 const questions = pendingQuestions(own);
                 if (frames.length && port.stream)
                     await port.stream(wakeId, frames);
@@ -347,7 +392,7 @@ export function createRoomTurn(options) {
                     return;
                 const asked = (await owed(wakeId))?.asked ?? [];
                 for (const question of questions.filter(question => !asked.includes(question.callId))) {
-                    await port.question(wakeId, question);
+                    await port.question(wakeId, { ...question, ...(artifacts.length ? { artifacts } : {}) });
                     // Asking cannot share the native commit: a crash before this acknowledgement repeats it, and `q:<callId>` absorbs that.
                     await update(wakeId, (items, index) => { if (!items[index].asked.includes(question.callId))
                         items[index].asked.push(question.callId); });
@@ -381,7 +426,15 @@ export function createRoomTurn(options) {
             // An unanswered run is closed with the room's own line, never dropped: left open it would only wait for its resends.
             if (record.type === 'input' && record.status === 'done') {
                 const entry = (await conversation.entries({ minEntryId: record.answer, maxEntryId: record.answer }, 1, undefined, context)).items[0];
-                await port.settle(wakeId, { text: answerText(entry) });
+                const entries = [];
+                let cursor;
+                do {
+                    const page = await conversation.entries({ minEntryId: (record.entry + 1), maxEntryId: record.answer, order: 'ascending' }, 200, cursor, context);
+                    entries.push(...page.items);
+                    cursor = page.next;
+                } while (cursor !== undefined);
+                const artifacts = presented(entries);
+                await port.settle(wakeId, { text: answerText(entry), ...(artifacts.length ? { artifacts } : {}) });
             }
             else if (record.type === 'input' && record.status === 'unanswered')
                 await port.settle(wakeId, { text: ROOM.unanswered });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hachej/boring-agent",
-  "version": "0.4.37",
+  "version": "0.4.39",
   "license": "MIT",
   "private": false,
   "type": "module",
@@ -188,8 +188,8 @@
     "@earendil-works/pi-durable": "~1.4.0",
     "@earendil-works/pi-ai": "~1.4.0",
     "@earendil-works/chord": "~1.4.0",
-    "@hachej/boring-files": "^0.4.37",
-    "@hachej/boring-ui-kit": "^0.4.37",
+    "@hachej/boring-files": "^0.4.39",
+    "@hachej/boring-ui-kit": "^0.4.39",
     "typebox": "1.3.27",
     "xlsx": "^0.20.3"
   },