sneakoscope 8.0.2 → 8.0.4

package/dist/core/subagents/wave-lifecycle.js

@@ -4,6 +4,7 @@ import { readSubagentEvents } from './subagent-evidence.js';
 import { MAX_AUTOMATIC_SUBAGENT_COUNT, MAX_MASS_AUTOMATIC_SUBAGENT_COUNT } from './agent-catalog.js';
 import { buildWaveParentGuidance } from './wave-parent-guidance.js';
 export const SUBAGENT_WAVE_LIFECYCLE_SCHEMA = 'sks.subagent-wave-lifecycle.v1';
+const LEGACY_SKS_AUTOMATIC_SUBAGENT_CEILINGS = new Set([12, 64]);
 export function subagentCountPolicy(plan) {
     const lifecycle = plan?.wave_lifecycle;
     if (lifecycle?.count_policy === 'dynamic_automatic')
@@ -61,11 +62,17 @@ export function subagentCountContractBlockers(plan, observedStarts = 0) {
 }
 export function automaticSubagentTargetCap(plan) {
     const fanout = plan?.fanout_policy;
-    const configuredCeiling = positiveCount(fanout?.automatic_ceiling) || MAX_AUTOMATIC_SUBAGENT_COUNT;
     const hardAutomaticCeiling = fanout?.mass_parallel === true
         ? MAX_MASS_AUTOMATIC_SUBAGENT_COUNT
         : MAX_AUTOMATIC_SUBAGENT_COUNT;
-    return Math.min(configuredCeiling, hardAutomaticCeiling);
+    const configuredCeiling = positiveCount(fanout?.automatic_ceiling);
+    const legacySksOwnedCeiling = fanout?.mode === 'parent_owned_risk_based'
+        && fanout?.count_source === 'automatic'
+        && LEGACY_SKS_AUTOMATIC_SUBAGENT_CEILINGS.has(configuredCeiling);
+    const effectiveConfiguredCeiling = legacySksOwnedCeiling
+        ? hardAutomaticCeiling
+        : configuredCeiling || hardAutomaticCeiling;
+    return Math.min(effectiveConfiguredCeiling, hardAutomaticCeiling);
 }
 export function effectiveSubagentTarget(plan, observedStarts = 0) {
     const countPolicy = subagentCountPolicy(plan);
@@ -211,10 +218,15 @@ function projectLifecycle(previous, input) {
             ? latestEventTime(input.events, 'SubagentStop', wave.settled_thread_ids) || wave.settled_at || nowIso()
             : null;
     }
-    const failed = new Set(input.events
-        .filter((event) => event.event_name === 'SubagentStop' && event.outcome === 'failed')
-        .map((event) => event.thread_id || '')
-        .filter(Boolean));
+    const latestStopOutcomes = new Map();
+    for (const event of input.events) {
+        if (event.event_name === 'SubagentStop' && event.thread_id) {
+            latestStopOutcomes.set(event.thread_id, event.outcome);
+        }
+    }
+    const failed = new Set([...latestStopOutcomes]
+        .filter(([, outcome]) => outcome === 'failed')
+        .map(([threadId]) => threadId));
     const cumulativeSettled = [...stops].filter((threadId) => starts.includes(threadId)).length;
     const completed = Math.max(0, cumulativeSettled - failed.size);
     const openThreads = Math.max(0, starts.length - cumulativeSettled);

package/dist/core/telegram/access.js

@@ -0,0 +1,58 @@
+import { randomInt, randomUUID } from 'node:crypto';
+import { SYSTEM_TELEGRAM_CLOCK } from './types.js';
+export class InMemoryTelegramAccessStore {
+    clock;
+    pairings = new Map();
+    chats = new Map();
+    transactionTail = Promise.resolve();
+    constructor(clock = SYSTEM_TELEGRAM_CLOCK) {
+        this.clock = clock;
+    }
+    async issuePairingCode(ttlMs = 5 * 60_000) {
+        return this.transaction(async () => {
+            this.expireCodes();
+            const code = `${randomInt(100_000, 1_000_000)}-${randomUUID().slice(0, 4).toUpperCase()}`;
+            const expiresAt = this.clock.now() + Math.max(30_000, Math.min(ttlMs, 15 * 60_000));
+            this.pairings.set(code, { code, expiresAt, used: false });
+            return { code, expires_at: new Date(expiresAt).toISOString() };
+        });
+    }
+    async pairAtomically(input) {
+        return this.transaction(async () => {
+            const record = this.pairings.get(input.code);
+            if (input.chatType !== 'private'
+                || !Number.isSafeInteger(input.chatId) || input.chatId <= 0
+                || !Number.isSafeInteger(input.senderId) || input.senderId <= 0
+                || !record || record.used || record.expiresAt <= this.clock.now())
+                return false;
+            record.used = true;
+            this.chats.clear();
+            this.chats.set(input.chatId, {
+                chatId: input.chatId,
+                senderId: input.senderId,
+                pairedAt: new Date(this.clock.now()).toISOString()
+            });
+            return true;
+        });
+    }
+    async authorized(chatId, senderId) {
+        return this.transaction(async () => {
+            const chat = this.chats.get(chatId);
+            return chat?.senderId === senderId;
+        });
+    }
+    async authorizedCount() {
+        return this.transaction(async () => this.chats.size);
+    }
+    expireCodes() {
+        for (const [code, record] of this.pairings) {
+            if (record.used || record.expiresAt <= this.clock.now())
+                this.pairings.delete(code);
+        }
+    }
+    transaction(operation) {
+        const next = this.transactionTail.then(operation, operation);
+        this.transactionTail = next.then(() => undefined, () => undefined);
+        return next;
+    }
+}

package/dist/core/telegram/client.js

@@ -0,0 +1,157 @@
+import { redactTelegramError } from './redaction.js';
+export class TelegramApiError extends Error {
+    code;
+    retryAfterSeconds;
+    constructor(message, code = null, retryAfterSeconds = null) {
+        super(message);
+        this.name = 'TelegramApiError';
+        this.code = code;
+        this.retryAfterSeconds = retryAfterSeconds;
+    }
+}
+export class TelegramClient {
+    tokenProvider;
+    fetchImpl;
+    baseUrl;
+    requestTimeoutMs;
+    constructor(options) {
+        this.tokenProvider = options.tokenProvider;
+        this.fetchImpl = options.fetch ?? globalThis.fetch;
+        this.baseUrl = validatedBaseUrl(options.baseUrl ?? 'https://api.telegram.org', options.allowInsecureLocalhost === true);
+        this.requestTimeoutMs = Math.max(1_000, Math.min(options.requestTimeoutMs ?? 20_000, 120_000));
+    }
+    getMe(signal) {
+        return this.call('getMe', {}, signal);
+    }
+    async getWebhookInfo(signal) {
+        const info = await this.call('getWebhookInfo', {}, signal);
+        if (!info || typeof info.url !== 'string')
+            throw new TelegramApiError('telegram_webhook_info_invalid');
+        return info;
+    }
+    async deleteWebhook(signal) {
+        const removed = await this.call('deleteWebhook', {
+            drop_pending_updates: false
+        }, signal);
+        if (removed !== true)
+            throw new TelegramApiError('telegram_delete_webhook_failed');
+    }
+    getUpdates(input) {
+        if (!Number.isSafeInteger(input.offset) || input.offset < 0) {
+            return Promise.reject(new TelegramApiError('telegram_offset_invalid'));
+        }
+        const timeoutSeconds = Number.isFinite(input.timeoutSeconds)
+            ? Math.max(0, Math.min(50, Math.floor(input.timeoutSeconds)))
+            : 0;
+        return this.call('getUpdates', {
+            offset: input.offset,
+            timeout: timeoutSeconds,
+            allowed_updates: [...(input.allowedUpdates ?? ['message'])]
+        }, input.signal, Math.max(this.requestTimeoutMs, Math.min(70_000, (timeoutSeconds * 1_000) + 10_000)));
+    }
+    sendMessage(chatId, text, signal) {
+        if (!Number.isSafeInteger(chatId))
+            return Promise.reject(new TelegramApiError('telegram_chat_id_invalid'));
+        const bounded = text.slice(0, 4_000);
+        if (!bounded)
+            return Promise.reject(new TelegramApiError('telegram_message_empty'));
+        return this.call('sendMessage', { chat_id: chatId, text: bounded }, signal);
+    }
+    async call(method, body, signal, timeoutMs = this.requestTimeoutMs) {
+        const token = String(await this.tokenProvider.loadToken() ?? '').trim();
+        if (!token)
+            throw new TelegramApiError('telegram_token_unavailable');
+        if (!/^\d+:[A-Za-z0-9_-]+$/.test(token))
+            throw new TelegramApiError('telegram_token_invalid');
+        const endpoint = new URL(`/bot${token}/${method}`, this.baseUrl);
+        const requestController = new AbortController();
+        let timedOut = false;
+        const timer = setTimeout(() => {
+            timedOut = true;
+            requestController.abort(new Error('telegram_request_timeout'));
+        }, timeoutMs);
+        const abort = () => requestController.abort(signal?.reason);
+        if (signal?.aborted)
+            requestController.abort(signal.reason);
+        else
+            signal?.addEventListener('abort', abort, { once: true });
+        try {
+            const response = await this.fetchImpl(endpoint, {
+                method: 'POST',
+                headers: { 'content-type': 'application/json; charset=utf-8' },
+                body: JSON.stringify(body),
+                redirect: 'error',
+                signal: requestController.signal
+            });
+            const decoded = await decodeBoundedJson(response);
+            if (!response.ok || !decoded.ok) {
+                const failure = decoded.ok ? null : decoded;
+                throw new TelegramApiError(redactTelegramError(failure?.description || `telegram_http_${response.status}`, token), failure?.error_code ?? response.status, failure?.parameters?.retry_after ?? null);
+            }
+            return decoded.result;
+        }
+        catch (error) {
+            if (error instanceof TelegramApiError)
+                throw error;
+            if (timedOut)
+                throw new TelegramApiError('telegram_request_timeout');
+            if (signal?.aborted)
+                throw error;
+            throw new TelegramApiError(redactTelegramError(error, token));
+        }
+        finally {
+            clearTimeout(timer);
+            signal?.removeEventListener('abort', abort);
+        }
+    }
+}
+async function decodeBoundedJson(response) {
+    const maximum = 2 * 1024 * 1024;
+    const declared = Number(response.headers.get('content-length') ?? '0');
+    if (Number.isFinite(declared) && declared > maximum)
+        throw new TelegramApiError('telegram_response_too_large');
+    const reader = response.body?.getReader();
+    let text = '';
+    if (reader) {
+        const decoder = new TextDecoder();
+        let bytes = 0;
+        while (true) {
+            const chunk = await reader.read();
+            if (chunk.done)
+                break;
+            bytes += chunk.value.byteLength;
+            if (bytes > maximum) {
+                await reader.cancel().catch(() => undefined);
+                throw new TelegramApiError('telegram_response_too_large');
+            }
+            text += decoder.decode(chunk.value, { stream: true });
+        }
+        text += decoder.decode();
+    }
+    else {
+        text = await response.text();
+        if (Buffer.byteLength(text, 'utf8') > maximum)
+            throw new TelegramApiError('telegram_response_too_large');
+    }
+    try {
+        const value = JSON.parse(text);
+        if (!value || typeof value !== 'object' || typeof value.ok !== 'boolean'
+            || (value.ok && !('result' in value))) {
+            throw new Error('shape');
+        }
+        return value;
+    }
+    catch {
+        throw new TelegramApiError('telegram_response_invalid');
+    }
+}
+function validatedBaseUrl(raw, allowInsecureLocalhost) {
+    const url = new URL(raw);
+    const local = url.hostname === '127.0.0.1' || url.hostname === 'localhost' || url.hostname === '::1';
+    if (url.username || url.password || url.search || url.hash)
+        throw new Error('telegram_base_url_invalid');
+    if (url.protocol !== 'https:' && !(allowInsecureLocalhost && local && url.protocol === 'http:')) {
+        throw new Error('telegram_base_url_https_required');
+    }
+    return url;
+}

package/dist/core/telegram/confirmation.js

@@ -0,0 +1,37 @@
+import { randomBytes } from 'node:crypto';
+import { SYSTEM_TELEGRAM_CLOCK } from './types.js';
+export class TelegramConfirmationStore {
+    clock;
+    ttlMs;
+    pending = new Map();
+    constructor(options = {}) {
+        this.clock = options.clock ?? SYSTEM_TELEGRAM_CLOCK;
+        this.ttlMs = Math.max(15_000, Math.min(options.ttlMs ?? 2 * 60_000, 10 * 60_000));
+    }
+    issue(command) {
+        this.expire();
+        const nonce = randomBytes(12).toString('base64url');
+        const expiresAt = this.clock.now() + this.ttlMs;
+        this.pending.set(nonce, { ...command, input: structuredClone(command.input), nonce, expiresAt, consumed: false });
+        return { nonce, expires_at: new Date(expiresAt).toISOString() };
+    }
+    consume(nonce, chatId, senderId) {
+        const item = this.pending.get(nonce);
+        if (!item || item.consumed || item.expiresAt <= this.clock.now()) {
+            if (item)
+                this.pending.delete(nonce);
+            return null;
+        }
+        if (item.chatId !== chatId || item.senderId !== senderId)
+            return null;
+        item.consumed = true;
+        this.pending.delete(nonce);
+        return { chatId: item.chatId, senderId: item.senderId, command: item.command, input: structuredClone(item.input) };
+    }
+    expire() {
+        for (const [nonce, item] of this.pending) {
+            if (item.consumed || item.expiresAt <= this.clock.now())
+                this.pending.delete(nonce);
+        }
+    }
+}

package/dist/core/telegram/doctor.js

@@ -0,0 +1,154 @@
+import { redactTelegramError } from './redaction.js';
+import { readTelegramLivenessReceipt, telegramLivenessPath } from './liveness.js';
+export async function probeTelegram(input) {
+    const now = input.now ?? Date.now();
+    if (!input.client || !input.tokenProvider) {
+        return probeTelegramReceipt(input.receiptPath, now);
+    }
+    const receiptProbe = !input.access || !input.poller
+        ? await probeTelegramReceipt(input.receiptPath, now)
+        : null;
+    const blockers = receiptProbe
+        ? receiptProbe.blockers.filter((blocker) => ![
+            'telegram_token_missing',
+            'telegram_getme_not_valid',
+            'telegram_getme_stale'
+        ].includes(blocker))
+        : [];
+    let tokenConfigured = false;
+    try {
+        tokenConfigured = Boolean(String(await input.tokenProvider.loadToken() ?? '').trim());
+    }
+    catch (error) {
+        blockers.push(`telegram_token_load_failed:${redactTelegramError(error)}`);
+    }
+    let identityValid = false;
+    let getMeCheckedAt = null;
+    let getMeLatencyMs = null;
+    if (!tokenConfigured)
+        blockers.push('telegram_token_missing');
+    else {
+        const started = Date.now();
+        try {
+            identityValid = (await input.client.getMe()).is_bot === true;
+            if (!identityValid)
+                blockers.push('telegram_getme_not_bot');
+        }
+        catch (error) {
+            blockers.push(`telegram_getme_failed:${redactTelegramError(error)}`);
+        }
+        finally {
+            getMeLatencyMs = Date.now() - started;
+            getMeCheckedAt = new Date().toISOString();
+        }
+    }
+    let pairedChatCount = receiptProbe?.paired_chat_count ?? 0;
+    if (input.access) {
+        try {
+            pairedChatCount = await input.access.authorizedCount();
+        }
+        catch (error) {
+            blockers.push(`telegram_access_state_failed:${redactTelegramError(error)}`);
+        }
+    }
+    if (pairedChatCount === 0 && !blockers.includes('telegram_private_chat_not_paired')) {
+        blockers.push('telegram_private_chat_not_paired');
+    }
+    let poller = receiptProbe?.poller ?? emptyPoller();
+    if (input.poller) {
+        try {
+            poller = input.poller.snapshot();
+        }
+        catch (error) {
+            blockers.push(`telegram_poller_state_failed:${redactTelegramError(error)}`);
+        }
+    }
+    if (!poller.running && !blockers.includes('telegram_poller_not_running')) {
+        blockers.push('telegram_poller_not_running');
+    }
+    return {
+        schema: 'sks.telegram-doctor-probe.v1',
+        ok: blockers.length === 0,
+        status: !tokenConfigured ? 'not_configured' : blockers.length ? 'degraded' : 'ready',
+        token_configured: tokenConfigured,
+        token_source: tokenConfigured ? (receiptProbe?.token_source ?? 'unknown') : 'none',
+        bot_identity_valid: identityValid,
+        getme_checked_at: getMeCheckedAt,
+        getme_latency_ms: getMeLatencyMs,
+        getme_check_kind: 'live',
+        paired_chat_count: pairedChatCount,
+        audit_healthy: receiptProbe?.audit_healthy ?? true,
+        audit_last_error: receiptProbe?.audit_last_error ?? null,
+        poller,
+        blockers: [...new Set(blockers)],
+        checked_at: new Date().toISOString()
+    };
+}
+async function probeTelegramReceipt(receiptPath, now) {
+    const liveness = await readTelegramLivenessReceipt(receiptPath ?? telegramLivenessPath(), now);
+    if (!liveness.ok) {
+        return {
+            schema: 'sks.telegram-doctor-probe.v1', ok: false, status: 'not_configured',
+            token_configured: false, bot_identity_valid: false, paired_chat_count: 0,
+            token_source: 'none',
+            audit_healthy: false, audit_last_error: null,
+            getme_checked_at: null, getme_latency_ms: null,
+            getme_check_kind: 'receipt',
+            poller: emptyPoller(), blockers: [liveness.blocker], checked_at: new Date(now).toISOString()
+        };
+    }
+    const receipt = liveness.receipt;
+    const blockers = [];
+    if (!receipt.token_configured)
+        blockers.push('telegram_token_missing');
+    if (receipt.token_configured && !receipt.bot_identity_valid)
+        blockers.push('telegram_getme_not_valid');
+    const getMeAge = receipt.getme_checked_at ? now - Date.parse(receipt.getme_checked_at) : Number.POSITIVE_INFINITY;
+    if (receipt.bot_identity_valid && getMeAge > 10 * 60_000)
+        blockers.push('telegram_getme_stale');
+    if (receipt.paired_chat_count === 0)
+        blockers.push('telegram_private_chat_not_paired');
+    if (receipt.audit_healthy === false)
+        blockers.push('telegram_audit_unavailable');
+    if (!receipt.running || !receipt.poller.running)
+        blockers.push('telegram_poller_not_running');
+    if (liveness.stale)
+        blockers.push('telegram_liveness_stale');
+    if (receipt.poller.consecutive_failures > 0)
+        blockers.push('telegram_poller_degraded');
+    return {
+        schema: 'sks.telegram-doctor-probe.v1',
+        ok: blockers.length === 0,
+        status: !receipt.token_configured ? 'not_configured' : blockers.length ? 'degraded' : 'ready',
+        token_configured: receipt.token_configured,
+        token_source: receipt.token_source ?? (receipt.token_configured ? 'unknown' : 'none'),
+        bot_identity_valid: receipt.bot_identity_valid,
+        getme_checked_at: receipt.getme_checked_at,
+        getme_latency_ms: receipt.getme_latency_ms,
+        getme_check_kind: 'receipt',
+        paired_chat_count: receipt.paired_chat_count,
+        audit_healthy: receipt.audit_healthy !== false,
+        audit_last_error: receipt.audit_last_error ?? null,
+        poller: receipt.poller,
+        blockers,
+        checked_at: new Date(now).toISOString()
+    };
+}
+function emptyPoller() {
+    return {
+        schema: 'sks.telegram-poller-state.v1', running: false, offset: 0,
+        consecutive_failures: 0, last_poll_at: null, last_success_at: null,
+        last_update_at: null, last_error: null
+    };
+}
+export function telegramSelfHealAction(probe) {
+    if (!probe.audit_healthy || probe.blockers.includes('telegram_audit_unavailable'))
+        return 'operator_repair_audit';
+    if (!probe.token_configured || !probe.bot_identity_valid || probe.blockers.includes('telegram_getme_stale'))
+        return 'revalidate_token';
+    if (/409|webhook/i.test(probe.poller.last_error ?? ''))
+        return 'operator_remove_webhook';
+    if (probe.blockers.includes('telegram_liveness_stale') || !probe.poller.running || probe.poller.consecutive_failures > 0)
+        return 'restart_poll';
+    return 'none';
+}

package/dist/core/telegram/index.js

@@ -0,0 +1,9 @@
+export * from './access.js';
+export * from './client.js';
+export * from './confirmation.js';
+export * from './doctor.js';
+export * from './liveness.js';
+export * from './keychain.js';
+export * from './poller.js';
+export * from './redaction.js';
+export * from './types.js';