sneakoscope 7.0.2 → 7.0.3

package/dist/core/image-ux-review/codex-app-generated-image-discovery.js

@@ -2,12 +2,6 @@ import fs from 'node:fs';
 import fsp from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
-// Codex App (GUI) $imagegen writes generated images to
-// `$CODEX_HOME/generated_images/<session-uuid>/ig_<hash>.png`. There is no
-// sidecar metadata; freshness is mtime-based and the `ig_` prefix marks an
-// image-generation output. This module lets a headless SKS route auto-discover
-// the most recent GUI-generated image instead of requiring the user to attach
-// it manually via SKS_CODEX_APP_IMAGEGEN_OUTPUT.
 export const CODEX_APP_GENERATED_IMAGE_DISCOVERY_SCHEMA = 'sks.codex-app-generated-image-discovery.v1';
 export function codexHomeDir(opts = {}) {
     const env = opts.env || process.env;
@@ -16,16 +10,6 @@ export function codexHomeDir(opts = {}) {
 export function codexAppGeneratedImagesDir(opts = {}) {
     return path.join(codexHomeDir(opts), 'generated_images');
 }
-/**
- * Find the most recent Codex App GUI-generated image (`ig_*.png`).
- *
- * Safety guards so an old, unrelated generation is never mistaken for the
- * current request's output:
- * - `since_ms`: only accept images modified at/after the run's start time
- *   (pass the mission creation time). When omitted, only the max-age guard applies.
- * - `max_age_ms`: reject anything older than this (default 10 min) so a stale
- *   image left in the directory is not silently reused.
- */
 export async function discoverCodexAppGeneratedImage(opts = { nowMs: 0 }) {
     const dir = codexAppGeneratedImagesDir(opts);
     const maxAgeMs = Number.isFinite(opts.maxAgeMs) ? Number(opts.maxAgeMs) : 10 * 60 * 1000;
@@ -102,7 +86,6 @@ async function hasImageSignature(file) {
         const { buffer, bytesRead } = await handle.read(Buffer.alloc(12), 0, 12, 0);
         if (bytesRead < 4)
             return false;
-        // PNG \x89PNG, JPEG \xFF\xD8\xFF, WEBP RIFF....WEBP
         const isPng = buffer[0] === 0x89 && buffer[1] === 0x50 && buffer[2] === 0x4e && buffer[3] === 0x47;
         const isJpeg = buffer[0] === 0xff && buffer[1] === 0xd8 && buffer[2] === 0xff;
         const isWebp = buffer.slice(0, 4).toString('ascii') === 'RIFF' && buffer.slice(8, 12).toString('ascii') === 'WEBP';

package/dist/core/image-ux-review/imagegen-adapter.js

@@ -50,9 +50,6 @@ export function createCodexAppImagegenAdapter(opts = {}) {
         model: 'gpt-image-2',
         available,
         async generateCalloutReview(input) {
-            // Manual attach wins; otherwise auto-discover the most recent Codex App
-            // GUI $imagegen output from ~/.codex/generated_images so the route does not
-            // require the user to pass SKS_CODEX_APP_IMAGEGEN_OUTPUT by hand.
             const manualOutput = opts.outputImagePath || process.env.SKS_CODEX_APP_IMAGEGEN_OUTPUT || null;
             const discovery = !manualOutput && opts.autoDiscoverGeneratedImage !== false
                 ? await discoverCodexAppGeneratedImage({
@@ -412,7 +409,6 @@ export function createOpenAIImagesApiAdapter(opts = {}) {
                             })
                         }, imagegenFetchTimeoutMs(opts));
                         const payload = await readResponsePayload(response, imagegenFetchTimeoutMs(opts));
-                        // Retry on transient HTTP status OR an SSE/JSON server_error/rate_limit payload.
                         return { value: { response, payload }, status: response.ok ? null : response.status, code: payloadRetryCode(payload) };
                     }, imagegenRetryOptions(opts));
                     const { response, payload } = attemptResult;
@@ -567,8 +563,6 @@ export async function generateGptImage2CalloutReview(input, opts = {}) {
         return createFakeImagegenAdapter({ ...(opts.fakeAdapter || {}), mockContext: true }).generateCalloutReview(input);
     }
     const capability = await detectImagegenCapability(opts.capability || {}).catch(() => null);
-    // codex-lb imagegen is a direct API fallback, not Codex App imagegen evidence.
-    // It must be explicitly enabled by the caller or environment.
     const explicitDisableCodexLbFallback = opts.allowCodexLbApiFallback === false || process.env.SKS_IMAGEGEN_ALLOW_CODEX_LB_API_FALLBACK === '0';
     const allowCodexLbApiFallback = !explicitDisableCodexLbFallback && (opts.allowCodexLbApiFallback === true
         || process.env.SKS_IMAGEGEN_ALLOW_CODEX_LB_API_FALLBACK === '1');
@@ -797,9 +791,6 @@ function redactedImagegenResponse(payload, ok, latencyMs, provider = 'openai_ima
         local_only: true
     };
 }
-// Classify a parsed image-API/Responses payload into a retryable error code so a
-// 200-with-server_error SSE body or an `error.code` of rate_limit/overloaded is
-// retried, not just non-2xx HTTP statuses. Returns null when not retryable.
 function payloadRetryCode(payload) {
     if (!payload)
         return null;
@@ -816,17 +807,12 @@ function payloadRetryCode(payload) {
         return 'server_error';
     return null;
 }
-// gpt-image-2 supports an optional `quality` (low|medium|high|auto). Default to
-// 'high' for review callouts so legibility holds; allow override/disable.
 function imagegenQualityParam(opts = {}) {
     const raw = String(opts.quality || process.env.SKS_IMAGEGEN_QUALITY || 'high').trim().toLowerCase();
     if (raw === 'none' || raw === 'off' || raw === '')
         return {};
     return ['low', 'medium', 'high', 'auto'].includes(raw) ? { quality: raw } : { quality: 'high' };
 }
-// Wire imagegen fetches into the centralized responses retry policy: exponential
-// backoff on 429/5xx/timeout and transient network errors, classifying a thrown
-// fetch error (abort/timeout/network) into a retryable code.
 function imagegenRetryOptions(opts = {}) {
     return {
         sleep: opts.retrySleep,

package/dist/core/imagegen/imagegen-auth-readiness.js

@@ -2,11 +2,6 @@ import os from 'node:os';
 import path from 'node:path';
 import { readText } from '../fsx.js';
 import { codexAppGeneratedImagesDir } from '../image-ux-review/codex-app-generated-image-discovery.js';
-// Auth-aware imagegen readiness. The codex-lb / ChatGPT-OAuth path drives the
-// LLM (text) fine, but "the LLM works, therefore images must work" still does
-// not hold: image generation needs a surface that actually exposes the
-// `image_generation` tool. This module reports, per detected auth mode, whether
-// a fully-headless generation path is available and the exact next action.
 export const IMAGEGEN_AUTH_READINESS_SCHEMA = 'sks.imagegen-auth-readiness.v1';
 export async function detectImagegenAuthMode(opts = {}) {
     const env = opts.env || process.env;
@@ -27,7 +22,6 @@ export async function detectImagegenAuthMode(opts = {}) {
                 mode = 'api_key';
         }
         catch {
-            // ignore malformed auth.json; fall through to key-based inference
         }
     }
     if (mode === 'unknown' && openaiApiKeyPresent)
@@ -44,9 +38,6 @@ export async function evaluateImagegenAuthReadiness(opts = {}) {
     const { auth_mode, openai_api_key_present } = await detectImagegenAuthMode(authModeOpts);
     const codexAppBuiltInAvailable = opts.codexAppBuiltInAvailable === true;
     const genDir = codexAppGeneratedImagesDir(opts.codexHome !== undefined ? { codexHome: opts.codexHome, env } : { env });
-    // Fully-headless generation can happen through a direct OpenAI key or through
-    // Codex built-in image_generation when the Codex feature surface exposes it.
-    // Capability is not output proof; real smoke still must verify a file.
     const headlessAutoAvailable = openai_api_key_present || codexAppBuiltInAvailable;
     const availablePaths = [];
     if (openai_api_key_present)

package/dist/core/imagegen/imagegen-capability.js

@@ -161,9 +161,6 @@ async function detectCodexAppImagegen(codexBin, opts = {}) {
     }
     if (!codexBin)
         return { available: false, detector: 'codex_binary_missing', blocker: 'codex_binary_missing', raw: null };
-    // Codex 0.144 exposes `features list` as a stable text table and rejects
-    // `--json`. Read the supported surface once; still accept JSON output if a
-    // future CLI returns it from the plain command.
     const featureRun = await runProcess(codexBin, ['features', 'list'], {
         timeoutMs: opts.timeoutMs || 5000,
         maxOutputBytes: 64 * 1024

package/dist/core/init/managed-skill-install.js

@@ -0,0 +1,42 @@
+import path from 'node:path';
+import os from 'node:os';
+import { ensureDir, sameFilesystemPath } from '../fsx.js';
+import { AUTHORITATIVE_SKS_SKILL_ROOT_REFERENCE } from '../codex-native/sks-skill-paths.js';
+import { installGlobalSkills, installProjectSkills } from './skills.js';
+function mergedStrings(left, right) {
+    return [...new Set([
+            ...(Array.isArray(left) ? left.map(String) : []),
+            ...(Array.isArray(right) ? right.map(String) : [])
+        ])];
+}
+export async function reconcileManagedSkillInstallation(root, home) {
+    const globalSkillHome = path.resolve(home || process.env.HOME || os.homedir());
+    await ensureDir(globalSkillHome);
+    const skillInstall = await installGlobalSkills(globalSkillHome);
+    const globalSkillTarget = path.resolve(globalSkillHome, '.agents', 'skills');
+    const projectSkillTarget = path.resolve(root, '.agents', 'skills');
+    const projectSkillCleanup = await sameFilesystemPath(projectSkillTarget, globalSkillTarget)
+        ? null
+        : await installProjectSkills(root);
+    const created = [];
+    if (projectSkillCleanup) {
+        skillInstall.ok = skillInstall.ok && projectSkillCleanup.ok;
+        skillInstall.warnings = mergedStrings(skillInstall.warnings, projectSkillCleanup.warnings);
+        skillInstall.removed = mergedStrings(skillInstall.removed, projectSkillCleanup.removed);
+        skillInstall.quarantined_user_collisions = mergedStrings(skillInstall.quarantined_user_collisions, projectSkillCleanup.quarantined_user_collisions);
+        skillInstall.removed_stale_generated_skills = mergedStrings(skillInstall.removed_stale_generated_skills, projectSkillCleanup.removed_stale_generated_skills);
+        skillInstall.project_residue_reconcile = projectSkillCleanup;
+        created.push('.agents/skills official residue reconciled');
+    }
+    created.push(`${AUTHORITATIVE_SKS_SKILL_ROOT_REFERENCE}/sks-*`);
+    const removedStaleGeneratedSkills = skillInstall.removed_stale_generated_skills || skillInstall.removed || [];
+    const removedAgentSkillAliases = skillInstall.removed_agent_skill_aliases || [];
+    const removedCodexSkillMirrors = skillInstall.removed_codex_skill_mirrors || [];
+    if (removedStaleGeneratedSkills.length)
+        created.push(`stale generated skills removed (${removedStaleGeneratedSkills.length})`);
+    if (removedAgentSkillAliases.length)
+        created.push(`deprecated generated skill aliases removed (${removedAgentSkillAliases.length})`);
+    if (removedCodexSkillMirrors.length)
+        created.push(`.codex/skills generated mirrors removed (${removedCodexSkillMirrors.length})`);
+    return { skillInstall, created };
+}