sneakoscope 4.8.4 → 4.8.6

package/dist/core/naruto/naruto-real-worker-child.js

@@ -1,7 +1,6 @@
 #!/usr/bin/env node
-import fs from 'node:fs/promises';
 import path from 'node:path';
-import { ensureDir, nowIso, readJson, writeJsonAtomic } from '../fsx.js';
+import { appendJsonlBounded, ensureDir, nowIso, readJson, writeJsonAtomic } from '../fsx.js';
 import { runCodexTask } from '../codex-control/codex-control-plane.js';
 import { CODEX_AGENT_WORKER_RESULT_SCHEMA_ID, codexAgentWorkerResultSchema } from '../codex-control/schemas/agent-worker-result.schema.js';
 async function main() {
@@ -12,12 +11,17 @@ async function main() {
     if (!intake?.result_path || !intake?.heartbeat_path || !intake?.item?.id) {
         throw new Error('naruto worker intake is invalid');
     }
-    await fs.appendFile(intake.heartbeat_path, `${JSON.stringify({
+    const startedAt = Date.now();
+    const maxRuntimeMs = normalizeMaxRuntimeMs(intake.max_runtime_ms);
+    let finished = false;
+    const heartbeatTimer = startDeadmanHeartbeat({ intake, startedAt, maxRuntimeMs, finished: () => finished });
+    await appendJsonlBounded(intake.heartbeat_path, {
         schema: 'sks.naruto-actual-worker-heartbeat.v1',
         ts: nowIso(),
         item_id: intake.item.id,
-        status: 'running'
-    })}\n`);
+        status: 'running',
+        progress: null
+    }, 2 * 1024 * 1024);
     if (intake.backend === 'fake')
         process.env.SKS_CODEX_SDK_FAKE = '1';
     const controlRoot = path.join(path.dirname(intake.result_path), 'codex-control');
@@ -76,14 +80,19 @@ async function main() {
             changed_files: Array.isArray(workerResult?.changed_files) ? workerResult.changed_files : [],
             blockers
         });
-        await fs.appendFile(intake.heartbeat_path, `${JSON.stringify({
+        finished = true;
+        clearInterval(heartbeatTimer);
+        await appendJsonlBounded(intake.heartbeat_path, {
             schema: 'sks.naruto-actual-worker-heartbeat.v1',
             ts: nowIso(),
             item_id: intake.item.id,
-            status: blockers.length ? 'blocked' : 'done'
-        })}\n`);
+            status: blockers.length ? 'blocked' : 'done',
+            progress: { done: 1, total: 1 }
+        }, 2 * 1024 * 1024);
     }
     catch (err) {
+        finished = true;
+        clearInterval(heartbeatTimer);
         await writeJsonAtomic(intake.result_path, {
             schema: 'sks.naruto-actual-worker-result.v1',
             ok: false,
@@ -94,15 +103,62 @@ async function main() {
             worktree_path: intake.worktree_path,
             blockers: [`naruto_actual_worker_control_plane_exception:${err?.message || String(err)}`]
         });
-        await fs.appendFile(intake.heartbeat_path, `${JSON.stringify({
+        await appendJsonlBounded(intake.heartbeat_path, {
             schema: 'sks.naruto-actual-worker-heartbeat.v1',
             ts: nowIso(),
             item_id: intake.item.id,
-            status: 'blocked'
-        })}\n`);
+            status: 'blocked',
+            progress: null
+        }, 2 * 1024 * 1024);
         throw err;
     }
 }
+function startDeadmanHeartbeat(input) {
+    const parsed = Number(process.env.SKS_ZELLIJ_WORKER_PROGRESS_MS || 10000);
+    const intervalMs = Math.max(1000, Number.isFinite(parsed) ? Math.floor(parsed) : 10000);
+    return setInterval(async () => {
+        if (input.finished())
+            return;
+        const elapsedMs = Date.now() - input.startedAt;
+        if (elapsedMs > input.maxRuntimeMs) {
+            await writeJsonAtomic(input.intake.result_path, {
+                schema: 'sks.naruto-actual-worker-result.v1',
+                ok: false,
+                generated_at: nowIso(),
+                item_id: input.intake.item.id,
+                placement: input.intake.placement,
+                backend: input.intake.backend,
+                worktree_path: input.intake.worktree_path,
+                status: 'timed_out',
+                blockers: ['naruto_worker_hard_timeout']
+            }).catch(() => undefined);
+            await appendJsonlBounded(input.intake.heartbeat_path, {
+                schema: 'sks.naruto-actual-worker-heartbeat.v1',
+                ts: nowIso(),
+                item_id: input.intake.item.id,
+                status: 'blocked',
+                elapsed_ms: elapsedMs,
+                progress: null
+            }, 2 * 1024 * 1024).catch(() => undefined);
+            process.exit(124);
+            return;
+        }
+        await appendJsonlBounded(input.intake.heartbeat_path, {
+            schema: 'sks.naruto-actual-worker-heartbeat.v1',
+            ts: nowIso(),
+            item_id: input.intake.item.id,
+            status: 'running',
+            elapsed_ms: elapsedMs,
+            progress: null
+        }, 2 * 1024 * 1024).catch(() => undefined);
+    }, intervalMs);
+}
+function normalizeMaxRuntimeMs(value) {
+    const parsed = Number(value);
+    if (Number.isFinite(parsed) && parsed > 0)
+        return Math.max(1000, Math.min(Math.floor(parsed), 24 * 60 * 60 * 1000));
+    return 10 * 60 * 1000;
+}
 function backendPreference(value) {
     const backend = String(value || '');
     if (backend === 'ollama' || backend === 'local-llm')

package/dist/core/permission-gates.js

@@ -86,29 +86,55 @@ export function madSksCatastrophicDbReasons(cls = {}) {
         blocked.push('dangerous_project_or_branch_management');
     return [...new Set(blocked)];
 }
+export function evaluatePermission({ action, scope, profile, classification, active = false, env = process.env } = {}) {
+    const selectedProfile = normalizePermissionProfile(profile, env);
+    const actionId = String(action || scope || '').trim();
+    const blocked = new Set((selectedProfile.blocked || []).map(String));
+    const allowed = new Set((selectedProfile.allowed || []).map(String));
+    const catastrophic = madSksCatastrophicDbReasons(classification || {});
+    const blockedCategories = [
+        ...(actionId && blocked.has(actionId) ? [actionId] : []),
+        ...catastrophic
+    ];
+    if (!active) {
+        return { matched: false, active: false, allowed: false, action: 'ignore', reasons: ['permission_profile_inactive'], blocked_categories: [], profile: permissionGateSummary(selectedProfile) };
+    }
+    if (blockedCategories.length) {
+        return { matched: true, active: true, allowed: false, action: 'block', reasons: ['permission_profile_blocked_action'], blocked_categories: [...new Set(blockedCategories)], profile: permissionGateSummary(selectedProfile) };
+    }
+    if (actionId && allowed.size > 0 && !allowed.has(actionId)) {
+        return { matched: true, active: true, allowed: false, action: 'block', reasons: ['permission_profile_action_not_allowed'], blocked_categories: [actionId], profile: permissionGateSummary(selectedProfile) };
+    }
+    return { matched: true, active: true, allowed: true, action: 'allow', reasons: ['permission_profile_scoped_allow'], blocked_categories: [], profile: permissionGateSummary(selectedProfile) };
+}
 export function evaluateMadSksPermissionGate({ classification, active = false } = {}) {
     const cls = classification || { level: 'none', reasons: [] };
-    if (!active || !['write', 'destructive'].includes(cls.level))
-        return { matched: false, active: Boolean(active), profile: permissionGateSummary() };
-    const catastrophic = madSksCatastrophicDbReasons(cls);
-    if (catastrophic.length) {
-        return {
-            matched: true,
-            active: true,
-            allowed: false,
-            action: 'block',
-            reasons: ['mad_sks_catastrophic_db_operation_blocked'],
-            blocked_categories: catastrophic,
-            profile: permissionGateSummary()
-        };
+    if (!active || !['write', 'destructive'].includes(cls.level)) {
+        return { matched: false, active: Boolean(active), allowed: false, action: 'ignore', reasons: [], blocked_categories: [], profile: permissionGateSummary() };
     }
+    const decision = evaluatePermission({ action: null, profile: MAD_SKS_PERMISSION_PROFILE, classification: cls, active: true });
     return {
-        matched: true,
-        active: true,
-        allowed: true,
-        action: 'allow',
-        reasons: ['mad_sks_scoped_live_full_access_active'],
-        profile: permissionGateSummary()
+        ...decision,
+        reasons: decision.allowed ? ['mad_sks_scoped_live_full_access_active'] : ['mad_sks_catastrophic_db_operation_blocked']
     };
 }
+function normalizePermissionProfile(profile, env = process.env) {
+    if (profile?.allowed && profile?.blocked)
+        return profile;
+    const configured = loadConfiguredPermissionProfiles(env);
+    const id = typeof profile === 'string' ? profile : profile?.id;
+    return configured.find((row) => row.id === id) || MAD_SKS_PERMISSION_PROFILE;
+}
+function loadConfiguredPermissionProfiles(env = process.env) {
+    const raw = String(env.SKS_PERMISSION_PROFILES_JSON || '').trim();
+    if (!raw)
+        return [];
+    try {
+        const parsed = JSON.parse(raw);
+        return Array.isArray(parsed?.profiles) ? parsed.profiles : Array.isArray(parsed) ? parsed : [];
+    }
+    catch {
+        return [];
+    }
+}
 //# sourceMappingURL=permission-gates.js.map

package/dist/core/pipeline-internals/runtime-gates.js

@@ -1,4 +1,3 @@
-import fsp from 'node:fs/promises';
 import path from 'node:path';
 import { appendJsonl, exists, nowIso, readJson, readText, writeJsonAtomic } from '../fsx.js';
 import { containsUserQuestion, noQuestionContinuationReason } from '../no-question-guard.js';
@@ -72,42 +71,9 @@ async function staleReflectionReasons(root, state = {}, gate = {}) {
     const id = state?.mission_id;
     if (!id)
         return [];
-    const dir = missionDir(root, id);
-    const missing = [];
-    for (const file of gateFilesForState(state).filter((file) => file && !['none', 'honest_mode'].includes(file))) {
-        if (await fileUpdatedAfter(path.join(dir, file), created))
-            missing.push(`${file}:updated_after_reflection`);
-    }
-    const transcript = await readText(path.join(dir, 'team-transcript.jsonl'), '');
-    const newerWorkEvent = transcript
-        .split(/\n/)
-        .filter(Boolean)
-        .map((line) => {
-        try {
-            return JSON.parse(line);
-        }
-        catch {
-            return null;
-        }
-    })
-        .find((event) => {
-        const ts = Date.parse(event?.ts || '');
-        if (!Number.isFinite(ts) || ts <= created)
-            return false;
-        return !/^(REFLECTION|HONEST|TEAM_CLEANUP)$/i.test(String(event?.phase || ''));
-    });
-    if (newerWorkEvent)
-        missing.push('team-transcript.jsonl:work_after_reflection');
-    return missing;
-}
-async function fileUpdatedAfter(file, timeMs) {
-    try {
-        const stat = await fsp.stat(file);
-        return stat.mtimeMs > timeMs + 1000;
-    }
-    catch {
-        return false;
-    }
+    if (state.reflection_invalidation_required !== true)
+        return [];
+    return ['reflection_invalidation_required'];
 }
 function reflectionStopReason(state = {}, status = {}) {
     const id = state?.mission_id || 'latest';
@@ -227,7 +193,7 @@ export async function evaluateStop(root, state, payload, opts = {}) {
         if (gate.ok) {
             const reflection = await reflectionGateStatus(root, state);
             if (!reflection.ok)
-                return complianceBlock(root, state, reflectionStopReason(state, reflection), { gate: 'reflection', missing: reflection.missing });
+                await appendHonestModeNote(root, state, `reflection stale: ${(reflection.missing || []).join(', ')}`);
             return { continue: true };
         }
         const missing = gate.missing?.length ? ` Missing gate fields: ${gate.missing.join(', ')}.` : '';
@@ -250,7 +216,7 @@ export async function evaluateStop(root, state, payload, opts = {}) {
                     return { continue: true, systemMessage: `SKS: canonical stop-gate passed at ${stopCheck.gate_path}` };
             }
             else if (stopCheck.action === 'hard_blocked') {
-                return { continue: true, systemMessage: `SKS: ${stopCheck.feedback}` };
+                return { decision: 'block', reason: stopCheck.feedback, action: 'hard_blocked', gate: stopCheck.gate_path };
             }
             else {
                 const missing = stopCheck.diagnostics.missing_fields?.length ? ` Missing gate fields: ${stopCheck.diagnostics.missing_fields.join(', ')}.` : '';
@@ -304,7 +270,7 @@ async function complianceBlock(root, state = {}, reason = '', detail = {}) {
     const normalized = normalizeComplianceReason(reason);
     const previous = await readJson(guardPath, {});
     const count = previous.normalized_reason === normalized ? Number(previous.repeat_count || 0) + 1 : 1;
-    const limit = complianceLoopLimit();
+    const limit = complianceLoopLimit(detail.gate || state.stop_gate || '');
     const record = {
         schema_version: 1,
         updated_at: nowIso(),
@@ -323,7 +289,9 @@ async function complianceBlock(root, state = {}, reason = '', detail = {}) {
     if (!record.tripped)
         return { decision: 'block', reason, gate: detail.gate || state.stop_gate || null, missing: Array.isArray(detail.missing) ? detail.missing : [] };
     await writeJsonAtomic(path.join(dir, HARD_BLOCKER_ARTIFACT), {
-        passed: true,
+        schema: 'sks.hard-blocker.v1',
+        passed: false,
+        status: 'hard_blocked',
         created_at: nowIso(),
         reason: 'compliance_loop_guard_tripped',
         route: record.route,
@@ -337,10 +305,11 @@ async function complianceBlock(root, state = {}, reason = '', detail = {}) {
         ]
     });
     await appendJsonl(path.join(dir, 'events.jsonl'), { ts: nowIso(), type: 'pipeline.compliance_loop_guard.tripped', gate: record.gate, repeat_count: count, limit });
-    return null;
+    return { decision: 'escalate', reason, gate: detail.gate || state.stop_gate || null, repeat_count: count, message: '동일 사유가 반복됩니다. 사용자 개입이 필요합니다.' };
 }
-function complianceLoopLimit() {
-    const raw = Number.parseInt(process.env.SKS_COMPLIANCE_LOOP_LIMIT || '', 10);
+function complianceLoopLimit(gate = '') {
+    const gateKey = String(gate || '').toUpperCase().replace(/[^A-Z0-9]+/g, '_').replace(/^_+|_+$/g, '');
+    const raw = Number.parseInt(String((gateKey && process.env[`SKS_COMPLIANCE_LOOP_LIMIT_${gateKey}`]) || process.env.SKS_COMPLIANCE_LOOP_LIMIT || ''), 10);
     if (!Number.isFinite(raw))
         return DEFAULT_COMPLIANCE_LOOP_LIMIT;
     return Math.max(1, Math.min(20, raw));
@@ -349,7 +318,6 @@ function normalizeComplianceReason(reason = '') {
     return String(reason || '')
         .replace(/\bM-\d{8}-\d{6}-[a-z0-9]+\b/gi, 'M-*')
         .replace(/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z/g, 'TIMESTAMP')
-        .replace(/\d+/g, 'N')
         .replace(/\s+/g, ' ')
         .trim()
         .slice(0, 1200);
@@ -386,8 +354,21 @@ async function passedHardBlocker(root, state) {
     const blocker = await readJson(path.join(missionDir(root, state.mission_id), file), null);
     if (!blocker)
         return { ok: false };
+    if (String(blocker.status || '') === 'hard_blocked')
+        return { ok: false, file, missing: ['hard_blocked'] };
     return { ok: blocker.passed === true && String(blocker.reason || '').trim() && Array.isArray(blocker.evidence) && blocker.evidence.length > 0, file };
 }
+async function appendHonestModeNote(root, state = {}, message) {
+    if (!state?.mission_id)
+        return;
+    const dir = missionDir(root, state.mission_id);
+    await appendJsonl(path.join(dir, 'honest-mode-notes.jsonl'), {
+        ts: nowIso(),
+        type: 'honest_mode_note',
+        route: state.route_command || state.route || state.mode || null,
+        message
+    });
+}
 function missingRequiredGateFields(file, state, gate = {}) {
     const mode = String(state?.mode || '').toUpperCase();
     if (file === 'team-gate.json' || mode === 'TEAM') {

package/dist/core/ppt/artifacts.js

@@ -0,0 +1,19 @@
+export const PPT_AUDIENCE_STRATEGY_ARTIFACT = 'ppt-audience-strategy.json';
+export const PPT_GATE_ARTIFACT = 'ppt-gate.json';
+export const PPT_SOURCE_LEDGER_ARTIFACT = 'ppt-source-ledger.json';
+export const PPT_FACT_LEDGER_ARTIFACT = 'ppt-fact-ledger.json';
+export const PPT_STORYBOARD_ARTIFACT = 'ppt-storyboard.json';
+export const PPT_STYLE_TOKENS_ARTIFACT = 'ppt-style-tokens.json';
+export const PPT_IMAGE_ASSET_LEDGER_ARTIFACT = 'ppt-image-asset-ledger.json';
+export const PPT_ASSET_DIR = 'assets';
+export const PPT_REVIEW_POLICY_ARTIFACT = 'ppt-review-policy.json';
+export const PPT_REVIEW_LEDGER_ARTIFACT = 'ppt-review-ledger.json';
+export const PPT_ITERATION_REPORT_ARTIFACT = 'ppt-iteration-report.json';
+export const PPT_SOURCE_HTML_DIR = 'source-html';
+export const PPT_HTML_ARTIFACT = `${PPT_SOURCE_HTML_DIR}/artifact.html`;
+export const PPT_PDF_ARTIFACT = 'artifact.pdf';
+export const PPT_RENDER_REPORT_ARTIFACT = 'ppt-render-report.json';
+export const PPT_CLEANUP_REPORT_ARTIFACT = 'ppt-cleanup-report.json';
+export const PPT_PARALLEL_REPORT_ARTIFACT = 'ppt-parallel-report.json';
+export const PPT_TEMP_DIR = 'ppt-tmp';
+//# sourceMappingURL=artifacts.js.map

package/dist/core/ppt/html.js

@@ -0,0 +1,96 @@
+function escapeHtml(value) {
+    return String(value ?? '')
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#39;');
+}
+function jsonScript(value) {
+    return JSON.stringify(value).replace(/</g, '\\u003c');
+}
+export function buildPptHtml({ contract = {}, audience, sourceLedger, factLedger, imageAssetLedger, reviewPolicy, storyboard, styleTokens }) {
+    const title = escapeHtml(storyboard.title);
+    const referenceName = escapeHtml(styleTokens.design_policy?.design_reference_selection?.primary?.name || 'selected design reference');
+    const audienceRaw = escapeHtml(audience?.audience_profile?.raw || 'Audience context');
+    const stpRaw = escapeHtml(audience?.stp?.raw || 'STP context');
+    const decisionRaw = escapeHtml(audience?.decision_context?.raw || storyboard.thesis || '');
+    const surfaceRule = styleTokens.layout?.treatment === 'shadow_as_border_minimal_depth'
+        ? `box-shadow: 0 0 0 1px ${styleTokens.color.rule}; border: 0;`
+        : `border: 1px solid ${styleTokens.color.rule}; box-shadow: none;`;
+    const css = `@page { size: 16in 9in; margin: 0; }
+* { box-sizing: border-box; }
+body { margin: 0; background: ${styleTokens.color.bg}; color: ${styleTokens.color.text}; font-family: ${styleTokens.typography.font_stack}; }
+.page { width: 100vw; min-height: 100vh; page-break-after: always; padding: 64px 88px 54px; display: grid; grid-template-rows: auto 1fr auto; gap: 34px; }
+.topline { display: grid; grid-template-columns: 1fr auto; align-items: end; border-bottom: 1px solid ${styleTokens.color.rule}; padding-bottom: 14px; }
+.kicker { color: ${styleTokens.color.primary}; font-size: ${styleTokens.typography.caption_px}px; font-weight: 600; letter-spacing: 0; text-transform: uppercase; }
+.reference { color: ${styleTokens.color.muted}; font-size: ${styleTokens.typography.caption_px}px; letter-spacing: 0; }
+.content { display: grid; grid-template-columns: minmax(0, 6fr) minmax(320px, 4fr); gap: 58px; align-items: center; }
+h1 { margin: 0; font-size: ${styleTokens.typography.display_px}px; line-height: 1.08; letter-spacing: 0; max-width: 1040px; font-weight: 600; }
+p { margin: 0; color: ${styleTokens.color.muted}; font-size: ${styleTokens.typography.body_px}px; line-height: ${styleTokens.typography.line_height}; max-width: 920px; }
+.claim { display: grid; gap: 26px; }
+.evidence { ${surfaceRule} border-radius: ${styleTokens.layout.radius_px}px; background: ${styleTokens.color.surface}; display: grid; }
+.image-asset { padding: 12px; border-bottom: 1px solid ${styleTokens.color.rule}; }
+.image-asset img { display: block; width: 100%; aspect-ratio: 16 / 9; object-fit: cover; border-radius: ${styleTokens.layout.radius_px}px; }
+.evidence-row { padding: 22px 24px; border-bottom: 1px solid ${styleTokens.color.rule}; }
+.evidence-row:last-child { border-bottom: 0; }
+.label { color: ${styleTokens.color.primary}; font-size: ${styleTokens.typography.caption_px}px; font-weight: 600; letter-spacing: 0; text-transform: uppercase; margin-bottom: 8px; }
+.value { color: ${styleTokens.color.text}; font-size: 20px; line-height: 1.42; }
+.source { display: grid; grid-template-columns: 1fr auto; gap: 24px; color: ${styleTokens.color.muted}; font-size: ${styleTokens.typography.caption_px}px; border-top: 1px solid ${styleTokens.color.rule}; padding-top: 14px; }
+.accent { width: 64px; height: 3px; background: ${styleTokens.color.accent}; }`;
+    const generatedAssets = (imageAssetLedger?.assets || []).filter((asset) => asset.status === 'generated' && asset.html_src);
+    const pages = storyboard.pages.map((page) => {
+        const asset = generatedAssets.find((candidate) => Number(candidate.slide) === Number(page.number));
+        return `<section class="page">
+  <header class="topline">
+    <div class="kicker">${escapeHtml(page.kind)} / ${page.number}</div>
+    <div class="reference">${referenceName}</div>
+  </header>
+  <main class="content">
+    <div class="claim">
+      <div class="accent"></div>
+      <h1>${escapeHtml(page.claim)}</h1>
+      <p>${escapeHtml(page.support)}</p>
+    </div>
+    <aside class="evidence" aria-label="decision evidence">
+      ${asset ? `<div class="image-asset"><img src="${escapeHtml(asset.html_src)}" alt="${escapeHtml(asset.role || 'generated presentation visual')}"></div>` : ''}
+      <div class="evidence-row">
+        <div class="label">Audience</div>
+        <div class="value">${audienceRaw}</div>
+      </div>
+      <div class="evidence-row">
+        <div class="label">STP</div>
+        <div class="value">${stpRaw}</div>
+      </div>
+      <div class="evidence-row">
+        <div class="label">Decision</div>
+        <div class="value">${decisionRaw}</div>
+      </div>
+    </aside>
+  </main>
+  <div class="source">
+    <span>Sources: ${escapeHtml((page.source_ids || []).join(', ') || 'none')}</span>
+    <span>${escapeHtml(styleTokens.layout?.composition || 'presentation-grid')}</span>
+  </div>
+</section>`;
+    }).join('\n');
+    return `<!doctype html>
+<html lang="${styleTokens.typography.language}">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>${title}</title>
+  <style>${css}</style>
+</head>
+<body>
+${pages}
+<script type="application/json" id="ppt-audience-strategy">${jsonScript(audience)}</script>
+<script type="application/json" id="ppt-source-ledger">${jsonScript(sourceLedger)}</script>
+<script type="application/json" id="ppt-fact-ledger">${jsonScript(factLedger || null)}</script>
+<script type="application/json" id="ppt-image-asset-ledger">${jsonScript(imageAssetLedger || null)}</script>
+<script type="application/json" id="ppt-review-policy">${jsonScript(reviewPolicy || null)}</script>
+</body>
+</html>
+`;
+}
+//# sourceMappingURL=html.js.map