sneakoscope 7.3.0 → 7.6.0

package/dist/core/telegram/ledgers.js

@@ -5,12 +5,13 @@ import { appendJsonlBounded, ensureDir, nowIso, readJson, sha256, writeJsonAtomi
 import { withFileLock } from '../locks/file-lock.js';
 export class TelegramTopicRegistry {
     file;
-    constructor(file) {
+    options;
+    constructor(file, options = {}) {
         this.file = file;
+        this.options = options;
     }
     async list() {
-        const registry = await readJson(this.file, { schema: 'sks.telegram-topic-registry.v1', routes: [] });
-        return registry.schema === 'sks.telegram-topic-registry.v1' && Array.isArray(registry.routes) ? registry.routes : [];
+        return (await this.readRegistry()).routes;
     }
     async findBySession(machineId, projectId, sessionId) {
         return (await this.list()).find((route) => route.machine_id === machineId && route.project_id === projectId && route.session_id === sessionId) ?? null;
@@ -20,7 +21,8 @@ export class TelegramTopicRegistry {
     }
     async upsert(input) {
         return withFileLock({ lockPath: `${this.file}.lock`, timeoutMs: 5_000, staleMs: 30_000 }, async () => {
-            const routes = await this.list();
+            const registry = await this.readRegistry();
+            const routes = [...registry.routes];
             const sessionIndex = routes.findIndex((route) => route.machine_id === input.machine_id && route.project_id === input.project_id && route.session_id === input.session_id);
             const collision = input.message_thread_id > 0
                 ? routes.find((route, index) => index !== sessionIndex && route.chat_id === input.chat_id && route.message_thread_id === input.message_thread_id)
@@ -29,6 +31,10 @@ export class TelegramTopicRegistry {
                 throw new Error('telegram_topic_collision');
             const current = sessionIndex >= 0 ? routes[sessionIndex] : undefined;
             const at = nowIso();
+            const routeMoved = Boolean(current
+                && (current.chat_id !== input.chat_id
+                    || current.message_thread_id !== input.message_thread_id));
+            const generationBase = Math.max(registry.generation_epoch ?? 0, ...routes.map((route) => route.generation));
             const next = {
                 schema: 'sks.telegram-topic-route.v1',
                 machine_id: input.machine_id,
@@ -39,16 +45,60 @@ export class TelegramTopicRegistry {
                 pinned_message_id: input.pinned_message_id,
                 created_at: current?.created_at ?? at,
                 updated_at: at,
-                generation: current ? current.generation + (input.recreate === true ? 1 : 0) : 1
+                generation: current && !routeMoved && input.recreate !== true
+                    ? current.generation
+                    : generationBase + 1
             };
             if (sessionIndex >= 0)
                 routes[sessionIndex] = next;
             else
                 routes.push(next);
-            await writeJsonAtomic(this.file, { schema: 'sks.telegram-topic-registry.v1', routes });
+            await writeJsonAtomic(this.file, {
+                schema: 'sks.telegram-topic-registry.v1',
+                ...(this.options.identityFingerprint
+                    ? { identity_fingerprint: this.options.identityFingerprint }
+                    : {}),
+                generation_epoch: Math.max(generationBase, next.generation),
+                routes
+            });
             return next;
         });
     }
+    async invalidateAll() {
+        return withFileLock({ lockPath: `${this.file}.lock`, timeoutMs: 5_000, staleMs: 30_000 }, async () => {
+            const raw = await this.readRawRegistry();
+            const generationEpoch = Math.max(raw.generation_epoch ?? 0, ...raw.routes.map((route) => route.generation));
+            await writeJsonAtomic(this.file, {
+                schema: 'sks.telegram-topic-registry.v1',
+                ...(this.options.identityFingerprint
+                    ? { identity_fingerprint: this.options.identityFingerprint }
+                    : {}),
+                generation_epoch: generationEpoch,
+                routes: []
+            });
+            return generationEpoch;
+        });
+    }
+    async readRegistry() {
+        const registry = await this.readRawRegistry();
+        const expectedIdentity = this.options.identityFingerprint;
+        if (!expectedIdentity || registry.identity_fingerprint === expectedIdentity)
+            return registry;
+        return {
+            schema: 'sks.telegram-topic-registry.v1',
+            identity_fingerprint: expectedIdentity,
+            generation_epoch: Math.max(registry.generation_epoch ?? 0, ...registry.routes.map((route) => route.generation)),
+            routes: []
+        };
+    }
+    async readRawRegistry() {
+        const registry = await readJson(this.file, { schema: 'sks.telegram-topic-registry.v1', routes: [] });
+        if (registry.schema !== 'sks.telegram-topic-registry.v1'
+            || !Array.isArray(registry.routes)) {
+            throw new Error('telegram_topic_registry_schema_invalid');
+        }
+        return registry;
+    }
 }
 export function buildTelegramTopicName(input, existingNames = [], maxLength = 128) {
     const normalized = [input.machine, `${input.repo}/${input.branch}`, input.title]
@@ -80,33 +130,86 @@ export class TelegramIdempotencyLedger {
 }
 export class TelegramActionBroker {
     file;
-    constructor(file) {
+    maxEntries;
+    now;
+    constructor(file, options = {}) {
         this.file = file;
+        this.maxEntries = Math.max(64, Math.min(4096, options.maxEntries ?? 512));
+        this.now = options.now ?? Date.now;
     }
     async create(action, route) {
-        if (action.risk === 'R3')
+        return (await this.createMany([{ action, route }]))[0];
+    }
+    async createMany(entries) {
+        if (entries.some((entry) => entry.action.risk === 'R3'))
             throw new Error('telegram_r3_always_denied');
         return this.mutate((ledger) => {
-            if (ledger.actions.some((candidate) => candidate.action_id === action.action_id))
-                throw new Error('telegram_action_id_exists');
-            const alias = createAlias();
-            const callbackData = `cb:${alias}`;
-            if (Buffer.byteLength(callbackData, 'utf8') < 1 || Buffer.byteLength(callbackData, 'utf8') > 64)
-                throw new Error('telegram_callback_data_out_of_bounds');
-            ledger.actions.push(action);
-            ledger.aliases.push({
-                alias,
-                action_id: action.action_id,
-                session_id: action.session_id,
-                chat_id: route.chat_id,
-                message_thread_id: route.message_thread_id,
-                revision: action.revision,
-                expires_at: action.expires_at,
-                used_at: null
+            expireOpenActions(ledger, this.now());
+            const actionsById = new Map(ledger.actions.map((action) => [action.action_id, action]));
+            const aliasesByActionId = new Map(ledger.aliases.map((alias) => [alias.action_id, alias]));
+            const protectedActionIds = new Set();
+            let additions = 0;
+            for (const { action, route } of entries) {
+                if (protectedActionIds.has(action.action_id))
+                    throw new Error('telegram_action_batch_duplicate');
+                protectedActionIds.add(action.action_id);
+                const existing = actionsById.get(action.action_id);
+                if (!existing) {
+                    additions += 1;
+                    continue;
+                }
+                const existingAlias = aliasesByActionId.get(action.action_id);
+                if (!existingAlias
+                    || existing.status !== 'open'
+                    || existing.route_generation !== action.route_generation
+                    || existingAlias.chat_id !== route.chat_id
+                    || existingAlias.message_thread_id !== route.message_thread_id) {
+                    throw new Error('telegram_action_id_exists');
+                }
+            }
+            reserveActionLedgerCapacity(ledger, this.maxEntries, additions, protectedActionIds);
+            return entries.map(({ action, route }) => {
+                const existing = actionsById.get(action.action_id);
+                if (existing) {
+                    const existingAlias = aliasesByActionId.get(action.action_id);
+                    return { action: existing, callback_data: `cb:${existingAlias.alias}` };
+                }
+                const alias = createAlias();
+                const callbackData = `cb:${alias}`;
+                if (Buffer.byteLength(callbackData, 'utf8') < 1 || Buffer.byteLength(callbackData, 'utf8') > 64)
+                    throw new Error('telegram_callback_data_out_of_bounds');
+                ledger.actions.push(action);
+                const aliasEntry = {
+                    alias,
+                    action_id: action.action_id,
+                    session_id: action.session_id,
+                    chat_id: route.chat_id,
+                    message_thread_id: route.message_thread_id,
+                    route_generation: action.route_generation,
+                    revision: action.revision,
+                    expires_at: action.expires_at,
+                    used_at: null,
+                    claimed_update_id: null
+                };
+                ledger.aliases.push(aliasEntry);
+                actionsById.set(action.action_id, action);
+                aliasesByActionId.set(action.action_id, aliasEntry);
+                return { action, callback_data: callbackData };
             });
-            return { action, callback_data: callbackData };
         });
     }
+    async inspect(callbackData) {
+        const ledger = await readJson(this.file, { schema: 'sks.telegram-action-ledger.v1', actions: [], aliases: [] });
+        if (ledger.schema !== 'sks.telegram-action-ledger.v1') {
+            return { alias: null, action: null };
+        }
+        const aliasValue = callbackData.startsWith('cb:') ? callbackData.slice(3) : '';
+        const alias = ledger.aliases.find((entry) => entry.alias === aliasValue) ?? null;
+        const action = alias
+            ? ledger.actions.find((entry) => entry.action_id === alias.action_id) ?? null
+            : null;
+        return { alias, action };
+    }
     async resolve(input) {
         return this.mutate((ledger) => {
             const aliasValue = input.callback_data.startsWith('cb:') ? input.callback_data.slice(3) : '';
@@ -116,19 +219,30 @@ export class TelegramActionBroker {
             const action = ledger.actions.find((entry) => entry.action_id === alias.action_id) ?? null;
             if (!action)
                 return { ok: false, status: 'unknown_action', action: null };
+            if (alias.claimed_update_id === input.update_id
+                && alias.used_at
+                && action.status === 'claimed') {
+                return { ok: true, status: 'claimed', action };
+            }
             if (alias.used_at || ['claimed', 'resolved', 'cancelled'].includes(action.status))
                 return { ok: false, status: 'already_resolved', action };
-            const now = input.now ?? Date.now();
-            if (Date.parse(alias.expires_at) <= now || Date.parse(action.expires_at) <= now) {
+            const now = input.now ?? this.now();
+            if (hasExpired(alias.expires_at, now) || hasExpired(action.expires_at, now)) {
                 action.status = 'expired';
                 return { ok: false, status: 'expired', action };
             }
             if (alias.chat_id !== input.chat_id || alias.message_thread_id !== input.message_thread_id)
                 return { ok: false, status: 'wrong_topic', action };
+            if (input.route_generation === null
+                || alias.route_generation !== input.route_generation
+                || action.route_generation !== input.route_generation) {
+                return { ok: false, status: 'stale_generation', action };
+            }
             if (alias.revision !== input.revision || action.revision !== input.revision)
                 return { ok: false, status: 'revision_mismatch', action };
             const usedAt = new Date(now).toISOString();
             alias.used_at = usedAt;
+            alias.claimed_update_id = input.update_id;
             action.status = 'claimed';
             return { ok: true, status: 'claimed', action };
         });
@@ -148,11 +262,52 @@ export class TelegramActionBroker {
             if (ledger.schema !== 'sks.telegram-action-ledger.v1')
                 throw new Error('telegram_action_ledger_schema_invalid');
             const result = fn(ledger);
+            capActionLedger(ledger, this.maxEntries);
             await writeJsonAtomic(this.file, ledger);
             return result;
         });
     }
 }
+function capActionLedger(ledger, maxEntries) {
+    if (ledger.actions.length <= maxEntries)
+        return;
+    pruneTerminalActionHistory(ledger, ledger.actions.length - maxEntries);
+}
+function reserveActionLedgerCapacity(ledger, maxEntries, additions, protectedActionIds) {
+    const removeCount = Math.max(0, ledger.actions.length + additions - maxEntries);
+    if (removeCount === 0)
+        return;
+    pruneTerminalActionHistory(ledger, removeCount, protectedActionIds);
+}
+function pruneTerminalActionHistory(ledger, removeCount, protectedActionIds = new Set()) {
+    const removable = ledger.actions
+        .filter((action) => isTerminalActionStatus(action.status) && !protectedActionIds.has(action.action_id))
+        .slice(0, removeCount);
+    if (removable.length < removeCount)
+        throw new Error('telegram_action_ledger_capacity_exceeded');
+    const removedIds = new Set(removable.map((action) => action.action_id));
+    ledger.actions = ledger.actions.filter((action) => !removedIds.has(action.action_id));
+    ledger.aliases = ledger.aliases.filter((alias) => !removedIds.has(alias.action_id));
+}
+function isTerminalActionStatus(status) {
+    return status === 'resolved' || status === 'cancelled' || status === 'expired';
+}
+function expireOpenActions(ledger, now) {
+    const aliasesByActionId = new Map(ledger.aliases.map((alias) => [alias.action_id, alias]));
+    for (const action of ledger.actions) {
+        if (action.status !== 'open')
+            continue;
+        const alias = aliasesByActionId.get(action.action_id);
+        if (hasExpired(action.expires_at, now)
+            || (alias && hasExpired(alias.expires_at, now))) {
+            action.status = 'expired';
+        }
+    }
+}
+function hasExpired(expiresAt, now) {
+    const expiresAtMs = Date.parse(expiresAt);
+    return !Number.isFinite(expiresAtMs) || expiresAtMs <= now;
+}
 export class TelegramAuditLedger {
     file;
     salt;
@@ -167,11 +322,15 @@ export class TelegramAuditLedger {
             update_id: input.update_id,
             chat_id_hash: `sha256:${sha256(`${this.salt}:${input.chat_id}`)}`,
             topic_id: input.topic_id,
-            action_alias: input.action_alias,
+            action_alias: input.action_alias ? `sha256:${sha256(`${this.salt}:${input.action_alias}`)}` : null,
             command_kind: sanitizeAuditField(input.command_kind),
             decision: input.decision,
             policy_reason: sanitizeAuditField(input.policy_reason),
-            effect_receipt: input.effect_receipt ? sanitizeAuditField(input.effect_receipt) : null
+            effect_receipt: input.effect_receipt ? sanitizeAuditField(input.effect_receipt) : null,
+            telegram_delivery: input.telegram_delivery,
+            telegram_delivery_receipt: input.telegram_delivery_receipt
+                ? sanitizeAuditField(input.telegram_delivery_receipt)
+                : null
         };
         await appendJsonlBounded(this.file, event, 5 * 1024 * 1024);
         return event;

package/dist/core/telegram/messages.js

@@ -178,14 +178,34 @@ export class TelegramMessageProjector {
                 text,
                 reply_markup: replyMarkup
             }));
-            return { method: 'editMessageText', message_id: input.route.pinned_message_id, pinned: true };
+            return {
+                method: 'editMessageText',
+                message_id: input.route.pinned_message_id,
+                pinned: true,
+                pin_delivery: 'not_attempted'
+            };
         }
         const sent = await this.sendFinal({ route: input.route, text, replyMarkup });
-        await this.api.call('pinChatMessage', this.basePayload(input.route, {
-            message_id: sent.message_id,
-            disable_notification: true
-        }));
-        return { method: sent.method, message_id: sent.message_id, pinned: true };
+        try {
+            await this.api.call('pinChatMessage', this.basePayload(input.route, {
+                message_id: sent.message_id,
+                disable_notification: true
+            }));
+            return {
+                method: sent.method,
+                message_id: sent.message_id,
+                pinned: true,
+                pin_delivery: 'delivered'
+            };
+        }
+        catch (error) {
+            return {
+                method: sent.method,
+                message_id: sent.message_id,
+                pinned: false,
+                pin_delivery: error instanceof TelegramBotApiError ? error.delivery : 'unknown'
+            };
+        }
     }
     async requestInput(input) {
         const sent = await this.sendFinal({

package/dist/core/telegram/owner-lock.js

@@ -2,6 +2,7 @@ import crypto from 'node:crypto';
 import fsp from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
+import { errorCodeOf } from '../errors/message.js';
 import { ensureDir, nowIso } from '../fsx.js';
 export class TelegramOwnerConflictError extends Error {
     owner;
@@ -19,6 +20,7 @@ export class TelegramOwnerLock {
     processStartTime;
     now;
     isPidAlive;
+    reclaimDeadImmediately;
     owner = null;
     constructor(options) {
         this.options = options;
@@ -28,6 +30,7 @@ export class TelegramOwnerLock {
         this.processStartTime = options.processStartTime ?? new Date(Date.now() - process.uptime() * 1000).toISOString();
         this.now = options.now ?? Date.now;
         this.isPidAlive = options.isPidAlive ?? localPidAlive;
+        this.reclaimDeadImmediately = options.reclaimDeadImmediately === true;
     }
     async acquire() {
         await ensureDir(path.dirname(this.options.lockPath));
@@ -46,7 +49,7 @@ export class TelegramOwnerLock {
                 return owner;
             }
             catch (error) {
-                if (errorCode(error) !== 'EEXIST')
+                if (errorCodeOf(error) !== 'EEXIST')
                     throw error;
                 const existing = await this.readOwner();
                 if (!this.isStale(existing))
@@ -57,7 +60,7 @@ export class TelegramOwnerLock {
                     await fsp.unlink(quarantine).catch(() => undefined);
                 }
                 catch (renameError) {
-                    if (!['ENOENT', 'EEXIST'].includes(errorCode(renameError)))
+                    if (!['ENOENT', 'EEXIST'].includes(errorCodeOf(renameError)))
                         throw renameError;
                 }
             }
@@ -108,7 +111,10 @@ export class TelegramOwnerLock {
         if (!owner)
             return true;
         const age = this.now() - Date.parse(owner.heartbeat_at);
-        return Number.isFinite(age) && age > this.staleMs && !this.isPidAlive(owner.pid, owner.host);
+        const alive = this.isPidAlive(owner.pid, owner.host);
+        if (!alive && this.reclaimDeadImmediately)
+            return true;
+        return Number.isFinite(age) && age > this.staleMs && !alive;
     }
 }
 function sameOwner(left, right) {
@@ -126,9 +132,6 @@ function localPidAlive(pid, host) {
         return true;
     }
     catch (error) {
-        return errorCode(error) !== 'ESRCH';
+        return errorCodeOf(error) !== 'ESRCH';
     }
 }
-function errorCode(error) {
-    return error && typeof error === 'object' && 'code' in error ? String(error.code) : '';
-}

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

@@ -3,13 +3,20 @@ 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) {
+export function pickerAction(route, now, updateId) {
     return {
         schema: 'sks.remote-action.v1',
-        action_id: crypto.randomUUID(),
+        action_id: `tg-pick-${crypto.createHash('sha256').update([
+            updateId,
+            route.machine_id,
+            route.project_id,
+            route.session_id,
+            route.generation
+        ].join(':')).digest('hex').slice(0, 36)}`,
         machine_id: route.machine_id,
         project_id: route.project_id,
         session_id: route.session_id,
+        route_generation: route.generation,
         kind: 'read',
         risk: 'R0',
         prompt: 'pick',
@@ -63,6 +70,28 @@ export function successSummary(action, data) {
         return `Verification snapshot: ${snapshotSummary(data ?? {})}`;
     return snapshotSummary(data ?? {});
 }
+export function failureSummary(codeInput, deliveryInput) {
+    const code = publicSafeText(String(codeInput || 'remote_command_failed')).slice(0, 160);
+    const delivery = String(deliveryInput || '');
+    if (code === 'codex_turn_completion_unknown') {
+        return `Codex accepted this turn, but SKS lost the completion signal. It will not replay the request automatically. Check SKS Center → Telegram → Codex activity or send /status before trying again. Code: ${code}`;
+    }
+    if (code === 'codex_turn_start_delivery_unknown' || delivery === 'unknown') {
+        return `Codex may already have received this request, so SKS will not replay it automatically. Check SKS Center → Telegram → Codex activity or send /status before trying again. Code: ${code}`;
+    }
+    if (code.includes('_contract_invalid')) {
+        return `The linked Codex App Server rejected an incompatible request contract before delivery. Restart the updated SKS Hub, then retry once. Code: ${code}`;
+    }
+    if (code === 'codex_app_server_initialize_failed'
+        || code === 'codex_app_server_unavailable'
+        || code === 'codex_app_server_provider_credentials_unavailable') {
+        return `The request was not sent because the linked Codex App Server could not initialize. Recheck provider authentication and Hub status in SKS Center. Code: ${code}`;
+    }
+    if (delivery === 'acknowledged') {
+        return `Codex acknowledged the request, but SKS could not finish projecting the result. Check the linked Codex thread in SKS Center before sending another request. Code: ${code}`;
+    }
+    return `Remote action blocked before completion. Use /status or SKS Center → Telegram → Diagnostics for the next action. Code: ${code}`;
+}
 export function topicName(target, sessionId, snapshot) {
     const project = asRecord(snapshot?.project);
     return buildTelegramTopicName({
@@ -80,7 +109,13 @@ export function routeKey(route) {
     return `${route.machine_id}:${route.project_id}:${route.session_id}:${route.generation}`;
 }
 export function emptyProjection() {
-    return { after_seq: 0, snapshot_digest: null, draft_message_id: null, final_generation: null };
+    return {
+        after_seq: 0,
+        snapshot_digest: null,
+        draft_message_id: null,
+        final_generation: null,
+        final_generation_unknown: null
+    };
 }
 export function requestId(prefix) {
     return `${prefix}:${crypto.randomUUID()}`;