@jini-ai/daemon 0.6.8 → 0.6.9

package/dist/terminal-session.js

@@ -115,6 +115,10 @@ function toSessionInfo(session, resourceRef) {
         signal: session.signal,
     };
 }
+/** Drop undefined-valued keys so an omitted option never overrides the engine's own default. */
+function definedOnly(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined));
+}
 /**
  * Serializes calls made for the same `id` through a per-id promise chain
  * (matching this codebase's `oauth-tokens.ts` `withLock` precedent), so a
@@ -141,18 +145,19 @@ async function runExclusive(locks, id, fn) {
  * the kill/write/resize lock, and (via {@link createTerminalToolRegistrations})
  * `ToolExecutor` gating for creation. See module doc for the full design.
  */
-export function createTerminalSessionManager(requiredArgs, optionalArgs = {}) {
-    const options = { ...requiredArgs, ...optionalArgs };
+export function createTerminalSessionManager(_requiredArgs, options = {}) {
     const terminalService = options.terminalService ??
         createTerminalService({
             loadSpawnPty: options.loadSpawnPty ?? (() => loadRealSpawnPty({})),
-            ...(options.maxEvents !== undefined ? { maxEvents: options.maxEvents } : {}),
-            ...(options.maxBufferBytes !== undefined ? { maxBufferBytes: options.maxBufferBytes } : {}),
-            ...(options.exitTailBytes !== undefined ? { exitTailBytes: options.exitTailBytes } : {}),
-            ...(options.flushIntervalMs !== undefined ? { flushIntervalMs: options.flushIntervalMs } : {}),
-            ...(options.flushThresholdBytes !== undefined ? { flushThresholdBytes: options.flushThresholdBytes } : {}),
-            ...(options.ttlMs !== undefined ? { ttlMs: options.ttlMs } : {}),
-            ...(options.shutdownGraceMs !== undefined ? { shutdownGraceMs: options.shutdownGraceMs } : {}),
+            ...definedOnly({
+                maxEvents: options.maxEvents,
+                maxBufferBytes: options.maxBufferBytes,
+                exitTailBytes: options.exitTailBytes,
+                flushIntervalMs: options.flushIntervalMs,
+                flushThresholdBytes: options.flushThresholdBytes,
+                ttlMs: options.ttlMs,
+                shutdownGraceMs: options.shutdownGraceMs,
+            }),
         });
     const metadata = new Map();
     const locks = new Map();
@@ -181,9 +186,7 @@ export function createTerminalSessionManager(requiredArgs, optionalArgs = {}) {
     async function create({ principal, options: createOptions }) {
         const session = await terminalService.create({
             cwd: createOptions.cwd,
-            ...(createOptions.cols !== undefined ? { cols: createOptions.cols } : {}),
-            ...(createOptions.rows !== undefined ? { rows: createOptions.rows } : {}),
-            ...(createOptions.shell !== undefined ? { shell: createOptions.shell } : {}),
+            ...definedOnly({ cols: createOptions.cols, rows: createOptions.rows, shell: createOptions.shell }),
         });
         const resourceRef = createOptions.resourceRef ?? null;
         metadata.set(session.id, { principalId: principal.id, resourceRef, killed: false });
@@ -210,7 +213,8 @@ export function createTerminalSessionManager(requiredArgs, optionalArgs = {}) {
         const session = terminalService.get(id);
         return session ? toSessionInfo(session, resourceRef) : null;
     }
-    async function write({ principal, id, input }) {
+    /** Shared write/resize path: ownership check, then the per-session lock, then the killed flag. */
+    async function unlessKilled(principal, id, act) {
         const found = checkOwnership(principal, id);
         if (!found)
             return { status: 'not-found' };
@@ -221,22 +225,15 @@ export function createTerminalSessionManager(requiredArgs, optionalArgs = {}) {
             if (!meta || meta.killed) {
                 return { status: 'ok', ok: false, session: currentSnapshot(id, meta?.resourceRef ?? null) };
             }
-            const ok = terminalService.write(id, input);
+            const ok = act();
             return { status: 'ok', ok, session: currentSnapshot(id, meta.resourceRef) };
         });
     }
+    async function write({ principal, id, input }) {
+        return unlessKilled(principal, id, () => terminalService.write(id, input));
+    }
     async function resize({ principal, id, cols, rows }) {
-        const found = checkOwnership(principal, id);
-        if (!found)
-            return { status: 'not-found' };
-        return runExclusive(locks, id, () => {
-            const meta = metadata.get(id);
-            if (!meta || meta.killed) {
-                return { status: 'ok', ok: false, session: currentSnapshot(id, meta?.resourceRef ?? null) };
-            }
-            const ok = terminalService.resize(id, cols, rows);
-            return { status: 'ok', ok, session: currentSnapshot(id, meta.resourceRef) };
-        });
+        return unlessKilled(principal, id, () => terminalService.resize(id, cols, rows));
     }
     async function kill({ principal, id }, { signal } = {}) {
         const found = checkOwnership(principal, id);
@@ -280,12 +277,9 @@ function isRecord(value) {
  * precedent).
  */
 export function createTerminalToolRegistrations(requiredArgs, optionalArgs = {}) {
-    const options = { ...requiredArgs, ...optionalArgs };
-    const { manager, policy = denyAllTerminalCreatePolicy, requiresConfirmation, timeoutMs } = options;
-    const descriptorExtras = {
-        ...(requiresConfirmation !== undefined ? { requiresConfirmation } : {}),
-        ...(timeoutMs !== undefined ? { timeoutMs } : {}),
-    };
+    const { manager } = requiredArgs;
+    const { policy = denyAllTerminalCreatePolicy, requiresConfirmation, timeoutMs } = optionalArgs;
+    const descriptorExtras = definedOnly({ requiresConfirmation, timeoutMs });
     return {
         create: {
             descriptor: {
@@ -307,8 +301,7 @@ export function createTerminalToolRegistrations(requiredArgs, optionalArgs = {})
                 return manager.create({ principal: ctx.principal, options: {
                         resourceRef,
                         cwd,
-                        ...(cols !== undefined ? { cols } : {}),
-                        ...(rows !== undefined ? { rows } : {}),
+                        ...definedOnly({ cols, rows }),
                         shell,
                     } });
             },

package/dist/tool-audit.d.ts

@@ -1,2 +1,3 @@
 export * from './core/tool-audit.js';
+export * from './core/tool-gaps.js';
 //# sourceMappingURL=tool-audit.d.ts.map

package/dist/tool-audit.js

@@ -1,3 +1,4 @@
 // Shared audit owner; used by standalone auditing and the recovery stack.
 export * from './core/tool-audit.js';
+export * from './core/tool-gaps.js';
 //# sourceMappingURL=tool-audit.js.map

package/dist/tool-executor.d.ts

@@ -70,6 +70,8 @@ export type ToolExecutionStatus = 'completed' | 'denied' | 'confirmation-denied'
  */
 export type ToolExecutionErrorKind = 'validation' | 'internal';
 export interface ToolExecutionResult {
+    /** Value-free rewrites, retained even when output text is truncated. */
+    readonly normalizationNotes?: readonly string[];
     readonly executionId: string;
     readonly status: ToolExecutionStatus;
     readonly output?: unknown;
@@ -99,7 +101,7 @@ export interface ToolExecutor {
         readonly executionId: string;
         readonly decision: ConfirmationDecision;
     }): void;
-    /** Aborts an in-flight handler, or resolves a still-pending confirmation as denied. No-op if `executionId` is already terminal or unknown. */
+    /** Cancels an in-flight execution, unblocking a still-pending confirmation. No-op if `executionId` is already terminal or unknown. */
     cancel(args: {
         readonly executionId: string;
     }): void;
@@ -107,12 +109,30 @@ export interface ToolExecutor {
         readonly executionId: string;
     }): ToolExecutionAuditRecord | null;
 }
+/** Advisory preparation after authorization/confirmation, before the handler. A failure is fail-open. */
+export type PrepareToolGuidance = (required: {
+    principal: Principal;
+    run: RunRef;
+    tool: ToolDescriptor;
+    signal: AbortSignal;
+    emitSurface?: SurfaceEmitter;
+}, optional?: Record<string, never>) => Promise<string>;
 export interface CreateToolExecutorOptions {
+    readonly prepareGuidance?: PrepareToolGuidance;
     readonly registry: ToolRegistry;
     readonly delegate?: ExecutionDelegate;
     /** Injectable clock for audit timestamps — defaults to `Date.now`. Test-only hook. */
     readonly now?: () => number;
+    /** Cap on retained finished audit records, oldest evicted first. See {@link DEFAULT_MAX_AUDIT_RECORDS}. */
+    readonly maxAuditRecords?: number;
 }
+/**
+ * Default cap on finished audit records kept for `getAuditRecord`. One record is added per tool
+ * execution and nothing else ever removed one, so a long-lived daemon grew the map for its whole
+ * uptime (memory investigation 2026-10-21). An in-flight execution's record is never evicted: its
+ * later transitions still have to land on it.
+ */
+export declare const DEFAULT_MAX_AUDIT_RECORDS = 1000;
 /**
  * Creates the `ToolExecutor` reference implementation: an in-process,
  * in-memory gate over a `ToolRegistry`. No persistence — a real host that
@@ -125,8 +145,9 @@ export interface CreateToolExecutorOptions {
  * — the one and only caller of that internal export.
  * @param options.delegate - Transport-supplied authorize/confirm UI seam;
  * omit for a headless caller whose tools never need interactive gating.
- * @complexity Known-id `execute` is O(1) plus the handler's own cost; unknown ids scan O(n) descriptors for hints. `resumeConfirmation`/`cancel`/`getAuditRecord` are O(1) map lookups.
+ * @param options.maxAuditRecords - Finished audit records kept, see {@link DEFAULT_MAX_AUDIT_RECORDS}.
+ * @complexity Known-id `execute` adds schema-guided normalization to the handler's cost; unknown ids scan O(n) descriptors for hints. `resumeConfirmation`/`cancel`/`getAuditRecord` are O(1) map lookups.
  * @overallScore 100/100
  */
-export declare function createToolExecutor(requiredArgs: Pick<CreateToolExecutorOptions, "registry">, optionalArgs?: Pick<CreateToolExecutorOptions, "delegate" | "now">): ToolExecutor;
+export declare function createToolExecutor(requiredArgs: Pick<CreateToolExecutorOptions, "registry">, optionalArgs?: Pick<CreateToolExecutorOptions, "delegate" | "now" | "prepareGuidance" | "maxAuditRecords">): ToolExecutor;
 //# sourceMappingURL=tool-executor.d.ts.map