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

package/dist/http/frontend-sessions.js

@@ -30,6 +30,7 @@
  */
 import { randomUUID } from 'node:crypto';
 import { createApiError } from '@jini-ai/protocol';
+import { FrontendSessionCapacityError } from '../frontend-session-registry.js';
 import { defineJsonRoute, mountJsonRoute } from '@jini-ai/http-kit';
 import { guardSameOrigin } from '@jini-ai/http-kit';
 import { createSseResponse } from '@jini-ai/http-kit';
@@ -59,7 +60,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)
@@ -71,20 +73,34 @@ export function parseCapabilityQuery({ raw }, _optional = {}) {
 /**
  * Handles one surface's stream from open to close.
  *
- * SSE commits `text/event-stream` headers before anything else can be known, so a bad request is
- * reported as one `{type:'error'}` data event and then closed — there is no status-code channel
- * left. Same precedent as `run-stream.ts`.
+ * Invalid capability queries use a final SSE error event. Capacity admission happens before
+ * opening the stream so resource refusals retain a real HTTP status and create no connection.
  */
-export function handleFrontendSessionStream({ req, res, deps }, _optional = {}) {
-    const capabilities = parseCapabilityQuery({ raw: req.query['capability'] });
+export function handleFrontendSessionStream({ req, res, deps, owner }, _optional = {}) {
+    const requested = parseCapabilityQuery({ raw: req.query['capability'] });
+    const capabilities = requested?.filter(id => !deps.allowedCapabilities || deps.allowedCapabilities.includes(id)) ?? null;
     // Assigned below, after the connection exists — `attach` needs something to deliver through, and
     // `onClose` has to be armed before then so a connection that dies during setup still detaches.
     let handle;
-    const connection = createSseResponse({ req, res }, {
-        // Detach on close rather than on an explicit teardown call: this fires for a closed tab and a
-        // dropped connection too, which an unregister route would not.
-        onClose: () => handle?.detach({}),
-    });
+    let expiry;
+    // Reserve capacity before committing SSE headers, so a full scope gets a real 429.
+    // Delivery cannot occur until the attached token has been sent to the client.
+    let connection;
+    if (capabilities !== null) {
+        handle = attachFrontendSession({ req, deps, capabilities, owner,
+            deliver: invocation => connection.send({ data: { type: 'invocation', ...invocation } }),
+            cancel: ({ invocationId }) => connection.send({ data: { type: 'cancelled', invocationId } }) });
+    }
+    try {
+        connection = createSseResponse({ req, res }, {
+            // Close and expiry release the same quota reservation, without a separate counter lifecycle.
+            onClose: () => { clearTimeout(expiry); handle?.detach({}); },
+        });
+    }
+    catch (error) {
+        handle?.detach({});
+        throw error;
+    }
     if (capabilities === null) {
         connection.send({
             data: {
@@ -95,16 +111,22 @@ export function handleFrontendSessionStream({ req, res, deps }, _optional = {})
         connection.close();
         return;
     }
-    const sessionId = (deps.newSessionId ?? randomUUID)();
-    handle = deps.registry.attach({ descriptor: { sessionId, capabilities }, deliver: (invocation) => connection.send({ data: { type: 'invocation', ...invocation } }) });
+    expiry = expireScopedSession({ owner, handle: handle, close: () => connection.close(), ttl: deps.sessionTtlMs });
     connection.send({
         data: {
             type: 'attached',
-            sessionId,
+            sessionId: handle.sessionId,
             bindToken: handle.bindToken,
         }
     });
 }
+/** Reserve the registry's capacity before SSE commits headers. Host keys are never client input. */
+function attachFrontendSession({ req, deps, capabilities, owner, deliver, cancel }) {
+    const sessionId = (deps.newSessionId ?? randomUUID)();
+    const capacityKeys = deps.resolveCapacityKeys?.({ req, ...(owner ? { owner } : {}) });
+    return deps.registry.attach({ descriptor: { sessionId, capabilities, ...(owner ? { owner } : {}), ...(capacityKeys ? { capacityKeys } : {}) },
+        deliver, cancel });
+}
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
@@ -119,12 +141,28 @@ function parseFrontendSessionResponse(input) {
     if (typeof invocationId !== 'string' || invocationId.trim().length === 0) {
         return err({ error: validationError({ message: 'invocationId must be a non-empty string' }, { issues: [{ path: 'invocationId', message: 'required non-empty string' }] }) });
     }
-    const okFlag = input.body['ok'];
+    return parseResponseOutcome({ sessionId, invocationId, body: input.body });
+}
+/** Progress is scoped to a pending invocation; only fixed, value-free decisions enter the audit. */
+function parseApprovalProgress({ sessionId, invocationId, phase, decision }, _options = {}) {
+    if (decision === undefined)
+        return ok({ value: { sessionId, invocationId, phase } });
+    if (phase !== 'execution-started' || typeof decision !== 'string' || !['approved', 'declined', 'expired', 'abandoned'].includes(decision)) {
+        return err({ error: validationError({ message: 'invalid approval decision' }) });
+    }
+    return ok({ value: { sessionId, invocationId, phase, decision: decision } });
+}
+/** Identity parsing precedes outcome parsing so progress and results share exactly one scope. */
+function parseResponseOutcome({ sessionId, invocationId, body }, _options = {}) {
+    const phase = body['phase'];
+    if (phase === 'approval-pending' || phase === 'execution-started')
+        return parseApprovalProgress({ sessionId, invocationId, phase, decision: body['decision'] });
+    const okFlag = body['ok'];
     if (typeof okFlag !== 'boolean') {
         return err({ error: validationError({ message: 'ok must be a boolean' }, { issues: [{ path: 'ok', message: 'required boolean' }] }) });
     }
     if (!okFlag) {
-        const message = input.body['message'];
+        const message = body['message'];
         if (typeof message !== 'string' || message.trim().length === 0) {
             // A failure with no reason gives the agent nothing to act on, which is how a caller ends up
             // retrying the same refusal forever.
@@ -132,7 +170,7 @@ function parseFrontendSessionResponse(input) {
         }
         return ok({ value: { sessionId, invocationId, ok: false, message } });
     }
-    return ok({ value: { sessionId, invocationId, ok: true, output: input.body['output'] } });
+    return ok({ value: { sessionId, invocationId, ok: true, output: body['output'] } });
 }
 /**
  * `POST /api/frontend-sessions/:sessionId/responses` — delivers a surface's answer to the tool
@@ -141,6 +179,8 @@ function parseFrontendSessionResponse(input) {
  */
 export const frontendSessionResponseRoute = defineJsonRoute({
     method: 'post', path: FRONTEND_SESSION_RESPONSE_ROUTE_PATH, parse: parseFrontendSessionResponse, handle: ({ input, deps }) => {
+        if ('phase' in input)
+            return ok({ value: { settled: deps.registry.progress({ sessionId: input.sessionId, invocationId: input.invocationId, pending: input.phase === 'approval-pending', ...(input.decision ? { decision: input.decision } : {}) }) } });
         const settled = deps.registry.settle({ sessionId: input.sessionId, invocationId: input.invocationId, outcome: input.ok
                 ? { ok: true, output: input.output }
                 : { ok: false, message: input.message } });
@@ -156,25 +196,65 @@ export const frontendSessionResponseRoute = defineJsonRoute({
  * never gets a stream (and, notably, never mints a session id or `bindToken` either).
  */
 export function registerFrontendSessionRoutes({ app, deps, adapter }, _optional = {}) {
-    app.get(FRONTEND_SESSION_STREAM_ROUTE_PATH, (req, res) => {
-        const origin = guardSameOrigin({ req, origin: adapter });
+    const prefix = deps.routePrefix ?? '/api/frontend-sessions';
+    app.get(`${prefix}/stream`, async (req, res) => {
+        // Scoped hosts authenticate origin together with guest/tab ownership in resolveOwner.
+        const origin = deps.resolveOwner ? ok({ value: undefined }) : guardSameOrigin({ req, origin: adapter });
         if (!origin.ok) {
             sendApiError({ res, status: statusForError({ error: origin.error }), error: origin.error });
             return;
         }
         try {
-            handleFrontendSessionStream({ req, res, deps });
+            const owner = deps.resolveOwner ? await deps.resolveOwner({ req, res }) : undefined;
+            if (owner === null) {
+                res.sendStatus(403);
+                return;
+            }
+            handleFrontendSessionStream({ req, res, deps, ...(owner ? { owner } : {}) });
         }
         catch (error) {
-            reportInternalError(deps, 'stream', error);
-            if (!res.headersSent) {
-                res.status(500).json({ error: createApiError({ code: 'INTERNAL_ERROR', message: 'an internal error occurred' }) });
-            }
-            else if (!res.writableEnded) {
-                res.end();
-            }
+            endStreamOnError({ error, res, deps });
         }
     });
-    mountJsonRoute({ app, spec: frontendSessionResponseRoute, deps, adapter });
+    const responsePath = `${prefix}/:sessionId/responses`;
+    if (deps.resolveOwner)
+        app.post(responsePath, async (req, res, next) => {
+            try {
+                const owner = await deps.resolveOwner({ req, res });
+                const bindToken = req.get('x-frontend-bind-token') ?? '';
+                if (!owner || !deps.registry.ownsSession({ sessionId: String(req.params['sessionId']), owner, bindToken })) {
+                    res.sendStatus(403);
+                    return;
+                }
+                next();
+            }
+            catch {
+                res.sendStatus(403);
+            }
+        });
+    mountJsonRoute({ app, spec: { ...frontendSessionResponseRoute, path: responsePath, requireSameOrigin: !deps.resolveOwner }, deps, adapter });
+}
+/** Capacity is ordinary admission refusal, not a loggable internal failure. */
+function endStreamOnError({ error, res, deps }) {
+    if (error instanceof FrontendSessionCapacityError && !res.headersSent) {
+        res.sendStatus(429);
+        return;
+    }
+    reportInternalError(deps, 'stream', error);
+    if (res.headersSent) {
+        if (!res.writableEnded)
+            res.end();
+    }
+    else {
+        res.status(500).json({ error: createApiError({ code: 'INTERNAL_ERROR', message: 'an internal error occurred' }) });
+    }
+}
+/** Expiry tears down addressing and the stream together, including clients which never disconnect. */
+function expireScopedSession({ owner, handle, close, ttl = 30 * 60_000 }) {
+    if (!owner)
+        return undefined;
+    const timer = setTimeout(() => { handle.detach({}); close(); }, ttl);
+    timer.unref();
+    return timer;
 }
 //# sourceMappingURL=frontend-sessions.js.map

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/index.d.ts

@@ -57,4 +57,5 @@ export { ATTACHMENT_LOOKUP_ROUTE_PATH, registerAttachmentLookupRoutes } from './
 export type { RemoteAttachmentLookupOptional, RemoteAttachmentLookupRequired } from '../remote-attachment-lookup.js';
 export { createRemoteAttachmentLookup } from '../remote-attachment-lookup.js';
 export { createTavilyResearchProvider } from './research-tavily.adapter.js';
+export { createFrontendGuestScope } from './frontend-guest-scope.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/http/index.js

@@ -30,4 +30,5 @@ export { DEFAULT_TOOL_EXEC_MAX_BODY_BYTES, DEFAULT_TOOL_EXEC_TOKEN_ENV_VAR, regi
 export { ATTACHMENT_LOOKUP_ROUTE_PATH, registerAttachmentLookupRoutes } from './attachment-lookup-routes.js';
 export { createRemoteAttachmentLookup } from '../remote-attachment-lookup.js';
 export { createTavilyResearchProvider } from './research-tavily.adapter.js';
+export { createFrontendGuestScope } from './frontend-guest-scope.js';
 //# sourceMappingURL=index.js.map

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/index.d.ts

@@ -72,8 +72,8 @@
  *   solution belongs at the lifecycle or transport boundary, rather than a
  *   restart-unsafe recorder cache that makes the two paths disagree.
  *
- * node-pty uses native addons. Linux deployment requires python3, make and a
- * C/C++ compiler during installation; source compilation is the fallback.
+ * The opt-in @jini-ai/daemon/terminal adapter uses node-pty's native addon.
+ * Linux hosts selecting it need python3, make and a C/C++ compiler for fallback compilation.
  * Vendoring foreign prebuilt binaries would create an unowned maintenance burden.
  * See the owning modules and packages/daemon/README.md for detailed contracts.
  */

package/dist/index.js

@@ -72,8 +72,8 @@
  *   solution belongs at the lifecycle or transport boundary, rather than a
  *   restart-unsafe recorder cache that makes the two paths disagree.
  *
- * node-pty uses native addons. Linux deployment requires python3, make and a
- * C/C++ compiler during installation; source compilation is the fallback.
+ * The opt-in @jini-ai/daemon/terminal adapter uses node-pty's native addon.
+ * Linux hosts selecting it need python3, make and a C/C++ compiler for fallback compilation.
  * Vendoring foreign prebuilt binaries would create an unowned maintenance burden.
  * See the owning modules and packages/daemon/README.md for detailed contracts.
  */

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 };
 }
 // ---------------------------------------------------------------------------