agent-afk 5.296.1 → 5.296.3

package/dist/skills/audit-fit/handler.d.ts

@@ -0,0 +1,4 @@
+import type { SkillExecutionContext } from '../index.js';
+import type { IAgentSession } from '../../agent/types.js';
+import { type AuditFitResult } from './schemas.js';
+export declare function handler(input: unknown, parentSession?: IAgentSession, ctx?: SkillExecutionContext): Promise<AuditFitResult>;

package/dist/skills/audit-fit/index.d.ts

@@ -1,100 +1,5 @@
-import { z } from 'zod';
 import { type SkillMetadata } from '../index.js';
-import type { SubagentResult } from '../../agent/subagent/result.js';
-import { type DiscoveredHook } from './discover.js';
-export declare const VerdictSchema: z.ZodObject<{
-    path: z.ZodString;
-    type: z.ZodEnum<{
-        agent: "agent";
-        command: "command";
-        skill: "skill";
-        hook: "hook";
-    }>;
-    source: z.ZodEnum<{
-        user: "user";
-        plugin: "plugin";
-    }>;
-    plugin_key: z.ZodOptional<z.ZodString>;
-    verdict: z.ZodEnum<{
-        correct: "correct";
-        misfit: "misfit";
-        outlier: "outlier";
-    }>;
-    recommended_type: z.ZodString;
-    rationale: z.ZodString;
-    confidence: z.ZodEnum<{
-        low: "low";
-        high: "high";
-        med: "med";
-    }>;
-}, z.core.$strip>;
-export type Verdict = z.infer<typeof VerdictSchema>;
-export declare const InventoryMatrixSchema: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodNumber>>;
-export type InventoryMatrix = z.infer<typeof InventoryMatrixSchema>;
-export declare const AuditFitResultSchema: z.ZodObject<{
-    inventory: z.ZodObject<{
-        user: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodNumber>>;
-        plugin: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodNumber>>;
-    }, z.core.$strip>;
-    misfits: z.ZodArray<z.ZodObject<{
-        path: z.ZodString;
-        type: z.ZodEnum<{
-            agent: "agent";
-            command: "command";
-            skill: "skill";
-            hook: "hook";
-        }>;
-        source: z.ZodEnum<{
-            user: "user";
-            plugin: "plugin";
-        }>;
-        plugin_key: z.ZodOptional<z.ZodString>;
-        verdict: z.ZodEnum<{
-            correct: "correct";
-            misfit: "misfit";
-            outlier: "outlier";
-        }>;
-        recommended_type: z.ZodString;
-        rationale: z.ZodString;
-        confidence: z.ZodEnum<{
-            low: "low";
-            high: "high";
-            med: "med";
-        }>;
-    }, z.core.$strip>>;
-    briefs_written: z.ZodNumber;
-    total_artifacts: z.ZodNumber;
-}, z.core.$strip>;
-export type AuditFitResult = z.infer<typeof AuditFitResultSchema>;
-export declare const AuditFitInputSchema: z.ZodObject<{
-    writeBriefs: z.ZodOptional<z.ZodBoolean>;
-    scope: z.ZodOptional<z.ZodEnum<{
-        user: "user";
-        plugin: "plugin";
-        all: "all";
-    }>>;
-}, z.core.$strip>;
-export type AuditFitInput = z.infer<typeof AuditFitInputSchema>;
-type Scope = 'user' | 'plugin' | 'all';
-type FullArtifactType = 'skill' | 'command' | 'agent' | 'hook';
-export declare function planAuditScope(scope: Scope): {
-    runUserDiscovery: boolean;
-    runPluginDiscovery: boolean;
-    runHookInspector: boolean;
-};
-export declare function aggregateVerdicts(verdicts: ReadonlyArray<Verdict>): {
-    inventory: AuditFitResult['inventory'];
-    misfits: Verdict[];
-};
-export declare function shouldWriteBriefForMisfit(m: Verdict): boolean;
-export declare function renderHookList(settingsPath: string, hooks: ReadonlyArray<DiscoveredHook>): string;
-export type InspectorOutcome = {
-    kind: 'failure';
-    message: string;
-} | {
-    kind: 'success';
-    output: ReadonlyArray<Verdict>;
-};
-export declare function classifyInspectorResult(type: FullArtifactType, result: SubagentResult<ReadonlyArray<Verdict>> | undefined): InspectorOutcome;
+export { VerdictSchema, InventoryMatrixSchema, AuditFitResultSchema, AuditFitInputSchema, planAuditScope, aggregateVerdicts, shouldWriteBriefForMisfit, renderHookList, classifyInspectorResult, ALL_TYPES, } from './schemas.js';
+export type { Verdict, InventoryMatrix, AuditFitResult, AuditFitInput, Scope, FullArtifactType, InspectorOutcome, } from './schemas.js';
+export type { SkillExecutionContext } from '../index.js';
 export declare const auditFitSkill: SkillMetadata;
-export {};

package/dist/skills/audit-fit/schemas.d.ts

@@ -0,0 +1,98 @@
+import { z } from 'zod';
+import type { SubagentResult } from '../../agent/subagent/result.js';
+import type { DiscoveredHook } from './discover.js';
+export declare const VerdictSchema: z.ZodObject<{
+    path: z.ZodString;
+    type: z.ZodEnum<{
+        agent: "agent";
+        command: "command";
+        skill: "skill";
+        hook: "hook";
+    }>;
+    source: z.ZodEnum<{
+        user: "user";
+        plugin: "plugin";
+    }>;
+    plugin_key: z.ZodOptional<z.ZodString>;
+    verdict: z.ZodEnum<{
+        correct: "correct";
+        misfit: "misfit";
+        outlier: "outlier";
+    }>;
+    recommended_type: z.ZodString;
+    rationale: z.ZodString;
+    confidence: z.ZodEnum<{
+        low: "low";
+        high: "high";
+        med: "med";
+    }>;
+}, z.core.$strip>;
+export type Verdict = z.infer<typeof VerdictSchema>;
+export declare const InventoryMatrixSchema: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodNumber>>;
+export type InventoryMatrix = z.infer<typeof InventoryMatrixSchema>;
+export declare const AuditFitResultSchema: z.ZodObject<{
+    inventory: z.ZodObject<{
+        user: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodNumber>>;
+        plugin: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    }, z.core.$strip>;
+    misfits: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        type: z.ZodEnum<{
+            agent: "agent";
+            command: "command";
+            skill: "skill";
+            hook: "hook";
+        }>;
+        source: z.ZodEnum<{
+            user: "user";
+            plugin: "plugin";
+        }>;
+        plugin_key: z.ZodOptional<z.ZodString>;
+        verdict: z.ZodEnum<{
+            correct: "correct";
+            misfit: "misfit";
+            outlier: "outlier";
+        }>;
+        recommended_type: z.ZodString;
+        rationale: z.ZodString;
+        confidence: z.ZodEnum<{
+            low: "low";
+            high: "high";
+            med: "med";
+        }>;
+    }, z.core.$strip>>;
+    briefs_written: z.ZodNumber;
+    total_artifacts: z.ZodNumber;
+}, z.core.$strip>;
+export type AuditFitResult = z.infer<typeof AuditFitResultSchema>;
+export declare const AuditFitInputSchema: z.ZodObject<{
+    writeBriefs: z.ZodOptional<z.ZodBoolean>;
+    scope: z.ZodOptional<z.ZodEnum<{
+        user: "user";
+        plugin: "plugin";
+        all: "all";
+    }>>;
+}, z.core.$strip>;
+export type AuditFitInput = z.infer<typeof AuditFitInputSchema>;
+export type Scope = 'user' | 'plugin' | 'all';
+export type FullArtifactType = 'skill' | 'command' | 'agent' | 'hook';
+export declare const ALL_TYPES: ReadonlyArray<FullArtifactType>;
+export declare function planAuditScope(scope: Scope): {
+    runUserDiscovery: boolean;
+    runPluginDiscovery: boolean;
+    runHookInspector: boolean;
+};
+export declare function aggregateVerdicts(verdicts: ReadonlyArray<Verdict>): {
+    inventory: AuditFitResult['inventory'];
+    misfits: Verdict[];
+};
+export declare function shouldWriteBriefForMisfit(m: Verdict): boolean;
+export declare function renderHookList(settingsPath: string, hooks: ReadonlyArray<DiscoveredHook>): string;
+export type InspectorOutcome = {
+    kind: 'failure';
+    message: string;
+} | {
+    kind: 'success';
+    output: ReadonlyArray<Verdict>;
+};
+export declare function classifyInspectorResult(type: FullArtifactType, result: SubagentResult<ReadonlyArray<Verdict>> | undefined): InspectorOutcome;

package/dist/telegram/handlers/farm-callbacks.open-pr.d.ts

@@ -0,0 +1,7 @@
+import type { Context } from 'telegraf';
+import { type CreatePrOpts, type ExecFn } from '../../agent/gh.js';
+import { type FarmManifest } from '../../agent/worktree.js';
+import type { FarmCallbackDeps } from './farm-callbacks.js';
+type LogFn = (...args: unknown[]) => void;
+export declare function handleOpenPr(ctx: Context, manifest: FarmManifest, deps: FarmCallbackDeps, log: LogFn): Promise<void>;
+export type { CreatePrOpts, ExecFn };

package/dist/telegram/handlers/farm-callbacks.respawn.d.ts

@@ -0,0 +1,6 @@
+import type { Context } from 'telegraf';
+import { type FarmManifest } from '../../agent/worktree.js';
+import type { FarmCallbackDeps } from './farm-callbacks.js';
+type LogFn = (...args: unknown[]) => void;
+export declare function handleRespawn(ctx: Context, manifest: FarmManifest, deps: FarmCallbackDeps, log: LogFn): Promise<void>;
+export {};

package/dist/telegram/handlers/message.compact-handler.d.ts

@@ -0,0 +1,14 @@
+import type { Context } from 'telegraf';
+import { type TelegramRoute } from '../route.js';
+import type { SessionManager } from '../session-manager.js';
+type LogFn = (...args: unknown[]) => void;
+export interface CompactHandlerContext {
+    sessionManager: SessionManager;
+    log: LogFn;
+    reserveClaim(key: string): void;
+    releaseClaim(key: string): void;
+    enqueueCompact(route: TelegramRoute, ctx: Context): void;
+    drainQueue(route: TelegramRoute): Promise<void>;
+}
+export declare function processCompactDirectImpl(route: TelegramRoute, ctx: Context, hc: CompactHandlerContext): Promise<void>;
+export {};

package/dist/telegram/handlers/message.media-helpers.d.ts

@@ -1,3 +1,4 @@
+import type { Context } from 'telegraf';
 export declare function sniffMimeType(bytes: Buffer): 'image/jpeg' | 'image/png' | 'image/gif' | 'image/webp' | null;
 export type LimitedReadResult = {
     status: 'ok';
@@ -9,3 +10,15 @@ export type LimitedReadResult = {
     status: 'missing-body';
 };
 export declare function readResponseBytesWithLimit(response: Response, maxBytes: number): Promise<LimitedReadResult>;
+export declare const ALLOWED_PHOTO_MIME: readonly ["image/jpeg", "image/png", "image/gif", "image/webp"];
+export type AllowedPhotoMime = typeof ALLOWED_PHOTO_MIME[number];
+export type FetchPhotoResult = {
+    ok: true;
+    bytes: Buffer;
+    media_type: AllowedPhotoMime;
+} | {
+    ok: false;
+};
+type LogFn = (...args: unknown[]) => void;
+export declare function fetchAndClassifyPhoto(ctx: Context, fileId: string, chatId: number, log: LogFn): Promise<FetchPhotoResult>;
+export {};

package/dist/telegram/handlers/message.photo-handler.d.ts

@@ -0,0 +1,22 @@
+import { Context } from 'telegraf';
+import type { ContentBlockParam } from '@anthropic-ai/sdk/resources';
+import { type TelegramRoute } from '../route.js';
+import type { SessionManager } from '../session-manager.js';
+import type { Telegraf } from 'telegraf';
+type LogFn = (...args: unknown[]) => void;
+export interface PhotoHandlerContext {
+    bot: Telegraf;
+    sessionManager: SessionManager;
+    registeredCommandChats: Set<number>;
+    tagOnlyChats: Set<number>;
+    log: LogFn;
+    isClaimed(key: string): boolean;
+    reserveClaim(key: string): void;
+    releaseClaim(key: string): void;
+    enqueuePhoto(route: TelegramRoute, ctx: Context, content: ContentBlockParam[]): number | false;
+    processOne(route: TelegramRoute, ctx: Context, content: ContentBlockParam[]): Promise<void>;
+    MAX_QUEUE_DEPTH: number;
+    messageQueues: Map<string, unknown[]>;
+}
+export declare function handlePhotoImpl(ctx: Context, hc: PhotoHandlerContext): Promise<void>;
+export {};

package/dist/telegram/session-manager.d.ts

@@ -70,7 +70,6 @@ export declare class SessionManager {
         reason: 'not-found' | 'already-active';
     }>;
     newSession(target: RouteTarget): Promise<void>;
-    private sidecarFileName;
     loadSessions(): Promise<void>;
     saveSessions(): Promise<void>;
     private _evictStaleSessionData;

package/dist/telegram/session-manager.disk-io.d.ts

@@ -0,0 +1,5 @@
+import { type TelegramRoute } from './route.js';
+import type { SessionData } from './session-manager.js';
+export declare function sidecarFileName(data: SessionData): string;
+export declare function loadSessionsFromDisk(dataDir: string, sessionData: Map<string, SessionData>, onEachRoute: (route: TelegramRoute, data: SessionData) => void): Promise<void>;
+export declare function saveSessionsToDisk(dataDir: string, sessionData: Map<string, SessionData>): Promise<void>;

package/dist/telegram/session-manager.session-builder.d.ts

@@ -0,0 +1,20 @@
+import type { IAgentSession, AgentConfig, AgentModelInput, ThinkingConfig, EffortLevel } from '../agent/types.js';
+import { type TelegramRoute } from './route.js';
+import type { SessionData } from './session-manager.js';
+export interface SessionBuilderOptions {
+    apiKey: string;
+    settingSources?: ('user' | 'project')[];
+    thinking?: ThinkingConfig;
+    effort?: EffortLevel;
+    botCwd?: string;
+    createSession: (config: AgentConfig) => Promise<IAgentSession>;
+    onResumptionOffer?: (route: TelegramRoute, text: string) => void | Promise<boolean>;
+    defaultModel: AgentModelInput;
+}
+export interface SessionBuilderContext {
+    sessions: Map<string, IAgentSession>;
+    sessionData: Map<string, SessionData>;
+    pendingResume: Map<string, string>;
+    ensureRegistryHandle(route: TelegramRoute, data: SessionData): void;
+}
+export declare function buildAndRegisterSession(route: TelegramRoute, key: string, data: SessionData, opts: SessionBuilderOptions, sc: SessionBuilderContext): Promise<IAgentSession>;

package/dist/telegram/session-manager.switcher.d.ts

@@ -0,0 +1,21 @@
+import type { IAgentSession } from '../agent/types.js';
+import { type TelegramRoute } from './route.js';
+import type { SessionData, ChatSessionInfo, RouteTarget } from './session-manager.js';
+import type { SessionStats } from '../cli/slash/types.js';
+export declare function listChatSessionsImpl(target: RouteTarget, sessionData: Map<string, SessionData>): ChatSessionInfo[];
+export interface SwitcherContext {
+    sessions: Map<string, IAgentSession>;
+    pendingSessions: Map<string, Promise<IAgentSession>>;
+    sessionData: Map<string, SessionData>;
+    sessionStats: Map<string, SessionStats>;
+    autosaveFailureLogged: Set<string>;
+    pendingResume: Map<string, string>;
+    newData(route: TelegramRoute): SessionData;
+}
+export declare function switchToSessionImpl(target: RouteTarget, targetSessionId: string, sc: SwitcherContext): Promise<{
+    ok: true;
+    name?: string;
+} | {
+    ok: false;
+    reason: 'not-found' | 'already-active';
+}>;