sneakoscope 7.1.0 → 7.3.0

package/dist/core/subagents/role-model-preferences.js

@@ -3,12 +3,17 @@ import os from 'node:os';
 import path from 'node:path';
 import { writeTextAtomic } from '../fsx.js';
 import { MANAGED_OFFICIAL_SUBAGENT_ROLES, managedOfficialSubagentRoleByName } from '../managed-assets/managed-assets-manifest.js';
-export const ROLE_MODEL_PREFERENCES_SCHEMA = 'sks.role-model-preferences.v1';
+import { inferProviderFromModel, normalizeCodexModelId, normalizeCodexReasoningEffort, readConfiguredCodexModelRoutingContext } from '../codex-app/codex-model-catalog.js';
+import { childInheritsActiveMainModel } from '../provider/model-router.js';
+import { isRecord } from '../json/records.js';
+export const ROLE_MODEL_PREFERENCES_SCHEMA = 'sks.role-model-preferences.v2';
+const LEGACY_ROLE_MODEL_PREFERENCES_SCHEMA = 'sks.role-model-preferences.v1';
+const ROLE_MODEL_PROFILE_PRESENTATION_LIMIT = 1_000;
 export const SUPPORTED_ROLE_MODEL_PROFILES = Object.freeze([
-    Object.freeze({ model: 'gpt-5.6-luna', reasoning_effort: 'max' }),
-    Object.freeze({ model: 'gpt-5.6-terra', reasoning_effort: 'medium' }),
-    Object.freeze({ model: 'gpt-5.6-sol', reasoning_effort: 'high' }),
-    Object.freeze({ model: 'gpt-5.6-sol', reasoning_effort: 'max' })
+    Object.freeze({ provider: 'openai', model: 'gpt-5.6-luna', reasoning_effort: 'max', source: 'managed-default' }),
+    Object.freeze({ provider: 'openai', model: 'gpt-5.6-terra', reasoning_effort: 'medium', source: 'managed-default' }),
+    Object.freeze({ provider: 'openai', model: 'gpt-5.6-sol', reasoning_effort: 'high', source: 'managed-default' }),
+    Object.freeze({ provider: 'openai', model: 'gpt-5.6-sol', reasoning_effort: 'max', source: 'managed-default' })
 ]);
 export function roleModelPreferencesPath(env = process.env) {
     const sksHome = path.resolve(env.SKS_HOME || path.join(env.HOME || os.homedir(), '.sneakoscope'));
@@ -18,7 +23,9 @@ export async function readRoleModelPreferences(input = {}) {
     const filePath = input.filePath || roleModelPreferencesPath(input.env || process.env);
     try {
         const parsed = JSON.parse(await fs.readFile(filePath, 'utf8'));
-        if (parsed.schema !== ROLE_MODEL_PREFERENCES_SCHEMA || parsed.version !== 1 || !isRecord(parsed.roles)) {
+        const legacy = parsed.schema === LEGACY_ROLE_MODEL_PREFERENCES_SCHEMA && parsed.version === 1;
+        const current = parsed.schema === ROLE_MODEL_PREFERENCES_SCHEMA && parsed.version === 2;
+        if ((!legacy && !current) || !isRecord(parsed.roles)) {
             return { store: emptyStore(), path: filePath, blockers: ['role_model_preferences_invalid_schema'] };
         }
         const roles = {};
@@ -29,23 +36,25 @@ export async function readRoleModelPreferences(input = {}) {
                 blockers.push(`role_model_preference_invalid_role:${rawRole}`);
                 continue;
             }
-            const model = String(rawPreference.model || '');
-            const reasoning = String(rawPreference.reasoning_effort || '');
-            const profile = supportedRoleModelProfile(model, reasoning);
-            if (!profile) {
+            const model = normalizeCodexModelId(rawPreference.model);
+            const reasoning = normalizeCodexReasoningEffort(rawPreference.reasoning_effort);
+            const provider = normalizeRoleProvider(rawPreference.provider)
+                || (model ? inferProviderFromModel(model) : null);
+            if (!model || !reasoning || !provider) {
                 blockers.push(`role_model_preference_invalid_profile:${role.codex_name}`);
                 continue;
             }
             roles[role.codex_name] = {
-                model: profile.model,
-                reasoning_effort: profile.reasoning_effort,
+                provider,
+                model,
+                reasoning_effort: reasoning,
                 updated_at: String(rawPreference.updated_at || parsed.updated_at || '')
             };
         }
         return {
             store: {
                 schema: ROLE_MODEL_PREFERENCES_SCHEMA,
-                version: 1,
+                version: 2,
                 updated_at: String(parsed.updated_at || ''),
                 roles
             },
@@ -60,37 +69,167 @@ export async function readRoleModelPreferences(input = {}) {
     }
 }
 export async function roleModelPreferencesStatus(input = {}) {
+    const env = input.env || process.env;
     const read = await readRoleModelPreferences(input);
+    const routing = await readConfiguredCodexModelRoutingContext({
+        env,
+        ...(input.home ? { home: input.home } : {}),
+        ...(input.configPath ? { configPath: input.configPath } : {})
+    });
+    const catalog = routing.catalog;
+    const routerSelected = routing.selected_provider === 'sks-router';
+    const activeMainModel = routing.selected_provider && routing.selected_model
+        ? {
+            provider: routing.selected_provider,
+            model: routing.selected_model
+        }
+        : null;
+    const preferenceBlockers = Object.entries(read.store.roles).flatMap(([role, preference]) => {
+        const routed = preference.provider !== 'openai' || preference.model.includes('/');
+        if (!routed) {
+            return isSupportedRoleModelProfile(preference.model, preference.reasoning_effort)
+                ? []
+                : [`role_model_preference_not_managed:${role}`];
+        }
+        if (!routerSelected)
+            return [`role_model_router_not_selected:${role}`];
+        const entry = catalog.models.find((model) => model.model === preference.model);
+        if (!catalog.ok || !entry)
+            return [`role_model_preference_not_in_active_catalog:${role}`];
+        if (!entry.reasoning_efforts.includes(preference.reasoning_effort)) {
+            return [`role_model_preference_reasoning_not_in_active_catalog:${role}`];
+        }
+        return entry.multi_agent_version === 'v2'
+            ? []
+            : [`role_model_preference_multi_agent_v2_required:${role}`];
+    });
+    const catalogProfiles = (routerSelected ? catalog.models : [])
+        .filter((entry) => entry.multi_agent_version === 'v2')
+        .flatMap((entry) => (entry.reasoning_efforts.map((reasoning) => ({
+        provider: entry.provider,
+        model: entry.model,
+        reasoning_effort: reasoning,
+        source: 'codex-model-catalog'
+    }))));
+    const allProfiles = dedupeProfiles([
+        ...SUPPORTED_ROLE_MODEL_PROFILES,
+        ...catalogProfiles
+    ]);
+    const supportedProfiles = allProfiles.slice(0, ROLE_MODEL_PROFILE_PRESENTATION_LIMIT);
     const roles = MANAGED_OFFICIAL_SUBAGENT_ROLES.map((role) => {
         const override = read.store.roles[role.codex_name] || null;
+        const inheritActiveMain = childInheritsActiveMainModel(activeMainModel?.model);
+        const effectiveProvider = override?.provider
+            || (inheritActiveMain ? activeMainModel?.provider : null)
+            || inferProviderFromModel(role.model);
+        const effectiveModel = override?.model
+            || (inheritActiveMain ? activeMainModel?.model : null)
+            || role.model;
+        const effectiveReasoning = override?.reasoning_effort || role.model_reasoning_effort;
         return {
             role: role.codex_name,
             description: role.description,
+            default_provider: inferProviderFromModel(role.model),
             default_model: role.model,
             default_reasoning_effort: role.model_reasoning_effort,
             override,
-            effective_model: override?.model || role.model,
-            effective_reasoning_effort: override?.reasoning_effort || role.model_reasoning_effort
+            effective_provider: effectiveProvider,
+            effective_model: effectiveModel,
+            effective_reasoning_effort: effectiveReasoning,
+            effective_source: override
+                ? 'role-override'
+                : inheritActiveMain
+                    ? 'selected-main-model'
+                    : 'managed-default'
         };
     });
     return {
-        schema: 'sks.role-model-preferences-status.v1',
-        ok: read.blockers.length === 0,
+        schema: 'sks.role-model-preferences-status.v2',
+        ok: read.blockers.length === 0 && preferenceBlockers.length === 0,
         path: read.path,
         owner_only: true,
-        supported_profiles: SUPPORTED_ROLE_MODEL_PROFILES,
+        supported_profiles: supportedProfiles,
+        supported_profile_count: allProfiles.length,
+        supported_profiles_truncated: allProfiles.length > supportedProfiles.length,
+        routing: {
+            selected_provider: routing.selected_provider,
+            selected_model: routing.selected_model,
+            active_main_model_inherited: childInheritsActiveMainModel(activeMainModel?.model),
+            router_selected: routerSelected,
+            runtime_verified: false
+        },
+        catalog: {
+            configured: catalog.configured,
+            ok: catalog.ok,
+            path: catalog.path,
+            model_count: catalog.model_count,
+            total_model_count: catalog.total_model_count,
+            truncated: catalog.truncated,
+            blockers: catalog.blockers
+        },
         roles,
-        blockers: read.blockers,
-        warnings: []
+        store_readable: read.blockers.length === 0,
+        store_blockers: [...read.blockers],
+        preference_blockers: [...preferenceBlockers],
+        blockers: [...read.blockers, ...preferenceBlockers],
+        warnings: [
+            ...catalog.warnings,
+            ...(catalog.configured && !catalog.ok
+                ? catalog.blockers.map((blocker) => `role_model_catalog:${blocker}`)
+                : []),
+            ...(catalog.configured && catalog.ok && !routerSelected
+                ? ['role_model_router_not_selected']
+                : []),
+            ...(allProfiles.length > supportedProfiles.length
+                ? [`role_model_supported_profiles_truncated:${allProfiles.length}:${supportedProfiles.length}`]
+                : [])
+        ]
     };
 }
 export async function setRoleModelPreference(input) {
     const role = managedOfficialSubagentRoleByName(String(input.role || '').trim());
     if (!role)
         return mutationBlocked('role_model_role_invalid');
-    const profile = supportedRoleModelProfile(input.model, input.reasoning);
-    if (!profile) {
-        return mutationBlocked('role_model_profile_unsupported');
+    const model = normalizeCodexModelId(input.model);
+    const reasoning = normalizeCodexReasoningEffort(input.reasoning);
+    if (!model || !reasoning)
+        return mutationBlocked('role_model_profile_invalid');
+    const env = input.env || process.env;
+    const routing = await readConfiguredCodexModelRoutingContext({
+        env,
+        ...(input.home ? { home: input.home } : {}),
+        ...(input.configPath ? { configPath: input.configPath } : {})
+    });
+    const catalog = routing.catalog;
+    const catalogEntry = catalog.models.find((entry) => entry.model === model) || null;
+    const requestedProvider = normalizeRoleProvider(input.provider);
+    if (input.provider && !requestedProvider)
+        return mutationBlocked('role_model_provider_invalid');
+    if (requestedProvider && catalogEntry && requestedProvider !== catalogEntry.provider) {
+        return mutationBlocked('role_model_provider_mismatch');
+    }
+    const provider = requestedProvider || catalogEntry?.provider || inferProviderFromModel(model);
+    const routedModel = provider !== 'openai' || model.includes('/');
+    const managedProfile = SUPPORTED_ROLE_MODEL_PROFILES.some((profile) => (profile.provider === provider
+        && profile.model === model
+        && profile.reasoning_effort === reasoning));
+    if (!routedModel && !managedProfile) {
+        return mutationBlocked('role_model_profile_not_managed');
+    }
+    if (routedModel && routing.selected_provider !== 'sks-router') {
+        return mutationBlocked('role_model_router_not_selected');
+    }
+    if (routedModel && !catalog.ok) {
+        return mutationBlocked('role_model_catalog_required_for_routed_model', ...catalog.blockers);
+    }
+    if (routedModel && !catalogEntry) {
+        return mutationBlocked('role_model_not_in_active_catalog');
+    }
+    if (catalogEntry && !catalogEntry.reasoning_efforts.includes(reasoning)) {
+        return mutationBlocked('role_model_reasoning_not_in_catalog');
+    }
+    if (routedModel && catalogEntry?.multi_agent_version !== 'v2') {
+        return mutationBlocked('role_model_multi_agent_v2_required');
     }
     const read = await readRoleModelPreferences(input);
     if (read.blockers.length)
@@ -98,28 +237,35 @@ export async function setRoleModelPreference(input) {
     const timestamp = (input.now || (() => new Date().toISOString()))();
     const store = {
         schema: ROLE_MODEL_PREFERENCES_SCHEMA,
-        version: 1,
+        version: 2,
         updated_at: timestamp,
         roles: {
             ...read.store.roles,
             [role.codex_name]: {
-                model: profile.model,
-                reasoning_effort: profile.reasoning_effort,
+                provider,
+                model,
+                reasoning_effort: reasoning,
                 updated_at: timestamp
             }
         }
     };
     await writeOwnerOnlyStore(read.path, store);
     return {
-        schema: 'sks.role-model-preference-mutation.v1',
+        schema: 'sks.role-model-preference-mutation.v2',
         ok: true,
         status: 'set',
         role: role.codex_name,
-        model: profile.model,
-        reasoning_effort: profile.reasoning_effort,
+        provider,
+        model,
+        reasoning_effort: reasoning,
+        catalog_verified: Boolean(catalogEntry),
+        catalog_path: catalog.path,
+        selected_model_provider: routing.selected_provider,
+        multi_agent_version: catalogEntry?.multi_agent_version || null,
+        runtime_verified: false,
         path: read.path,
         blockers: [],
-        warnings: []
+        warnings: catalog.warnings
     };
 }
 export async function resetRoleModelPreference(input) {
@@ -133,13 +279,13 @@ export async function resetRoleModelPreference(input) {
     delete roles[role.codex_name];
     const store = {
         schema: ROLE_MODEL_PREFERENCES_SCHEMA,
-        version: 1,
+        version: 2,
         updated_at: (input.now || (() => new Date().toISOString()))(),
         roles
     };
     await writeOwnerOnlyStore(read.path, store);
     return {
-        schema: 'sks.role-model-preference-mutation.v1',
+        schema: 'sks.role-model-preference-mutation.v2',
         ok: true,
         status: 'reset',
         role: role.codex_name,
@@ -149,13 +295,10 @@ export async function resetRoleModelPreference(input) {
     };
 }
 export function isSupportedRoleModelProfile(model, reasoning) {
-    return supportedRoleModelProfile(model, reasoning) !== null;
-}
-function supportedRoleModelProfile(model, reasoning) {
-    const normalizedModel = String(model || '').trim();
-    const normalizedReasoning = String(reasoning || '').trim();
-    const profile = SUPPORTED_ROLE_MODEL_PROFILES.find((profile) => (profile.model === normalizedModel && profile.reasoning_effort === normalizedReasoning));
-    return profile ? { model: profile.model, reasoning_effort: profile.reasoning_effort } : null;
+    const normalizedModel = normalizeCodexModelId(model);
+    const normalizedReasoning = normalizeCodexReasoningEffort(reasoning);
+    return SUPPORTED_ROLE_MODEL_PROFILES.some((profile) => (profile.model === normalizedModel
+        && profile.reasoning_effort === normalizedReasoning));
 }
 async function writeOwnerOnlyStore(filePath, store) {
     const dir = path.dirname(filePath);
@@ -163,17 +306,32 @@ async function writeOwnerOnlyStore(filePath, store) {
     await writeTextAtomic(filePath, `${JSON.stringify(store, null, 2)}\n`, { mode: 0o600 });
 }
 function emptyStore() {
-    return { schema: ROLE_MODEL_PREFERENCES_SCHEMA, version: 1, updated_at: '', roles: {} };
+    return { schema: ROLE_MODEL_PREFERENCES_SCHEMA, version: 2, updated_at: '', roles: {} };
 }
 function mutationBlocked(...blockers) {
     return {
-        schema: 'sks.role-model-preference-mutation.v1',
+        schema: 'sks.role-model-preference-mutation.v2',
         ok: false,
         status: 'blocked',
-        blockers,
+        blockers: [...new Set(blockers.filter(Boolean))],
         warnings: []
     };
 }
-function isRecord(value) {
-    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+function normalizeRoleProvider(value) {
+    const provider = String(value || '').trim().toLowerCase();
+    if (!provider || provider.length > 80)
+        return null;
+    return /^[a-z0-9][a-z0-9._-]*$/.test(provider) ? provider : null;
+}
+function dedupeProfiles(profiles) {
+    const seen = new Set();
+    const out = [];
+    for (const profile of profiles) {
+        const key = `${profile.model}\u0000${profile.reasoning_effort}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(profile);
+    }
+    return out;
 }

package/dist/core/subagents/subagent-evidence.js

@@ -3,6 +3,7 @@ import path from 'node:path';
 import { appendJsonlBounded, nowIso, sha256, writeJsonAtomic } from '../fsx.js';
 import { HOST_CAPABILITY_DESCRIPTORS, hostCapabilityDigest } from '../agent-bridge/agent-manifest.js';
 import { HOST_CAPABILITY_EVIDENCE_SCHEMA, HOST_CAPABILITY_RUNTIME_SCHEMA } from '../agent-bridge/host-capability-runtime.js';
+import { isRecord } from '../json/records.js';
 export const SUBAGENT_EVIDENCE_SCHEMA = 'sks.subagent-evidence.v1';
 export const SUBAGENT_EVENT_SCHEMA = 'sks.subagent-event.v1';
 export const SUBAGENT_PARENT_SUMMARY_SCHEMA = 'sks.subagent-parent-summary.v1';
@@ -1050,9 +1051,6 @@ function hasMeaningfulSummary(value) {
 function eventSourceOrder(a, b) {
     return (a === 'SubagentStart' ? 0 : 1) - (b === 'SubagentStart' ? 0 : 1);
 }
-function isRecord(value) {
-    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
-}
 function recordId(value) {
     return isRecord(value) ? value.id : undefined;
 }

package/dist/core/subagents/thread-budget.js

@@ -1,6 +1,6 @@
 export const DEFAULT_NARUTO_MAX_THREADS = 12;
 export const HARD_NARUTO_MAX_THREADS = 32;
-export const DEFAULT_NARUTO_REQUESTED_SUBAGENTS = 2;
+export const DEFAULT_NARUTO_REQUESTED_SUBAGENTS = 4;
 export const DEFAULT_NARUTO_PARENT_THREAD_RESERVATION = 1;
 export const DEFAULT_NARUTO_REVIEWER_THREAD_RESERVATION = 0;
 export function resolveSubagentThreadBudget(input = {}) {

package/dist/core/subagents/triwiki-attention.js

@@ -1,5 +1,6 @@
 import path from 'node:path';
 import { readJson } from '../fsx.js';
+import { asRecordOrEmpty as asRecord } from '../json/records.js';
 export const BOUNDED_TRIWIKI_ATTENTION_SCHEMA = 'sks.subagent-triwiki-attention.v1';
 export const DEFAULT_TRIWIKI_ATTENTION_ANCHOR_LIMIT = 8;
 export async function readBoundedTriwikiAttention(root, limit = DEFAULT_TRIWIKI_ATTENTION_ANCHOR_LIMIT, query = '') {
@@ -153,11 +154,6 @@ function normalizeLimit(value) {
         return DEFAULT_TRIWIKI_ATTENTION_ANCHOR_LIMIT;
     return Math.max(1, Math.min(16, Math.floor(parsed)));
 }
-function asRecord(value) {
-    return value && typeof value === 'object' && !Array.isArray(value)
-        ? value
-        : {};
-}
 function text(value) {
     return typeof value === 'string' ? value.trim() : '';
 }

package/dist/core/telegram/config.js

@@ -1,9 +1,7 @@
 import fsp from 'node:fs/promises';
 import path from 'node:path';
 import { runProcess, sha256 } from '../fsx.js';
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
+import { isRecord } from '../json/records.js';
 export function validateTelegramConfig(value) {
     const issues = [];
     if (!isRecord(value))
@@ -24,10 +22,7 @@ export function validateTelegramConfig(value) {
         if (!nonEmpty(secret.path) || !path.isAbsolute(String(secret.path)))
             issues.push('external_secret_path_must_be_absolute');
     }
-    if (!stringIdArray(value.paired_chat_ids))
-        issues.push('paired_chat_ids');
-    if (!stringIdArray(value.paired_user_ids))
-        issues.push('paired_user_ids');
+    issues.push(...validateTelegramPrivatePairing(value).issues);
     if (typeof value.long_poll_timeout_sec === 'number' && (value.long_poll_timeout_sec < 1 || value.long_poll_timeout_sec > 50))
         issues.push('long_poll_timeout_sec');
     if (typeof value.owner_stale_ms === 'number' && value.owner_stale_ms < 5_000)
@@ -59,7 +54,7 @@ export async function resolveTelegramBotToken(ref, options = {}) {
         ], { timeoutMs: 5_000, maxOutputBytes: 8 * 1024 });
         if (result.code !== 0 || result.timedOut)
             throw new Error('telegram_keychain_lookup_failed');
-        return validateTokenValue(result.stdout.trim());
+        return validateTelegramBotToken(result.stdout.trim());
     }
     if (!ref.path || !path.isAbsolute(ref.path))
         throw new Error('telegram_external_secret_path_invalid');
@@ -70,19 +65,41 @@ export async function resolveTelegramBotToken(ref, options = {}) {
         throw new Error('telegram_external_secret_not_file');
     if ((stat.mode & 0o077) !== 0)
         throw new Error('telegram_external_secret_permissions_must_be_0600');
-    return validateTokenValue((await fsp.readFile(ref.path, 'utf8')).trim());
+    return validateTelegramBotToken((await fsp.readFile(ref.path, 'utf8')).trim());
 }
 export function telegramTokenFingerprint(token) {
     return `sha256:${sha256(token)}`;
 }
-function validateTokenValue(token) {
+export function validateTelegramBotToken(token) {
     if (!/^\d{5,}:[A-Za-z0-9_-]{20,}$/.test(token))
         throw new Error('telegram_bot_token_format_invalid');
     return token;
 }
+export function isPositiveTelegramId(value) {
+    return typeof value === 'string' && /^[1-9]\d*$/.test(value);
+}
+export function validateTelegramPrivatePairing(value) {
+    if (!isRecord(value)) {
+        return {
+            ok: false,
+            missing: true,
+            issues: ['paired_chat_ids', 'paired_user_ids']
+        };
+    }
+    const issues = [];
+    if (!positiveStringIdArray(value.paired_chat_ids))
+        issues.push('paired_chat_ids');
+    if (!positiveStringIdArray(value.paired_user_ids))
+        issues.push('paired_user_ids');
+    const missing = pairingFieldMissing(value, 'paired_chat_ids') || pairingFieldMissing(value, 'paired_user_ids');
+    return { ok: issues.length === 0, missing, issues };
+}
 function nonEmpty(value) {
     return typeof value === 'string' && value.trim().length > 0;
 }
-function stringIdArray(value) {
-    return Array.isArray(value) && value.length > 0 && value.every((entry) => /^-?\d+$/.test(String(entry)));
+function positiveStringIdArray(value) {
+    return Array.isArray(value) && value.length > 0 && value.every(isPositiveTelegramId);
+}
+function pairingFieldMissing(value, field) {
+    return !(field in value) || (Array.isArray(value[field]) && value[field].length === 0);
 }

package/dist/core/telegram/hub.js

@@ -70,11 +70,13 @@ export class TelegramHubRouter {
         const text = staticUiAction?.command ?? message?.text?.trim() ?? '';
         const command = text.startsWith('/') ? text.split(/\s+/, 1)[0]?.toLowerCase() ?? '' : '';
         const policy = staticUiAction ?? COMMAND_POLICY[command];
-        if (actor.topicId === null) {
+        const route = actor.topicId === null
+            ? await this.onlyRouteForPrivateChat(actor.chatId)
+            : await this.options.topics.findByTopic(actor.chatId, actor.topicId);
+        if (actor.topicId === null && !route) {
             await this.audit(update, actor.chatId, null, null, command || 'free_text', 'rejected', 'session_picker_required');
             return { ...result(false, 'session_picker_required'), session_picker: true };
         }
-        const route = await this.options.topics.findByTopic(actor.chatId, actor.topicId);
         if (!route)
             return this.reject(update, actor, command || 'free_text', 'wrong_topic');
         if (policy) {
@@ -108,6 +110,10 @@ export class TelegramHubRouter {
             && this.options.config.paired_chat_ids.includes(chatId)
             && this.options.config.paired_user_ids.includes(userId);
     }
+    async onlyRouteForPrivateChat(chatId) {
+        const routes = (await this.options.topics.list()).filter((route) => route.chat_id === chatId);
+        return routes.length === 1 && routes[0]?.message_thread_id === 0 ? routes[0] : null;
+    }
     async reject(update, actor, command, reason) {
         await this.audit(update, actor.chatId, actor.topicId, null, command, 'rejected', reason);
         return result(false, reason);

package/dist/core/telegram/index.js

@@ -6,3 +6,5 @@ export * from './bot-api.js';
 export * from './messages.js';
 export * from './hub.js';
 export * from './runtime.js';
+export * from './setup.js';
+export * from './service.js';

package/dist/core/telegram/messages.js

@@ -85,7 +85,7 @@ export class TelegramMessageProjector {
         });
     }
     async sendFinal(input) {
-        const text = publicSafeText(input.text);
+        const text = telegramMessageText(input.text);
         let method = this.capabilities.rich_message ? 'sendRichMessage' : 'sendMessage';
         let result;
         try {
@@ -110,7 +110,7 @@ export class TelegramMessageProjector {
     async sendFlat(input) {
         const result = await this.api.call('sendMessage', {
             chat_id: input.chatId,
-            text: publicSafeText(input.text),
+            text: telegramMessageText(input.text),
             protect_content: this.options.protectContent !== false,
             disable_notification: this.options.silent === true,
             ...(input.replyMarkup ? { reply_markup: input.replyMarkup } : {})
@@ -287,6 +287,12 @@ export function publicSafeText(value) {
         .replace(/\u0000/g, '')
         .slice(0, 16_000);
 }
+function telegramMessageText(value) {
+    const text = publicSafeText(value);
+    if (text.length <= 4_000)
+        return text;
+    return `${text.slice(0, 3_920).trimEnd()}\n\n[Response truncated for Telegram. Ask Codex to continue with the remaining details.]`;
+}
 async function sleep(ms) {
     await new Promise((resolve) => setTimeout(resolve, ms));
 }

package/dist/core/telegram/runtime-projection.js

@@ -1,6 +1,8 @@
 import crypto from 'node:crypto';
 import { buildTelegramTopicName } from './ledgers.js';
 import { publicSafeText } from './messages.js';
+import { asRecordOrNull as asRecord } from '../json/records.js';
+export { asRecord };
 export function pickerAction(route, now) {
     return {
         schema: 'sks.remote-action.v1',
@@ -49,8 +51,12 @@ export function snapshotSummary(snapshot) {
     ].join('\n'));
 }
 export function successSummary(action, data) {
-    if (action.kind === 'input')
-        return 'Follow-up input was accepted by the exact active Codex turn.';
+    if (action.kind === 'input') {
+        const response = typeof data?.final_response === 'string' ? data.final_response.trim() : '';
+        return response
+            ? publicSafeText(response)
+            : 'Codex completed the Telegram turn, but no public final response was available.';
+    }
     if (action.kind === 'cancel')
         return 'Cancellation completed with owner-proof and one-time approval receipts.';
     if (action.kind === 'verify')
@@ -83,6 +89,3 @@ export function boundedIdentifier(value) {
     const text = typeof value === 'string' ? value : '';
     return /^[A-Za-z0-9][A-Za-z0-9._:-]{0,159}$/.test(text) ? text : null;
 }
-export function asRecord(value) {
-    return value !== null && typeof value === 'object' && !Array.isArray(value) ? value : null;
-}

package/dist/core/telegram/runtime.js

@@ -1,4 +1,4 @@
-import { REMOTE_COMMAND_SCHEMA, REMOTE_R2_APPROVAL_SCHEMA, REMOTE_WORKER_REQUEST_SCHEMA, RemoteSshClientError, RemoteSshWorkerClient, findRemoteMachine, findRemoteSessionTarget } from '../remote/index.js';
+import { REMOTE_COMMAND_SCHEMA, REMOTE_R2_APPROVAL_SCHEMA, REMOTE_WORKER_REQUEST_SCHEMA, RemoteLocalWorkerClient, RemoteSshClientError, RemoteSshWorkerClient, findRemoteMachine, findRemoteSessionTarget } from '../remote/index.js';
 import { nowIso, readJson, sha256, writeJsonAtomic } from '../fsx.js';
 import { TelegramActionBroker, TelegramAuditLedger, TelegramTopicRegistry } from './ledgers.js';
 import { TelegramBotApiError } from './bot-api.js';
@@ -86,9 +86,12 @@ export class TelegramHubRuntime {
                     warnings.push(`target_unavailable:${target.machine_id}:${target.project_id}`);
                     continue;
                 }
-                const rows = Array.isArray(asRecord(listed.data)?.sessions) ? asRecord(listed.data)?.sessions : [];
-                for (const raw of rows) {
-                    const session = asRecord(raw);
+                const rawRows = Array.isArray(asRecord(listed.data)?.sessions)
+                    ? asRecord(listed.data)?.sessions
+                    : [];
+                const rows = rawRows.map(asRecord).filter((row) => Boolean(row));
+                const dedicatedRows = rows.filter((row) => row.dedicated_telegram_thread === true);
+                for (const session of dedicatedRows.length ? dedicatedRows : rows) {
                     const sessionId = boundedIdentifier(session?.session_id);
                     if (!sessionId)
                         continue;
@@ -346,11 +349,18 @@ export class TelegramHubRuntime {
         const existing = this.clients.get(key);
         if (existing)
             return existing;
-        const created = this.options.clientFactory?.(target) ?? new RemoteSshWorkerClient({
-            machine: findRemoteMachine(this.options.machineRegistry, target.machine_id),
-            projectRoot: target.project_root,
-            projectId: target.project_id
-        });
+        const machine = findRemoteMachine(this.options.machineRegistry, target.machine_id);
+        const created = this.options.clientFactory?.(target) ?? (machine.transport === 'local'
+            ? new RemoteLocalWorkerClient({
+                machine,
+                projectRoot: target.project_root,
+                projectId: target.project_id
+            })
+            : new RemoteSshWorkerClient({
+                machine,
+                projectRoot: target.project_root,
+                projectId: target.project_id
+            }));
         this.clients.set(key, created);
         return created;
     }