@lensagent/core 0.1.0 → 0.1.2

package/dist/config/runtime.js

@@ -1,18 +1,21 @@
 import { createHash, randomUUID } from 'node:crypto';
 import { watch } from 'node:fs';
-import { readFile, rename, writeFile } from 'node:fs/promises';
+import { readFile, rename, rm, writeFile } from 'node:fs/promises';
 import { basename, dirname, isAbsolute, normalize, resolve } from 'node:path';
 import { Ajv } from 'ajv';
 import { canonicalize } from 'json-canonicalize';
 import { parse } from 'jsonc-parser';
 import { fail } from '../core/domain.js';
 import { ConfigSchema } from './schema.js';
+import { modelReasoningEfforts } from '../runtime/profile.js';
 export class ConfigRuntime {
     path;
     #validate;
     #snapshot;
     #watcher;
     #reloadTail = Promise.resolve();
+    #source = null;
+    #onChange;
     constructor(root, path = 'config/lens.jsonc') {
         this.path = resolve(root, path);
         this.#validate = new Ajv({ allErrors: true, strict: false }).compile(ConfigSchema);
@@ -28,11 +31,13 @@ export class ConfigRuntime {
             source = await readFile(this.path, 'utf8');
         }
         catch (error) {
+            this.#source = null;
             fail('CONFIG_INVALID', 503, 'The configuration file could not be read.', { reason: message(error) });
         }
+        this.#source = source;
         const previous = this.#snapshot;
         const fileDigest = hash(source);
-        if (previous?.fileDigest === fileDigest)
+        if (previous?.fileDigest === fileDigest && previous.error === null)
             return previous;
         const candidate = this.parse(source);
         const config = previous === undefined ? candidate : effective(previous.config, candidate);
@@ -47,6 +52,15 @@ export class ConfigRuntime {
             error: null
         };
         this.#snapshot = next;
+        if (previous !== undefined) {
+            try {
+                this.#onChange?.(next);
+            }
+            catch {
+                this.#snapshot = { ...next, error: 'CONFIG_APPLY_FAILED', appliedHot: [] };
+                fail('CONFIG_APPLY_FAILED', 503, 'Configuration was saved but could not be applied.');
+            }
+        }
         return next;
     }
     parse(source) {
@@ -58,89 +72,107 @@ export class ConfigRuntime {
         const semantic = semanticIssues(document);
         if (semantic.length > 0)
             fail('CONFIG_INVALID', 400, 'The configuration is invalid.', { issues: semantic });
+        // Migrate the two former checklist names without advertising executable aliases.
+        for (const role of Object.values(document.roles)) {
+            role.capabilities = [...new Set(role.capabilities.filter((id) => id !== 'compact').map((id) => id === 'slash_command_list' || id === 'slash_command_run' ? 'slash_command' : id === 'update_plan' || id === 'update_todo' ? 'todo' : id))];
+        }
+        for (const preset of Object.values(document.policyPresets)) {
+            const policies = preset.capabilities;
+            const previous = policies.update_todo ?? policies.update_plan;
+            if (policies.todo === undefined && previous !== undefined)
+                policies.todo = previous;
+            const slashPolicy = policies.slash_command_run ?? policies.slash_command_list;
+            if (policies.slash_command === undefined && slashPolicy !== undefined)
+                policies.slash_command = slashPolicy;
+            delete policies.compact;
+            delete policies.slash_command_list;
+            delete policies.slash_command_run;
+            delete policies.update_plan;
+            delete policies.update_todo;
+        }
         return document;
     }
     validate(source) {
         try {
             const config = this.parse(source);
-            return { valid: true, normalized_digest: hash(canonicalize(config)), errors: [] };
+            return { valid: true, normalized_digest: hash(canonicalize(config)), errors: [], warnings: unsupportedSettings(config) };
         }
         catch (error) {
-            return { valid: false, normalized_digest: null, errors: validationDetails(error) };
+            return { valid: false, normalized_digest: null, errors: validationDetails(error), warnings: [] };
         }
     }
-    replace(source, expectedFileDigest) {
-        if (expectedFileDigest !== this.current.fileDigest)
-            fail('CONFIG_CONFLICT', 409, 'The configuration file changed.');
-        // Resolved against the file, because the document the client edited was rendered from the file.
-        // Using the effective config would fail to restore a secret belonging to a restart-only setting
-        // that has been saved but not yet applied -- the placeholder would be written as the value.
-        const persisted = restoreSecrets(source, this.current.fileConfig);
-        this.parse(persisted);
+    replace(source, expectedFileDigest, authorize = () => { }) {
         const operation = this.#reloadTail.then(async () => {
+            await authorize();
+            const currentSource = await readFile(this.path, 'utf8');
+            if (expectedFileDigest !== hash(currentSource))
+                fail('CONFIG_CONFLICT', 409, 'The configuration file changed.');
+            this.parse(source);
             const temporary = `${this.path}.${process.pid}.${randomUUID()}.tmp`;
-            await writeFile(temporary, persisted, 'utf8');
-            await rename(temporary, this.path);
-            return this.load();
+            try {
+                await writeFile(temporary, source, { encoding: 'utf8', mode: 0o600 });
+                await authorize();
+                if (expectedFileDigest !== hash(await readFile(this.path, 'utf8')))
+                    fail('CONFIG_CONFLICT', 409, 'The configuration file changed.');
+                await rename(temporary, this.path);
+                return await this.load();
+            }
+            finally {
+                await rm(temporary, { force: true });
+            }
         });
         this.#reloadTail = operation.then(() => undefined, () => undefined);
         return operation;
     }
     start(onChange) {
+        this.#onChange = onChange;
         this.#watcher = watch(dirname(this.path), (_event, filename) => {
             if (filename !== null && filename !== basename(this.path))
                 return;
             this.#reloadTail = this.#reloadTail.then(async () => {
                 try {
-                    const previous = this.current;
-                    const next = await this.load();
-                    if (next !== previous)
-                        onChange(next);
+                    await this.load();
                 }
                 catch (error) {
                     const current = this.current;
-                    const source = await readFile(this.path, 'utf8').catch(() => '');
+                    const source = await readFile(this.path, 'utf8').catch(() => null);
+                    this.#source = source;
                     const next = {
                         ...current,
-                        fileDigest: hash(source),
+                        fileDigest: hash(source ?? ''),
                         metadataRevision: current.metadataRevision + 1,
                         error: message(error)
                     };
                     this.#snapshot = next;
-                    onChange(next);
+                    try {
+                        onChange(next);
+                    }
+                    catch { /* Snapshot retains the visible application error. */ }
                 }
-            });
+            }).catch(() => undefined);
         });
     }
     close() {
         this.#watcher?.close();
         this.#watcher = undefined;
     }
-    publicConfig() {
-        return redact(this.current.config);
-    }
-    /** The file as a client should see it: every saved setting, with secrets redacted. */
-    publicFileConfig() {
-        return redact(this.current.fileConfig);
-    }
     document() {
         const snapshot = this.current;
-        // Rendered from the file, not the effective config, so a restart-only setting that has been
-        // saved is visible and survives the next read/modify/write.
-        const content = snapshot.error === null ? `${JSON.stringify(this.publicFileConfig(), null, 2)}\n` : null;
+        const content = this.#source;
         return {
             content,
             content_omitted: content === null,
             // Documented as a decimal string, like the revisions, so a client never has to guess
             // whether a large size arrived as a number.
-            file_size_bytes: String(content === null ? 0 : Buffer.byteLength(content)),
+            file_size_bytes: String(Buffer.byteLength(content ?? '')),
             file_digest: snapshot.fileDigest,
             active_config_digest: snapshot.digest,
-            file_valid: snapshot.error === null,
+            file_valid: snapshot.error === null && content !== null,
             // `SchemaIssue` carries a path and a stable code beside the message.
-            validation_errors: snapshot.error === null
+            validation_errors: snapshot.error === null && content !== null
                 ? []
-                : [{ path: '/', code: 'CONFIG_INVALID', message: snapshot.error }],
+                : [{ path: '/', code: 'CONFIG_INVALID', message: snapshot.error ?? 'The configuration file could not be read.' }],
+            validation_warnings: unsupportedSettings(snapshot.fileConfig),
             applied_hot: snapshot.appliedHot,
             pending_restart: snapshot.pendingRestart
         };
@@ -157,55 +189,6 @@ export function resolveSecret(value) {
     }
     return secret;
 }
-function redact(value, key = '', headerValue = false) {
-    if (typeof value === 'string' && (key === 'apiKey' || headerValue))
-        return '[redacted]';
-    if (Array.isArray(value))
-        return value.map((entry) => redact(entry, '', headerValue));
-    if (typeof value !== 'object' || value === null)
-        return value;
-    return Object.fromEntries(Object.entries(value).map(([entryKey, entry]) => [
-        entryKey,
-        redact(entry, entryKey, headerValue || key === 'headers')
-    ]));
-}
-function restoreSecrets(source, current) {
-    const candidate = parse(source);
-    if (typeof candidate !== 'object' || candidate === null || Array.isArray(candidate))
-        return source;
-    let changed = false;
-    const document = candidate;
-    const providers = record(document.providers);
-    for (const [providerId, provider] of Object.entries(providers ?? {})) {
-        const options = record(record(provider)?.options);
-        if (options?.apiKey !== '[redacted]')
-            continue;
-        const existing = current.providers[providerId]?.options.apiKey;
-        if (existing !== undefined) {
-            options.apiKey = existing;
-            changed = true;
-        }
-    }
-    const servers = record(document.mcpServers);
-    for (const [serverId, server] of Object.entries(servers ?? {})) {
-        const headers = record(record(server)?.headers);
-        if (headers === null)
-            continue;
-        for (const [name, value] of Object.entries(headers)) {
-            if (value !== '[redacted]')
-                continue;
-            const existing = current.mcpServers?.[serverId]?.headers?.[name];
-            if (existing !== undefined) {
-                headers[name] = existing;
-                changed = true;
-            }
-        }
-    }
-    return changed ? `${JSON.stringify(document, null, 2)}\n` : source;
-}
-function record(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value) ? value : null;
-}
 function hash(value) {
     return createHash('sha256').update(value).digest('hex');
 }
@@ -230,20 +213,34 @@ function semanticIssues(config) {
     const result = [];
     const issue = (path, messageValue) => { result.push({ kind: 'semantic', path, message: messageValue }); };
     const profiles = new Set(Object.keys(config.modelHarnessProfiles ?? {}));
-    for (const [profileId, profile] of Object.entries(config.modelHarnessProfiles ?? {})) {
-        if (!profile.effort.allowed.includes(profile.effort.default))
-            issue(`/modelHarnessProfiles/${profileId}/effort/default`, 'The default effort is not allowed by the profile.');
-    }
     for (const [providerId, provider] of Object.entries(config.providers)) {
         if (!/^[a-z0-9][a-z0-9._-]{0,127}$/u.test(providerId))
             issue(`/providers/${providerId}`, 'Provider ID is invalid.');
         if (provider.adapter === '@ai-sdk/openai-compatible' && provider.options.baseURL === undefined)
             issue(`/providers/${providerId}/options/baseURL`, 'OpenAI-compatible providers require baseURL.');
         for (const [modelId, model] of Object.entries(provider.models)) {
+            if (modelReasoningEfforts(config, `${providerId}/${modelId}`).length === 0)
+                issue(`/providers/${providerId}/models/${modelId}/reasoningEfforts`, 'Declare reasoningEfforts on the Model or its Provider.');
             if (modelId.length === 0 || modelId.includes('\n'))
                 issue(`/providers/${providerId}/models/${modelId}`, 'Model ID is invalid.');
             if (model.harnessProfile !== undefined && !profiles.has(model.harnessProfile))
                 issue(`/providers/${providerId}/models/${modelId}/harnessProfile`, 'Model Harness Profile does not exist.');
+            if (provider.adapter === '@ai-sdk/openai-compatible' && model.harnessProfile !== undefined && config.modelHarnessProfiles?.[model.harnessProfile]?.semantics.reasoningStateRoundTrip === 'required') {
+                issue(`/providers/${providerId}/models/${modelId}/harnessProfile`, 'This adapter cannot guarantee required reasoning state round trips.');
+            }
+            const cache = model.promptCache ?? provider.promptCache;
+            if (cache !== undefined) {
+                const path = `/providers/${providerId}/models/${modelId}/promptCache`;
+                if ((cache.mode === 'anthropic' && provider.adapter !== '@ai-sdk/anthropic') || (cache.mode === 'openai-explicit' && provider.adapter !== '@ai-sdk/openai'))
+                    issue(path, 'Cache mode must match the Provider adapter.');
+                if (cache.ttl !== undefined && !((cache.mode === 'anthropic' && cache.ttl !== '30m') || (cache.mode === 'openai-explicit' && cache.ttl === '30m')))
+                    issue(path, 'Cache TTL must match an explicit cache mode.');
+                if (cache.retention !== undefined && (provider.adapter !== '@ai-sdk/openai' || cache.mode !== 'implicit'))
+                    issue(path, 'Cache retention applies only to OpenAI implicit caching.');
+            }
+            const threshold = model.compactionThresholdTokens ?? provider.compactionThresholdTokens;
+            if (threshold !== undefined && threshold > model.contextWindowTokens)
+                issue(`/providers/${providerId}/models/${modelId}/compactionThresholdTokens`, 'The effective Compaction threshold cannot exceed the model context window.');
         }
     }
     for (const [roleName, role] of Object.entries(config.roles)) {
@@ -253,12 +250,9 @@ function semanticIssues(config) {
             issue(`/roles/${roleName}/model`, 'Role model is not configured.');
         if (role.modelReasoningEffort === null)
             issue(`/roles/${roleName}/modelReasoningEffort`, 'Role reasoning effort is required.');
-        else {
-            const allowed = model?.harnessProfile === undefined
-                ? ['none', 'minimal', 'low', 'medium', 'high']
-                : config.modelHarnessProfiles?.[model.harnessProfile]?.effort.allowed ?? [];
-            if (!allowed.includes(role.modelReasoningEffort))
-                issue(`/roles/${roleName}/modelReasoningEffort`, 'Role reasoning effort is not allowed by the Model Harness Profile.');
+        else if (model !== undefined && role.model !== null) {
+            if (!modelReasoningEfforts(config, role.model).includes(role.modelReasoningEffort))
+                issue(`/roles/${roleName}/modelReasoningEffort`, 'Select an effort from the Model or Provider reasoningEfforts.');
         }
         if (agentRole && (role.policyPreset === null || config.policyPresets[role.policyPreset] === undefined))
             issue(`/roles/${roleName}/policyPreset`, 'Agent roles require an existing Policy preset.');
@@ -273,6 +267,8 @@ function semanticIssues(config) {
         for (const reference of role.providerRouting.fallback) {
             if (configuredModel(config, reference) === undefined)
                 issue(`/roles/${roleName}/providerRouting/fallback`, `Fallback model ${reference} is not configured.`);
+            else if (role.modelReasoningEffort !== null && !modelReasoningEfforts(config, reference).includes(role.modelReasoningEffort))
+                issue(`/roles/${roleName}/providerRouting/fallback`, `Fallback model ${reference} does not list the selected effort ${role.modelReasoningEffort}.`);
         }
     }
     for (const [serverId, server] of Object.entries(config.mcpServers ?? {})) {
@@ -338,12 +334,16 @@ function effective(current, candidate) {
     delete hot.observability;
     delete hot.mcpServers;
     delete hot.lspServers;
+    delete hot.localExecutor;
+    delete hot.executors;
     return {
         ...hot,
         listen: current.listen,
         tls: current.tls,
         database: current.database,
         executor: current.executor,
+        ...(current.localExecutor === undefined ? {} : { localExecutor: current.localExecutor }),
+        ...(current.executors === undefined ? {} : { executors: current.executors }),
         artifacts: current.artifacts,
         ...(current.pairPath === undefined ? {} : { pairPath: current.pairPath }),
         ...(current.persistence === undefined ? {} : { persistence: current.persistence }),
@@ -357,7 +357,7 @@ function effective(current, candidate) {
  * `pending_restart`. Returns the changed setting names rather than a flag so a client can say
  * which ones are waiting.
  */
-const RESTART_SETTINGS = ['listen', 'tls', 'database', 'executor', 'artifacts', 'pairPath', 'persistence', 'observability', 'mcpServers', 'lspServers'];
+const RESTART_SETTINGS = ['listen', 'tls', 'database', 'executor', 'localExecutor', 'executors', 'artifacts', 'pairPath', 'persistence', 'observability', 'mcpServers', 'lspServers'];
 function restartPending(current, candidate) {
     return RESTART_SETTINGS.filter((key) => JSON.stringify(current[key]) !== JSON.stringify(candidate[key]));
 }
@@ -369,3 +369,22 @@ function appliedHot(current, candidate) {
         .filter((key) => JSON.stringify(current[key]) !== JSON.stringify(candidate[key]))
         .sort();
 }
+function unsupportedSettings(config) {
+    const warnings = [];
+    const warn = (path) => { warnings.push({ path, code: 'CONFIG_NOT_IMPLEMENTED', message: 'This setting is accepted for existing files but does not control runtime behavior.' }); };
+    if (config.capabilityInput !== undefined)
+        warn('/capabilityInput');
+    if (config.contextProjection !== undefined)
+        warn('/contextProjection');
+    for (const [id, profile] of Object.entries(config.modelHarnessProfiles ?? {})) {
+        const root = `/modelHarnessProfiles/${id}`;
+        warn(`${root}/context/segmentOrder`);
+        warn(`${root}/semantics/structuredOutput`);
+        warn(`${root}/semantics/toolDescriptionStyle`);
+        warn(`${root}/semantics/recoveryConstraints/preserveReasoningState`);
+        warn(`${root}/cache/segmentStability`);
+        if (profile.ptc !== undefined)
+            warn(`${root}/ptc`);
+    }
+    return warnings;
+}

package/dist/config/schema.d.ts

@@ -28,10 +28,6 @@ export declare const ModelHarnessProfileSchema: import("@sinclair/typebox").TObj
         schemaVersion: import("@sinclair/typebox").TString;
         instruction: import("@sinclair/typebox").TString;
     }>>;
-    effort: import("@sinclair/typebox").TObject<{
-        allowed: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
-        default: import("@sinclair/typebox").TString;
-    }>;
     cache: import("@sinclair/typebox").TObject<{
         enabledByDefault: import("@sinclair/typebox").TBoolean;
         minimumEligiblePrefixTokens: import("@sinclair/typebox").TInteger;
@@ -57,8 +53,10 @@ export declare const ConfigSchema: import("@sinclair/typebox").TObject<{
         graceMs: import("@sinclair/typebox").TInteger;
     }>>;
     executor: import("@sinclair/typebox").TObject<{
+        sharedFilesystem: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
         address: import("@sinclair/typebox").TString;
         identityPath: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        credentialPath: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
         tls: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
             enabled: import("@sinclair/typebox").TBoolean;
             caFile: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
@@ -66,6 +64,25 @@ export declare const ConfigSchema: import("@sinclair/typebox").TObject<{
             keyFile: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
         }>>;
     }>;
+    localExecutor: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+        address: import("@sinclair/typebox").TString;
+        identityPath: import("@sinclair/typebox").TString;
+        credentialPath: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    }>>;
+    executors: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TObject<{
+        name: import("@sinclair/typebox").TString;
+        address: import("@sinclair/typebox").TString;
+        identityPath: import("@sinclair/typebox").TString;
+        credentialPath: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        sharedFilesystem: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+        defaultWorkspacePath: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        tls: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+            enabled: import("@sinclair/typebox").TBoolean;
+            caFile: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            certFile: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            keyFile: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        }>>;
+    }>>>;
     artifacts: import("@sinclair/typebox").TObject<{
         directory: import("@sinclair/typebox").TString;
     }>;
@@ -86,6 +103,8 @@ export declare const ConfigSchema: import("@sinclair/typebox").TObject<{
             maxFileBytes: import("@sinclair/typebox").TInteger;
             maxFiles: import("@sinclair/typebox").TInteger;
             retentionDays: import("@sinclair/typebox").TInteger;
+            maxQueuedRecords: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+            maxQueuedBytes: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
         }>>;
         traces: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
             capacity: import("@sinclair/typebox").TInteger;
@@ -107,8 +126,13 @@ export declare const ConfigSchema: import("@sinclair/typebox").TObject<{
         initializationOptions: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnknown>;
         maxFrameBytes: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
         maxBufferBytes: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+        requestTimeoutMs: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+        maxSessions: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+        idleTimeoutMs: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
     }>>>;
     providers: import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TObject<{
+        reasoningEfforts: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+        compactionThresholdTokens: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
         adapter: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"@ai-sdk/openai">, import("@sinclair/typebox").TLiteral<"@ai-sdk/anthropic">, import("@sinclair/typebox").TLiteral<"@ai-sdk/openai-compatible">]>;
         options: import("@sinclair/typebox").TObject<{
             apiKey: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TObject<{
@@ -118,12 +142,30 @@ export declare const ConfigSchema: import("@sinclair/typebox").TObject<{
             baseURL: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
             headers: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TString>>;
         }>;
+        promptCache: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+            mode: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"off">, import("@sinclair/typebox").TLiteral<"implicit">, import("@sinclair/typebox").TLiteral<"anthropic">, import("@sinclair/typebox").TLiteral<"openai-explicit">]>;
+            minimumEligiblePrefixTokens: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+            maximumBreakpoints: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+            positions: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"system">, import("@sinclair/typebox").TLiteral<"message">, import("@sinclair/typebox").TLiteral<"tool">]>>>;
+            ttl: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"5m">, import("@sinclair/typebox").TLiteral<"1h">, import("@sinclair/typebox").TLiteral<"30m">]>>;
+            retention: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"in_memory">, import("@sinclair/typebox").TLiteral<"24h">]>>;
+        }>>;
         models: import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TObject<{
+            reasoningEfforts: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
             contextWindowTokens: import("@sinclair/typebox").TInteger;
+            compactionThresholdTokens: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
             wireModel: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
             harnessProfile: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
             usageReliable: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
             cacheSupported: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+            promptCache: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+                mode: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"off">, import("@sinclair/typebox").TLiteral<"implicit">, import("@sinclair/typebox").TLiteral<"anthropic">, import("@sinclair/typebox").TLiteral<"openai-explicit">]>;
+                minimumEligiblePrefixTokens: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+                maximumBreakpoints: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+                positions: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"system">, import("@sinclair/typebox").TLiteral<"message">, import("@sinclair/typebox").TLiteral<"tool">]>>>;
+                ttl: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"5m">, import("@sinclair/typebox").TLiteral<"1h">, import("@sinclair/typebox").TLiteral<"30m">]>>;
+                retention: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"in_memory">, import("@sinclair/typebox").TLiteral<"24h">]>>;
+            }>>;
             programmaticToolCallingSupported: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
         }>>;
     }>>;
@@ -156,10 +198,6 @@ export declare const ConfigSchema: import("@sinclair/typebox").TObject<{
             schemaVersion: import("@sinclair/typebox").TString;
             instruction: import("@sinclair/typebox").TString;
         }>>;
-        effort: import("@sinclair/typebox").TObject<{
-            allowed: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
-            default: import("@sinclair/typebox").TString;
-        }>;
         cache: import("@sinclair/typebox").TObject<{
             enabledByDefault: import("@sinclair/typebox").TBoolean;
             minimumEligiblePrefixTokens: import("@sinclair/typebox").TInteger;
@@ -233,6 +271,14 @@ export declare const ConfigSchema: import("@sinclair/typebox").TObject<{
         outputReserveTokens: import("@sinclair/typebox").TInteger;
         safetyMarginTokens: import("@sinclair/typebox").TInteger;
     }>>;
+    localPtc: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+        timeoutMs: import("@sinclair/typebox").TInteger;
+        maxToolCalls: import("@sinclair/typebox").TInteger;
+        nativeCapabilities: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+    }>>;
+    slashCommands: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+        llmVisible: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TLiteral<"compact">>;
+    }>>;
     capabilityInput: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
         catalogMaxTokens: import("@sinclair/typebox").TInteger;
         searchResultMaxTokens: import("@sinclair/typebox").TInteger;
@@ -254,8 +300,8 @@ export declare const ConfigSchema: import("@sinclair/typebox").TObject<{
         stageVersion: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
     }>>;
     compaction: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
-        preservedSegmentTokens: import("@sinclair/typebox").TInteger;
-        preservedSegmentBytes: import("@sinclair/typebox").TInteger;
+        preservedSegmentTokens: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+        preservedSegmentBytes: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
         summaryMaxTokens: import("@sinclair/typebox").TInteger;
     }>>;
     autoReview: import("@sinclair/typebox").TObject<{

package/dist/config/schema.js

@@ -1,10 +1,19 @@
 import { Type } from '@sinclair/typebox';
 const NullableString = Type.Union([Type.String({ minLength: 1 }), Type.Null()]);
 const PositiveInteger = Type.Integer({ minimum: 1 });
+const ReasoningEfforts = Type.Array(Type.String({ minLength: 1 }), { minItems: 1, uniqueItems: true });
 const Secret = Type.Union([
     Type.String({ minLength: 1 }),
     Type.Object({ env: Type.String({ minLength: 1 }), optional: Type.Optional(Type.Boolean()) }, { additionalProperties: false })
 ]);
+const PromptCache = Type.Object({
+    mode: Type.Union([Type.Literal('off'), Type.Literal('implicit'), Type.Literal('anthropic'), Type.Literal('openai-explicit')]),
+    minimumEligiblePrefixTokens: Type.Optional(PositiveInteger),
+    maximumBreakpoints: Type.Optional(Type.Integer({ minimum: 0, maximum: 4 })),
+    positions: Type.Optional(Type.Array(Type.Union([Type.Literal('system'), Type.Literal('message'), Type.Literal('tool')]), { uniqueItems: true })),
+    ttl: Type.Optional(Type.Union([Type.Literal('5m'), Type.Literal('1h'), Type.Literal('30m')])),
+    retention: Type.Optional(Type.Union([Type.Literal('in_memory'), Type.Literal('24h')]))
+}, { additionalProperties: false });
 const Routing = Type.Object({
     retryMaxAttempts: Type.Integer({ minimum: 1, maximum: 10 }),
     fallback: Type.Array(Type.String({ minLength: 3 }))
@@ -41,16 +50,13 @@ export const ModelHarnessProfileSchema = Type.Object({
             preserveReasoningState: Type.Boolean()
         }, { additionalProperties: false })
     }, { additionalProperties: false }),
+    // Legacy hosted-PTC profile fields are accepted but no longer drive execution.
     ptc: Type.Optional(Type.Object({
         enabledByDefault: Type.Boolean(),
         maxToolCalls: PositiveInteger,
         schemaVersion: Type.String({ minLength: 1 }),
         instruction: Type.String({ minLength: 1 })
     }, { additionalProperties: false })),
-    effort: Type.Object({
-        allowed: Type.Array(Type.String({ minLength: 1, maxLength: 64, pattern: '^[A-Za-z0-9._:-]+$' }), { minItems: 1, uniqueItems: true }),
-        default: Type.String({ minLength: 1, maxLength: 64, pattern: '^[A-Za-z0-9._:-]+$' })
-    }, { additionalProperties: false }),
     cache: Type.Object({
         enabledByDefault: Type.Boolean(),
         minimumEligiblePrefixTokens: PositiveInteger,
@@ -69,8 +75,10 @@ export const ConfigSchema = Type.Object({
         graceMs: Type.Integer({ minimum: 0, maximum: 600000, default: 30000 })
     }, { additionalProperties: false })),
     executor: Type.Object({
+        sharedFilesystem: Type.Optional(Type.Boolean({ default: false })),
         address: Type.String({ minLength: 1 }),
         identityPath: Type.Optional(Type.String({ minLength: 1 })),
+        credentialPath: Type.Optional(Type.String({ minLength: 1 })),
         tls: Type.Optional(Type.Object({
             enabled: Type.Boolean(),
             caFile: Type.Optional(Type.String({ minLength: 1 })),
@@ -78,6 +86,23 @@ export const ConfigSchema = Type.Object({
             keyFile: Type.Optional(Type.String({ minLength: 1 }))
         }, { additionalProperties: false }))
     }, { additionalProperties: false }),
+    localExecutor: Type.Optional(Type.Object({
+        address: Type.String({ minLength: 1 }),
+        identityPath: Type.String({ minLength: 1 }),
+        credentialPath: Type.Optional(Type.String({ minLength: 1 }))
+    }, { additionalProperties: false })),
+    executors: Type.Optional(Type.Record(Type.String({ pattern: '^(?!local$|remote$)[a-zA-Z0-9][a-zA-Z0-9_-]{0,63}$' }), Type.Object({
+        name: Type.String({ minLength: 1, maxLength: 128 }),
+        address: Type.String({ minLength: 1 }),
+        identityPath: Type.String({ minLength: 1 }),
+        credentialPath: Type.Optional(Type.String({ minLength: 1 })),
+        sharedFilesystem: Type.Optional(Type.Boolean()),
+        defaultWorkspacePath: Type.Optional(Type.String({ minLength: 1 })),
+        tls: Type.Optional(Type.Object({
+            enabled: Type.Boolean(), caFile: Type.Optional(Type.String({ minLength: 1 })),
+            certFile: Type.Optional(Type.String({ minLength: 1 })), keyFile: Type.Optional(Type.String({ minLength: 1 }))
+        }, { additionalProperties: false }))
+    }, { additionalProperties: false }))),
     artifacts: Type.Object({ directory: Type.String({ minLength: 1 }) }, { additionalProperties: false }),
     persistence: Type.Optional(Type.Object({
         eventLog: Type.Optional(Type.Object({
@@ -91,7 +116,9 @@ export const ConfigSchema = Type.Object({
             path: Type.String({ minLength: 1 }),
             maxFileBytes: PositiveInteger,
             maxFiles: PositiveInteger,
-            retentionDays: PositiveInteger
+            retentionDays: PositiveInteger,
+            maxQueuedRecords: Type.Optional(PositiveInteger),
+            maxQueuedBytes: Type.Optional(PositiveInteger)
         }, { additionalProperties: false })),
         traces: Type.Optional(Type.Object({ capacity: PositiveInteger }, { additionalProperties: false }))
     }, { additionalProperties: false })),
@@ -107,9 +134,14 @@ export const ConfigSchema = Type.Object({
         project: Type.Optional(Type.String()),
         initializationOptions: Type.Optional(Type.Unknown()),
         maxFrameBytes: Type.Optional(PositiveInteger),
-        maxBufferBytes: Type.Optional(PositiveInteger)
+        maxBufferBytes: Type.Optional(PositiveInteger),
+        requestTimeoutMs: Type.Optional(PositiveInteger),
+        maxSessions: Type.Optional(PositiveInteger),
+        idleTimeoutMs: Type.Optional(PositiveInteger)
     }, { additionalProperties: false }))),
     providers: Type.Record(Type.String({ minLength: 1 }), Type.Object({
+        reasoningEfforts: Type.Optional(ReasoningEfforts),
+        compactionThresholdTokens: Type.Optional(PositiveInteger),
         adapter: Type.Union([
             Type.Literal('@ai-sdk/openai'),
             Type.Literal('@ai-sdk/anthropic'),
@@ -120,12 +152,17 @@ export const ConfigSchema = Type.Object({
             baseURL: Type.Optional(Type.String({ minLength: 1 })),
             headers: Type.Optional(Type.Record(Type.String(), Type.String()))
         }, { additionalProperties: false }),
+        promptCache: Type.Optional(PromptCache),
         models: Type.Record(Type.String({ minLength: 1 }), Type.Object({
+            reasoningEfforts: Type.Optional(ReasoningEfforts),
             contextWindowTokens: PositiveInteger,
+            compactionThresholdTokens: Type.Optional(PositiveInteger),
             wireModel: Type.Optional(Type.String({ minLength: 1 })),
             harnessProfile: Type.Optional(Type.String({ minLength: 1 })),
             usageReliable: Type.Optional(Type.Boolean()),
             cacheSupported: Type.Optional(Type.Boolean()),
+            promptCache: Type.Optional(PromptCache),
+            // Legacy Provider flag; local PTC works without it.
             programmaticToolCallingSupported: Type.Optional(Type.Boolean())
         }, { additionalProperties: false }))
     }, { additionalProperties: false })),
@@ -141,6 +178,8 @@ export const ConfigSchema = Type.Object({
     concurrency: Type.Object({ instanceMax: PositiveInteger, perStepMax: PositiveInteger, perAdapterMax: PositiveInteger }, { additionalProperties: false }),
     worker: Type.Object({ timeoutMs: PositiveInteger, outputLimitBytes: PositiveInteger }, { additionalProperties: false }),
     contextBudget: Type.Optional(Type.Object({ outputReserveTokens: PositiveInteger, safetyMarginTokens: PositiveInteger }, { additionalProperties: false })),
+    localPtc: Type.Optional(Type.Object({ timeoutMs: PositiveInteger, maxToolCalls: PositiveInteger, nativeCapabilities: Type.Optional(Type.Array(Type.String({ minLength: 1 }), { uniqueItems: true })) }, { additionalProperties: false })),
+    slashCommands: Type.Optional(Type.Object({ llmVisible: Type.Array(Type.Literal('compact'), { uniqueItems: true }) }, { additionalProperties: false })),
     capabilityInput: Type.Optional(Type.Object({ catalogMaxTokens: PositiveInteger, searchResultMaxTokens: PositiveInteger }, { additionalProperties: false })),
     contextProjection: Type.Optional(Type.Object({
         toolResultMaxTokens: Type.Optional(PositiveInteger),
@@ -150,8 +189,9 @@ export const ConfigSchema = Type.Object({
         stageVersion: Type.Optional(Type.String({ minLength: 1 }))
     }, { additionalProperties: false })),
     compaction: Type.Optional(Type.Object({
-        preservedSegmentTokens: PositiveInteger,
-        preservedSegmentBytes: PositiveInteger,
+        // Accepted for existing configuration files; the retained tail is now fixed at 5000 tokens.
+        preservedSegmentTokens: Type.Optional(PositiveInteger),
+        preservedSegmentBytes: Type.Optional(PositiveInteger),
         summaryMaxTokens: PositiveInteger
     }, { additionalProperties: false })),
     autoReview: Type.Object({ timeoutMs: PositiveInteger, goalMaxBytes: PositiveInteger }, { additionalProperties: false }),