@jini-ai/daemon 0.6.15-rc.2 → 0.6.15

package/dist/core/read-only-tools.js

@@ -1,5 +1,9 @@
 import { isReadOnlyTool, toolDiscoveryMetadata } from '@jini-ai/core';
 import { toolCandidates } from './tool-candidates.js';
+/** ` — did you mean a, b?` for any close tool ids, else nothing. */
+function didYouMean(candidates) {
+    return candidates.length > 0 ? ` — did you mean ${candidates.join(', ')}?` : '';
+}
 /**
  * Default daemon refusal wording, replaceable by the host. Unknown registrations and writes both
  * refuse unsafe dispatch; unknown ids direct discovery because an unrestricted retry cannot run them.
@@ -11,7 +15,7 @@ export const defaultDaemonMessages = {
         toolRefusalMessage: ({ toolId }) => `tool "${toolId}" is not registered as read-only — this gateway executes only tools whose registration declares readOnly; call it through execute_delegated_tool instead`,
         unknownToolMessage: ({ toolId, candidates }) => toolId === 'check_messages'
             ? 'check_messages is an MCP-local tool; call check_messages directly, never as toolId in a delegated gateway'
-            : `no tool "${toolId}" is registered; use search_tools${candidates.length > 0 ? ` — did you mean ${candidates.join(', ')}?` : ''}`,
+            : `no tool "${toolId}" is registered; use search_tools${didYouMean(candidates)}`,
     },
 };
 /** @returns A copied, attenuated principal; its roles are unchanged. */

package/dist/core/tool-gaps.js

@@ -189,7 +189,7 @@ export function createToolGapCollector(required, optional = {}) {
             const payload = event.payload;
             if (payload.type === 'text_delta')
                 readDelta(payload.delta);
-            else if (payload.type === 'tool_use')
+            if (payload.type === 'tool_use')
                 recordToolUse(payload, event.ts);
         },
         /** Await outstanding audit writes during graceful shutdown/tests. */

package/dist/delegated-result-correlation.js

@@ -1,3 +1,4 @@
+import { omitKeys } from './core/omit-keys.js';
 /** Accept only the complete base64 source shape; extra fields must remain part of the digest. */
 function base64ImageSource({ source }, _options = {}) {
     if (typeof source !== 'object' || source === null)
@@ -14,8 +15,7 @@ function normalizeSourceImage({ record }, _options = {}) {
     const image = base64ImageSource({ source: record.source });
     if (!image)
         return record;
-    const { source: _source, ...rest } = record;
-    return { ...rest, data: image.data, mimeType: image.media_type };
+    return { ...omitKeys(record, ['source']), data: image.data, mimeType: image.media_type };
 }
 /** Normalize unambiguous CLI images and JSON object key order.
  * @complexity O(n + k log k) for n bytes and k keys per object; inputs are wire JSON. */

package/dist/http/agents.d.ts

@@ -51,6 +51,10 @@ export interface AgentSummary {
      * as `true` (no known reason to warn) rather than assuming the worst.
      */
     readonly supportsTools?: boolean;
+    /** Project the runtime definition so picker preflight agrees with launch enforcement. */
+    readonly supportsNativeToolAccess?: boolean;
+    readonly fullCliAccessOnly?: boolean;
+    readonly fullCliAccessNote?: string;
 }
 export interface AgentsHttpDeps {
     /** Returns the host's cached or freshly resolved client-safe agent inventory. */

package/dist/http/attachments.js

@@ -284,13 +284,12 @@ const SIGNATURE_BYTES = FTYP_COMPATIBLE_BRANDS_OFFSET + MAX_SCANNED_COMPATIBLE_B
  * production is a check nobody knows works — a fake identity states each case directly.
  */
 export function isUnchangedAttachment({ recorded, observed }, _optional = {}) {
-    return observed.isRegularFile
-        && observed.canonicalPath === recorded.filePath
-        && observed.dev === recorded.dev
-        && observed.ino === recorded.ino
-        && observed.size === recorded.size
-        && (recorded.mtimeMs === undefined || observed.mtimeMs === recorded.mtimeMs)
+    const sameFile = observed.isRegularFile && observed.canonicalPath === recorded.filePath
+        && observed.dev === recorded.dev && observed.ino === recorded.ino;
+    // A recorded timestamp must still hold; one never recorded cannot disagree.
+    const sameTimes = (recorded.mtimeMs === undefined || observed.mtimeMs === recorded.mtimeMs)
         && (recorded.ctimeMs === undefined || observed.ctimeMs === recorded.ctimeMs);
+    return sameFile && observed.size === recorded.size && sameTimes;
 }
 /**
  * Phase 1 of `claim()`: synchronously reserves `attachments` for `runId`, or throws (releasing
@@ -384,13 +383,15 @@ export function sanitizeAttachmentName({ requestedName }, _optional = {}) {
         return 'attachment';
     return basename(requestedName).replaceAll(/[^a-zA-Z0-9._ -]/gu, '_') || 'attachment';
 }
+/** An attachment no run has claimed, or one claimed by `runId` (never by an absent run id). */
+function isUnclaimedOrClaimedBy(claimedRunId, runId) {
+    return claimedRunId === undefined || (runId !== undefined && claimedRunId === runId);
+}
+/** The complete PNG signature includes the CR/LF and control-byte corruption markers. */
+const PNG_SIGNATURE_PREFIX = [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a];
 /** `true` when `body`'s first 8 bytes are the PNG signature. */
 export function hasPngSignature({ body }, _optional = {}) {
-    return body.length >= 8
-        && body[0] === 0x89
-        && body[1] === 0x50
-        && body[2] === 0x4e
-        && body[3] === 0x47;
+    return body.length >= 8 && PNG_SIGNATURE_PREFIX.every((byte, index) => body[index] === byte);
 }
 /** `true` when `body`'s first 3 bytes are the JPEG start-of-image marker. */
 export function hasJpegSignature({ body }, _optional = {}) {
@@ -934,7 +935,7 @@ export async function createDiskAttachmentStore(requiredArgs, optionalArgs = {})
                 // what makes an ownerless record excluded rather than accidentally matched by a falsy-ish
                 // `ownerId` argument — see this method's own doc on why that must never be a wildcard.
                 .filter((record) => record.ownerId !== undefined && record.ownerId === ownerId
-                && (record.claimedRunId === undefined || (runId !== undefined && record.claimedRunId === runId)))
+                && isUnclaimedOrClaimedBy(record.claimedRunId, runId))
                 .sort((a, b) => a.createdAt - b.createdAt)
                 .map((record) => ({ ref: record.id, name: record.name, kind: record.kind, size: record.size, createdAt: record.createdAt }));
         },

package/dist/http/component-catalog.js

@@ -12,7 +12,7 @@ function parseSearchInput(input) {
     const rawLimit = input.query.limit;
     if (rawLimit === undefined)
         return ok({ value: { query: rawQuery, limit: DEFAULT_SEARCH_LIMIT } });
-    if (typeof rawLimit !== 'string' || !/^[0-9]+$/.test(rawLimit)) {
+    if (typeof rawLimit !== 'string' || !/^\d+$/.test(rawLimit)) {
         return err({ error: validationError({ message: 'limit must be a single positive-integer query-string value when provided' }) });
     }
     const parsed = Number(rawLimit);

package/dist/http/connectors.js

@@ -49,6 +49,8 @@ import { createApiError } from '@jini-ai/protocol';
 import { ClientFacingError, defineJsonRoute, mountJsonRoute } from '@jini-ai/http-kit';
 import { validationError } from '@jini-ai/http-kit';
 import { err, ok } from '@jini-ai/http-kit';
+/** Validation message for a request body that is not a JSON object. */
+const BODY_NOT_OBJECT_MESSAGE = 'body must be a JSON object';
 function defaultInternalErrorSink(context) {
     // eslint-disable-next-line no-console
     console.error(`[@jini-ai/http-kit] internal error (connectors/${context.source}.${context.operation}, correlationId=${context.correlationId})`, context.error);
@@ -86,7 +88,7 @@ function firstQueryValue(raw) {
 // ---------------------------------------------------------------------------
 function parseAuthCredentials(input) {
     if (!isRecord(input.body))
-        return err({ error: validationError({ message: 'body must be a JSON object' }) });
+        return err({ error: validationError({ message: BODY_NOT_OBJECT_MESSAGE }) });
     const email = nonEmptyString(input.body.email);
     if (!email)
         return err({ error: validationError({ message: 'email must be a non-empty string' }, { issues: [{ path: 'email', message: 'required non-empty string' }] }) });
@@ -97,7 +99,7 @@ function parseAuthCredentials(input) {
 }
 function parseAuthToken(input) {
     if (!isRecord(input.body))
-        return err({ error: validationError({ message: 'body must be a JSON object' }) });
+        return err({ error: validationError({ message: BODY_NOT_OBJECT_MESSAGE }) });
     const token = nonEmptyString(input.body.token);
     if (!token)
         return err({ error: validationError({ message: 'token must be a non-empty string' }, { issues: [{ path: 'token', message: 'required non-empty string' }] }) });
@@ -164,7 +166,7 @@ function parseStoragePut(input) {
     if (!keyResult.ok)
         return keyResult;
     if (!isRecord(input.body))
-        return err({ error: validationError({ message: 'body must be a JSON object' }) });
+        return err({ error: validationError({ message: BODY_NOT_OBJECT_MESSAGE }) });
     const dataBase64 = input.body.dataBase64;
     if (typeof dataBase64 !== 'string' || !isWellFormedBase64(dataBase64)) {
         return err({ error: validationError({ message: 'dataBase64 must be a non-empty base64-encoded string' }, { issues: [{ path: 'dataBase64', message: 'required base64 string' }] }) });
@@ -231,7 +233,7 @@ function parseDbInsert(input) {
     if (!collectionResult.ok)
         return collectionResult;
     if (!isRecord(input.body))
-        return err({ error: validationError({ message: 'body must be a JSON object' }) });
+        return err({ error: validationError({ message: BODY_NOT_OBJECT_MESSAGE }) });
     const id = input.body.id;
     if (typeof id !== 'string' || id.length === 0) {
         return err({ error: validationError({ message: 'id must be a non-empty string field' }, { issues: [{ path: 'id', message: 'required non-empty string' }] }) });
@@ -252,7 +254,7 @@ function parseDbUpdate(input) {
     if (!parsed.ok)
         return parsed;
     if (!isRecord(input.body))
-        return err({ error: validationError({ message: 'body must be a JSON object' }) });
+        return err({ error: validationError({ message: BODY_NOT_OBJECT_MESSAGE }) });
     return ok({ value: { ...parsed.value, patch: input.body } });
 }
 function parseDbQueryRequest(input) {

package/dist/http/db-ops.js

@@ -138,6 +138,11 @@ function toolResultToApiResult(deps, source, result) {
             sink({ source, correlationId, error: result.status === 'failed' ? result.error : result.status });
             return err({ error: createApiError({ code: 'INTERNAL_ERROR', message: 'an internal error occurred' }, { requestId: correlationId }) });
         }
+        default: {
+            // Unreachable: every tool result status has a case above, and a new one fails typecheck here.
+            const unhandled = result.status;
+            throw new TypeError(`Unhandled tool result status: ${String(unhandled)}`);
+        }
     }
 }
 /** `GET /api/daemon/db` — the database inventory (schema version, tables, row counts, size). */

package/dist/http/delegated-tools.js

@@ -144,6 +144,11 @@ function toolExecutionResultToApiResult(deps, { runId, toolId, result }) {
             return err({ error: reportInternalError(deps, { source: 'delegated-tool-execute', error: result.status, runId, toolId, status: result.status }) });
         case 'failed':
             return err({ error: failedResultToApiError(deps, { runId, toolId, result }) });
+        default: {
+            // Unreachable: every tool result status has a case above, and a new one fails typecheck here.
+            const unhandled = result.status;
+            throw new TypeError(`Unhandled tool result status: ${String(unhandled)}`);
+        }
     }
 }
 /** The `failed` arm of {@link toolExecutionResultToApiResult} — see its doc for the three-way split. */

package/dist/http/frontend-sessions.js

@@ -59,7 +59,8 @@ function reportInternalError(deps, source, error) {
  * from a bracketed query string) is rejected rather than coerced.
  */
 export function parseCapabilityQuery({ raw }, _optional = {}) {
-    const values = raw === undefined ? [] : (Array.isArray(raw) ? raw : [raw]);
+    const listed = Array.isArray(raw) ? raw : [raw];
+    const values = raw === undefined ? [] : listed;
     const capabilities = [];
     for (const value of values) {
         if (typeof value !== 'string' || value.trim().length === 0)
@@ -167,11 +168,12 @@ export function registerFrontendSessionRoutes({ app, deps, adapter }, _optional
         }
         catch (error) {
             reportInternalError(deps, 'stream', error);
-            if (!res.headersSent) {
-                res.status(500).json({ error: createApiError({ code: 'INTERNAL_ERROR', message: 'an internal error occurred' }) });
+            if (res.headersSent) {
+                if (!res.writableEnded)
+                    res.end();
             }
-            else if (!res.writableEnded) {
-                res.end();
+            else {
+                res.status(500).json({ error: createApiError({ code: 'INTERNAL_ERROR', message: 'an internal error occurred' }) });
             }
         }
     });

package/dist/http/host-tools.js

@@ -71,6 +71,12 @@ export function applicableForPlatform({ entry, platform }, _optional = {}) {
 export function defaultProbeEnv(_required, _optional = {}) {
     return { access: ({ path, mode }) => fsAccess(path, mode), env: process.env, platform: currentPlatform({}) };
 }
+/** The login-shell bin directories a GUI-launched daemon's `PATH` tends to lack, per platform. */
+function extraProbeDirs(platform, home) {
+    if (platform === 'darwin')
+        return ['/usr/local/bin', '/opt/homebrew/bin', '/usr/bin', '/bin', '/usr/sbin', '/sbin', `${home}/.local/bin`];
+    return platform === 'linux' ? ['/usr/local/bin', '/usr/bin', '/bin', `${home}/.local/bin`] : [];
+}
 /**
  * `$PATH` directories to probe, plus the common macOS/Linux locations a login shell would have
  * that a GUI-launched daemon's thin inherited `PATH` often lacks (no `/usr/local/bin`, no
@@ -81,11 +87,7 @@ export function pathDirs(probeEnv) {
     const raw = probeEnv.env.PATH ?? '';
     const sep = probeEnv.platform === 'win32' ? ';' : ':';
     const home = probeEnv.env.HOME ?? '';
-    const extras = probeEnv.platform === 'darwin'
-        ? ['/usr/local/bin', '/opt/homebrew/bin', '/usr/bin', '/bin', '/usr/sbin', '/sbin', `${home}/.local/bin`]
-        : probeEnv.platform === 'linux'
-            ? ['/usr/local/bin', '/usr/bin', '/bin', `${home}/.local/bin`]
-            : [];
+    const extras = extraProbeDirs(probeEnv.platform, home);
     return [...raw.split(sep), ...extras].filter((dir) => dir.length > 0);
 }
 export async function probeCommandOnPath({ command, probeEnv }, _optional = {}) {

package/dist/http/memory.js

@@ -290,7 +290,9 @@ export function registerMemoryEventStream({ app, deps, adapter }, _optional = {}
         let seq = 0;
         const channel = createSseChannel({ res });
         const emit = (kind, data) => {
-            channel.enqueue({ event: { opaqueCursor: String(seq++), kind, data } });
+            const cursor = seq;
+            seq += 1;
+            channel.enqueue({ event: { opaqueCursor: String(cursor), kind, data } });
         };
         const onChange = (event) => emit('change', event);
         const onExtraction = (event) => emit('extraction', event);

package/dist/http/model-proxy.js

@@ -218,12 +218,12 @@ function toStreamEvent(seq, event) {
 }
 /** Answers a failure that happened before any SSE stream existed: a redacted JSON 500 if nothing was sent yet, otherwise just end the response (matching `mountJsonRoute`'s own SEC-005 catch). */
 function respondInternalError(res, correlationId) {
-    if (!res.headersSent) {
-        sendApiError({ res, status: 500, error: createApiError({ code: 'INTERNAL_ERROR', message: 'an internal error occurred' }, { requestId: correlationId }) });
-    }
-    else if (!res.writableEnded) {
-        res.end();
+    if (res.headersSent) {
+        if (!res.writableEnded)
+            res.end();
+        return;
     }
+    sendApiError({ res, status: 500, error: createApiError({ code: 'INTERNAL_ERROR', message: 'an internal error occurred' }, { requestId: correlationId }) });
 }
 /**
  * The actual request handler body, shared by every fixed-path route and the `:provider`
@@ -238,6 +238,11 @@ async function runProxyStream({ req, res, adapter, provider, onInternalError, en
     // reach them however far execution got — including a throw from `guardSameOrigin`/`parse`,
     // before either exists yet.
     let seq = 0;
+    const nextSeq = () => {
+        const current = seq;
+        seq += 1;
+        return current;
+    };
     let channel;
     try {
         const origin = guardSameOrigin({ req, origin: adapter });
@@ -253,7 +258,7 @@ async function runProxyStream({ req, res, adapter, provider, onInternalError, en
         const openChannel = createSseChannel({ res }, { isEndEvent: ({ event }) => event.kind === 'end' });
         channel = openChannel;
         openChannel.open();
-        await entry.run(parsed.value, (event) => openChannel.enqueue({ event: toStreamEvent(seq++, event) }));
+        await entry.run(parsed.value, (event) => openChannel.enqueue({ event: toStreamEvent(nextSeq(), event) }));
         // No `channel.end()` call here: every reachable exit path inside every turn-runner emits
         // exactly one `'end'`-kind event before its promise resolves (the duplicate-end-event fix —
         // see each provider module's own `turn-end-guard.ts` usage, and each function's own
@@ -283,8 +288,8 @@ async function runProxyStream({ req, res, adapter, provider, onInternalError, en
         // here (an exception escaping `run` — e.g. a caller-supplied `executeTool` throwing — means
         // no `'end'` event was ever emitted for this connection), and the synthetic `'end'`-kind
         // event's own `isEndEvent` match closes the channel via the same path as a real one.
-        channel.enqueue({ event: toStreamEvent(seq++, { type: 'error', message: 'an internal error occurred', code: correlationId }) });
-        channel.enqueue({ event: toStreamEvent(seq++, { type: 'end', reason: 'error' }) });
+        channel.enqueue({ event: toStreamEvent(nextSeq(), { type: 'error', message: 'an internal error occurred', code: correlationId }) });
+        channel.enqueue({ event: toStreamEvent(nextSeq(), { type: 'end', reason: 'error' }) });
     }
 }
 /** Erases one provider's concrete parse/run types into the registry's shared entry shape — the single cast every entry needs. */

package/dist/http/research-tavily.adapter.js

@@ -1,6 +1,7 @@
 /** Tavily default adapter. Request limits, timeout and secret-redaction policy remain here. */
 import { validateBaseUrl } from '@jini-ai/agent-runtime';
 import { redactSecrets } from '@jini-ai/core';
+import { trimCharsEnd } from '@jini-ai/core/text';
 const DEFAULT_TAVILY_BASE_URL = 'https://api.tavily.com';
 /** Tavily's own documented cap on `max_results` (see OD's `tavily.ts#TAVILY_MAX_RESULTS_LIMIT`). */
 const TAVILY_MAX_RESULTS_LIMIT = 20;
@@ -20,7 +21,7 @@ function resolveTavilyBase(credentials) {
     if (baseUrlCheck.error) {
         throw new Error(baseUrlCheck.error);
     }
-    return baseUrl.replace(/\/+$/, '');
+    return trimCharsEnd({ text: baseUrl, chars: '/' });
 }
 function trimmedOrUndefined(value) {
     return typeof value === 'string' && value.trim() ? value.trim() : undefined;

package/dist/http/routines.js

@@ -3,6 +3,8 @@ import { createApiError } from '@jini-ai/protocol';
 import { defineJsonRoute, mountJsonRoute } from '@jini-ai/http-kit';
 import { validationError } from '@jini-ai/http-kit';
 import { err, ok } from '@jini-ai/http-kit';
+/** The 404 message for an unknown routine id. */
+const ROUTINE_NOT_FOUND_MESSAGE = 'routine not found';
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
@@ -192,7 +194,7 @@ export const routineGetRoute = defineJsonRoute({
     method: 'get', path: '/api/routines/:id', parse: parseRoutineId, handle: async ({ input: id, deps }) => {
         const routine = await deps.store.get({ id });
         return routine === null
-            ? err({ error: createApiError({ code: 'NOT_FOUND', message: 'routine not found' }) })
+            ? err({ error: createApiError({ code: 'NOT_FOUND', message: ROUTINE_NOT_FOUND_MESSAGE }) })
             : ok({ value: { routine: attachNextRunAt(routine, deps.scheduler) } });
     }
 });
@@ -205,7 +207,7 @@ export const routineUpdateRoute = defineJsonRoute({
         }
         const routine = await deps.store.update({ id, patch });
         if (routine === null)
-            return err({ error: createApiError({ code: 'NOT_FOUND', message: 'routine not found' }) });
+            return err({ error: createApiError({ code: 'NOT_FOUND', message: ROUTINE_NOT_FOUND_MESSAGE }) });
         deps.scheduler.rescheduleOne({ routineId: id });
         return ok({ value: { routine: attachNextRunAt(routine, deps.scheduler) } });
     }
@@ -214,14 +216,14 @@ export const routineDeleteRoute = defineJsonRoute({
     method: 'delete', path: '/api/routines/:id', parse: parseRoutineId, handle: async ({ input: id, deps }) => {
         deps.scheduler.unschedule({ routineId: id });
         const removed = await deps.store.delete({ id });
-        return removed ? ok({ value: { ok: true } }) : err({ error: createApiError({ code: 'NOT_FOUND', message: 'routine not found' }) });
+        return removed ? ok({ value: { ok: true } }) : err({ error: createApiError({ code: 'NOT_FOUND', message: ROUTINE_NOT_FOUND_MESSAGE }) });
     }
 }, { requireSameOrigin: true });
 export const routineRunNowRoute = defineJsonRoute({
     method: 'post', path: '/api/routines/:id/run', parse: parseRoutineId, handle: async ({ input: id, deps }) => {
         const existing = await deps.store.get({ id });
         if (existing === null)
-            return err({ error: createApiError({ code: 'NOT_FOUND', message: 'routine not found' }) });
+            return err({ error: createApiError({ code: 'NOT_FOUND', message: ROUTINE_NOT_FOUND_MESSAGE }) });
         const started = await deps.scheduler.runNow({ routineId: id });
         const [routine, run] = await Promise.all([deps.store.get({ id }), deps.store.getLatestRun({ routineId: id })]);
         return ok({
@@ -239,7 +241,7 @@ export const routineRunsListRoute = defineJsonRoute({
     method: 'get', path: '/api/routines/:id/runs', parse: parseRoutineRunsQuery, handle: async ({ input: { id, limit }, deps }) => {
         const existing = await deps.store.get({ id });
         if (existing === null)
-            return err({ error: createApiError({ code: 'NOT_FOUND', message: 'routine not found' }) });
+            return err({ error: createApiError({ code: 'NOT_FOUND', message: ROUTINE_NOT_FOUND_MESSAGE }) });
         const runs = await deps.store.listRuns({ routineId: id, limit });
         return ok({ value: { runs } });
     }

package/dist/http/terminals.js

@@ -60,6 +60,11 @@ function toolResultToApiResult(deps, result) {
             sink({ source: 'terminal-create', correlationId, error: result.status === 'failed' ? result.error : result.status });
             return err({ error: createApiError({ code: 'INTERNAL_ERROR', message: 'an internal error occurred' }, { requestId: correlationId }) });
         }
+        default: {
+            // Unreachable: every tool result status has a case above, and a new one fails typecheck here.
+            const unhandled = result.status;
+            throw new TypeError(`Unhandled tool result status: ${String(unhandled)}`);
+        }
     }
 }
 function parseTerminalCreate(input) {

package/dist/http/tool-catalog.js

@@ -12,7 +12,7 @@ function parseSearchInput(input) {
     const rawLimit = input.query.limit;
     if (rawLimit === undefined)
         return ok({ value: { query: rawQuery, limit: DEFAULT_SEARCH_LIMIT } });
-    if (typeof rawLimit !== 'string' || !/^[0-9]+$/.test(rawLimit)) {
+    if (typeof rawLimit !== 'string' || !/^\d+$/.test(rawLimit)) {
         return err({ error: validationError({ message: 'limit must be a single positive-integer query-string value when provided' }) });
     }
     const parsed = Number(rawLimit);

package/dist/http/xai.js

@@ -123,6 +123,9 @@ import { createApiError } from '@jini-ai/protocol';
 import { defineJsonRoute, mountJsonRoute } from '@jini-ai/http-kit';
 import { validationError } from '@jini-ai/http-kit';
 import { err, ok } from '@jini-ai/http-kit';
+import { trimCharsEnd } from '@jini-ai/core/text';
+/** The redacted message every internal failure answers with; details go to the error sink. */
+const INTERNAL_ERROR_MESSAGE = 'an internal error occurred';
 const DEFAULT_TOKEN_FILE_NAME = 'xai-oauth-token.json';
 /** Matches the loopback listener's own 30-minute self-close timeout (OD's real comment: keeps the
  * PKCE state, the open socket, and any paste-back UI expiring together). */
@@ -361,7 +364,7 @@ export const xaiOauthStartRoute = defineJsonRoute({
                 await stopListener(resolved);
                 const correlationId = randomUUID();
                 resolved.onInternalError({ source: 'oauth-start', correlationId, error });
-                return err({ error: createApiError({ code: 'INTERNAL_ERROR', message: 'an internal error occurred' }, { requestId: correlationId }) });
+                return err({ error: createApiError({ code: 'INTERNAL_ERROR', message: INTERNAL_ERROR_MESSAGE }, { requestId: correlationId }) });
             }
         });
     }
@@ -410,7 +413,7 @@ export const xaiOauthCompleteRoute = defineJsonRoute({
             }
             const correlationId = randomUUID();
             resolved.onInternalError({ source: 'oauth-complete', correlationId, error: redactError(error) });
-            return err({ error: createApiError({ code: 'INTERNAL_ERROR', message: 'an internal error occurred' }, { requestId: correlationId }) });
+            return err({ error: createApiError({ code: 'INTERNAL_ERROR', message: INTERNAL_ERROR_MESSAGE }, { requestId: correlationId }) });
         }
     }
 }, { requireSameOrigin: true });
@@ -448,7 +451,7 @@ export const xaiAuthStatusRoute = defineJsonRoute({
         catch (error) {
             const correlationId = randomUUID();
             resolved.onInternalError({ source: 'auth-status', correlationId, error });
-            return err({ error: createApiError({ code: 'INTERNAL_ERROR', message: 'an internal error occurred' }, { requestId: correlationId }) });
+            return err({ error: createApiError({ code: 'INTERNAL_ERROR', message: INTERNAL_ERROR_MESSAGE }, { requestId: correlationId }) });
         }
     }
 }, { requireSameOrigin: true });
@@ -466,7 +469,7 @@ export const xaiOauthDisconnectRoute = defineJsonRoute({
         catch (error) {
             const correlationId = randomUUID();
             resolved.onInternalError({ source: 'oauth-disconnect', correlationId, error });
-            return err({ error: createApiError({ code: 'INTERNAL_ERROR', message: 'an internal error occurred' }, { requestId: correlationId }) });
+            return err({ error: createApiError({ code: 'INTERNAL_ERROR', message: INTERNAL_ERROR_MESSAGE }, { requestId: correlationId }) });
         }
     }
 }, { requireSameOrigin: true });
@@ -594,7 +597,7 @@ async function callXaiSearch(resolved, accessToken, request) {
     const baseUrlCheck = validateBaseUrl({ baseUrl: resolved.searchBaseUrl });
     if (baseUrlCheck.error)
         throw new Error(baseUrlCheck.error);
-    const base = resolved.searchBaseUrl.replace(/\/+$/, '');
+    const base = trimCharsEnd({ text: resolved.searchBaseUrl, chars: '/' });
     const model = request.model ?? resolved.searchDefaultModel;
     const requestBody = {
         model,
@@ -633,7 +636,7 @@ export const xaiSearchRoute = defineJsonRoute({
         catch (error) {
             const correlationId = randomUUID();
             resolved.onInternalError({ source: 'search', correlationId, error });
-            return err({ error: createApiError({ code: 'INTERNAL_ERROR', message: 'an internal error occurred' }, { requestId: correlationId }) });
+            return err({ error: createApiError({ code: 'INTERNAL_ERROR', message: INTERNAL_ERROR_MESSAGE }, { requestId: correlationId }) });
         }
         if (!credential) {
             // No entitlement gate here — see module doc's "Dropped: OD's SuperGrok subscription gate"
@@ -649,7 +652,7 @@ export const xaiSearchRoute = defineJsonRoute({
         catch (error) {
             const correlationId = randomUUID();
             resolved.onInternalError({ source: 'search', correlationId, error });
-            return err({ error: createApiError({ code: 'INTERNAL_ERROR', message: 'an internal error occurred' }, { requestId: correlationId }) });
+            return err({ error: createApiError({ code: 'INTERNAL_ERROR', message: INTERNAL_ERROR_MESSAGE }, { requestId: correlationId }) });
         }
     }
 }, { requireSameOrigin: true });

package/dist/legacy-data-migration.d.ts

@@ -122,18 +122,6 @@ export declare function dataDirHasExistingPayload({ dataDir, config }: {
 }, { filesystem: fs }?: {
     filesystem?: LegacyFilesystemPort;
 }): string[];
-/**
- * Move staged payload entries into the final `dataDir`. Each entry is moved
- * with `renameSync` (atomic on the same filesystem); a cross-device rename
- * falls back to copy + remove. Rollback-safe in two layers: the copy
- * fallback removes a partial destination on its own failure, and the outer
- * loop removes every entry it already promoted before rethrowing.
- *
- * @param stagingDir - The sibling staging directory holding the copied payload.
- * @param dataDir - The destination data root.
- * @param entries - The payload entries to promote.
- * @returns The entries that were placed into `dataDir` before any failure.
- */
 export declare function promoteStaged({ stagingDir, dataDir, entries }: {
     readonly stagingDir: string;
     readonly dataDir: string;

package/dist/legacy-data-migration.js

@@ -133,6 +133,26 @@ function stagePayload(legacyDir, stagingDir, payloadEntries, fs) {
  * @param entries - The payload entries to promote.
  * @returns The entries that were placed into `dataDir` before any failure.
  */
+/** Renames `src` to `dst`, falling back to copy-then-delete (e.g. across devices); a failed copy
+ *  removes its partial `dst` before rethrowing. */
+function moveEntry(src, dst, fs) {
+    try {
+        fs.renameSync(src, dst);
+    }
+    catch {
+        copyThenRemove(src, dst, fs);
+    }
+}
+function copyThenRemove(src, dst, fs) {
+    try {
+        fs.cpSync(src, dst, { recursive: true, force: true, errorOnExist: false });
+        fs.rmSync(src, { recursive: true, force: true });
+    }
+    catch (cpErr) {
+        fs.rmSync(dst, { recursive: true, force: true });
+        throw cpErr;
+    }
+}
 export function promoteStaged({ stagingDir, dataDir, entries }, { filesystem: fs = nodeFilesystem } = {}) {
     fs.mkdirSync(dataDir, { recursive: true });
     const promoted = [];
@@ -140,19 +160,7 @@ export function promoteStaged({ stagingDir, dataDir, entries }, { filesystem: fs
         for (const entry of entries) {
             const src = path.join(stagingDir, entry);
             const dst = path.join(dataDir, entry);
-            try {
-                fs.renameSync(src, dst);
-            }
-            catch {
-                try {
-                    fs.cpSync(src, dst, { recursive: true, force: true, errorOnExist: false });
-                    fs.rmSync(src, { recursive: true, force: true });
-                }
-                catch (cpErr) {
-                    fs.rmSync(dst, { recursive: true, force: true });
-                    throw cpErr;
-                }
-            }
+            moveEntry(src, dst, fs);
             promoted.push(entry);
         }
     }

package/dist/remote-tool-executor.js

@@ -146,7 +146,8 @@ function readToolStream({ res, settle, fail }, { emitSurface }) {
     res.on('data', (chunk) => {
         buffer += chunk;
         const lines = buffer.split('\n');
-        buffer = lines.pop() ?? '';
+        // String.split always produces at least one member, including for an empty chunk.
+        buffer = lines.pop();
         lines.forEach(onLine);
     });
     // Once the terminal line is in hand the outcome is known, so a later reset cannot unsettle it.

package/dist/routines/schedule.js

@@ -110,7 +110,8 @@ export function tzWallToUtcGapFallback({ timezone, year, month, day, hour, minut
 }
 function matchesWallClock(timezone, at, year, month, day, hour, minute) {
     const p = partsInTimezone({ timezone: timezone, atUtc: at });
-    return p.year === year && p.month === month && p.day === day && p.hour === hour && p.minute === minute;
+    const sameDate = p.year === year && p.month === month && p.day === day;
+    return sameDate && p.hour === hour && p.minute === minute;
 }
 /** Minutes east of UTC for `timezone` at instant `at`. e.g. Asia/Shanghai returns 480. */
 function tzOffsetMinutes(timezone, at) {

package/dist/routines/scheduler.js

@@ -43,6 +43,11 @@ export class ScheduledRunPersistenceError extends Error {
         this.name = 'ScheduledRunPersistenceError';
     }
 }
+/** What a failed scheduled run logs: the underlying error's message when there is one. */
+function scheduledRunFailureDetail(error) {
+    const cause = error instanceof ScheduledRunPersistenceError ? error.originalError : error;
+    return cause instanceof Error ? cause.message : cause;
+}
 function isScheduledRunPersistenceError(error) {
     return error instanceof ScheduledRunPersistenceError;
 }
@@ -136,13 +141,7 @@ export class RoutineService {
                 this.rescheduleOne({ routineId: routine.id });
             })
                 .catch((error) => {
-                console.error(`[@jini-ai/daemon] routine ${routine.id} scheduled run failed:`, error instanceof ScheduledRunPersistenceError
-                    ? error.originalError instanceof Error
-                        ? error.originalError.message
-                        : error.originalError
-                    : error instanceof Error
-                        ? error.message
-                        : error);
+                console.error(`[@jini-ai/daemon] routine ${routine.id} scheduled run failed:`, scheduledRunFailureDetail(error));
                 if (isScheduledRunPersistenceError(error)) {
                     this.retryScheduledSlot(routine.id, fireAt);
                 }

package/dist/run-lifecycle.js

@@ -101,7 +101,8 @@ function terminalStateFromEndEntry(entry) {
     if (!isRecord(entry.data))
         return { state: 'failed', resumable: false };
     const status = entry.data.status;
-    const state = status === 'succeeded' ? 'succeeded' : status === 'canceled' ? 'cancelled' : 'failed';
+    const unsuccessful = status === 'canceled' ? 'cancelled' : 'failed';
+    const state = status === 'succeeded' ? 'succeeded' : unsuccessful;
     return { state, resumable: entry.data.resumable === true };
 }
 // ---------------------------------------------------------------------------