sneakoscope 2.0.4 → 2.0.6

package/dist/core/naruto/naruto-work-item.js

@@ -0,0 +1,40 @@
+export const NARUTO_WORK_KINDS = [
+    'implementation',
+    'code_modification',
+    'refactor',
+    'test_generation',
+    'test_execution',
+    'verification',
+    'research',
+    'documentation',
+    'ux_review',
+    'ppt_review',
+    'image_review',
+    'conflict_resolution',
+    'patch_rebase',
+    'rollback_preparation',
+    'integration_support',
+    'final_review_input_pack'
+];
+export const NARUTO_WRITE_WORK_KINDS = new Set([
+    'implementation',
+    'code_modification',
+    'refactor',
+    'test_generation',
+    'documentation',
+    'conflict_resolution',
+    'patch_rebase',
+    'rollback_preparation',
+    'integration_support'
+]);
+export function isNarutoWriteKind(kind) {
+    return NARUTO_WRITE_WORK_KINDS.has(kind);
+}
+export function normalizeNarutoWorkKind(value, fallback = 'verification') {
+    const text = String(value || '');
+    return NARUTO_WORK_KINDS.includes(text) ? text : fallback;
+}
+export function normalizeNarutoPath(value) {
+    return String(value || '').replace(/\\/g, '/').replace(/^\.\/+/, '').split('/').filter((part) => part && part !== '.').join('/');
+}
+//# sourceMappingURL=naruto-work-item.js.map

package/dist/core/naruto/naruto-work-stealing.js

@@ -0,0 +1,11 @@
+export function stealNarutoWork(queue, input = {}) {
+    const item = queue.shift() || null;
+    return {
+        schema: 'sks.naruto-work-stealing.v1',
+        stolen: Boolean(item),
+        work_item_id: item?.id || null,
+        from_queue: input.fromQueue || 'pending',
+        to_slot: input.toSlot || 'idle-slot'
+    };
+}
+//# sourceMappingURL=naruto-work-stealing.js.map

package/dist/core/naruto/resource-pressure-monitor.js

@@ -0,0 +1,32 @@
+export function monitorNarutoResourcePressure(probe, input = {}) {
+    const activeWorkers = Math.max(1, Math.floor(Number(input.activeWorkers || 1)));
+    const zellijCap = Math.max(1, Math.floor(Number(input.zellijVisiblePaneCap || 12)));
+    const memoryPressure = 1 - (probe.free_memory_bytes / Math.max(1, probe.total_memory_bytes));
+    const cpuPressure = Math.min(1, (probe.current_load_average[0] || 0) / Math.max(1, probe.cpu_core_count));
+    const fdPressure = Math.min(1, (activeWorkers * 6 + probe.process_count) / Math.max(1, probe.file_descriptor_limit));
+    const zellijPressure = Math.min(1, probe.zellij_pane_count / zellijCap);
+    const diskIoPressure = probe.disk_io_pressure;
+    const reasons = [
+        ...(memoryPressure > 0.8 ? ['memory_cap'] : []),
+        ...(cpuPressure > 0.9 ? ['cpu_load_cap'] : []),
+        ...(fdPressure > 0.75 ? ['file_descriptor_budget'] : []),
+        ...(zellijPressure > 0.9 ? ['zellij_ui_pane_budget'] : []),
+        ...(diskIoPressure > 0.75 ? ['disk_io_pressure'] : [])
+    ];
+    const maxPressure = Math.max(memoryPressure, cpuPressure, fdPressure, zellijPressure, diskIoPressure);
+    const state = maxPressure >= 0.92 ? 'saturated' : maxPressure >= 0.72 ? 'throttled' : 'normal';
+    return {
+        schema: 'sks.naruto-resource-pressure.v1',
+        state,
+        memory_pressure: round(memoryPressure),
+        cpu_pressure: round(cpuPressure),
+        fd_pressure: round(fdPressure),
+        zellij_pressure: round(zellijPressure),
+        disk_io_pressure: round(diskIoPressure),
+        reasons
+    };
+}
+function round(value) {
+    return Math.round(Math.max(0, Math.min(1, value)) * 1000) / 1000;
+}
+//# sourceMappingURL=resource-pressure-monitor.js.map

package/dist/core/pipeline/finalize-pipeline-result.js

@@ -0,0 +1,58 @@
+import path from 'node:path';
+import { nowIso, writeJsonAtomic } from '../fsx.js';
+import { runGptFinalArbiter } from '../codex-control/gpt-final-arbiter.js';
+import { gptFinalRequiredForPipeline } from './gpt-final-required.js';
+export async function finalizePipelineResult(input) {
+    const cwd = path.resolve(input.cwd || process.cwd());
+    const root = path.resolve(input.mutationLedgerRoot || path.join(cwd, '.sneakoscope', 'tmp', 'pipeline-finalize', safeName(input.missionId)));
+    const requirement = gptFinalRequiredForPipeline({
+        localParticipated: input.localParticipated,
+        candidateResults: input.candidateResults
+    });
+    let arbiter = null;
+    let blockers = [];
+    if (requirement.gpt_final_required) {
+        arbiter = await runGptFinalArbiter({
+            schema: 'sks.gpt-final-arbiter-input.v1',
+            route: input.route,
+            mission_id: input.missionId,
+            local_mode: 'local-parallel-gpt-final',
+            local_outputs: input.candidateResults,
+            candidate_patch_envelopes: input.candidatePatchEnvelopes
+        }, {
+            cwd,
+            mutationLedgerRoot: path.join(root, 'gpt-final-arbiter'),
+            ...(typeof input.forceGptFinalUnavailable === 'boolean' ? { forceUnavailable: input.forceGptFinalUnavailable } : {})
+        });
+        blockers = [
+            ...(arbiter.ok ? [] : ['gpt_final_arbiter_required_not_passed']),
+            ...(Array.isArray(arbiter.blockers) ? arbiter.blockers.map(String) : [])
+        ];
+    }
+    const result = {
+        schema: 'sks.pipeline-finalize-result.v1',
+        generated_at: nowIso(),
+        ok: blockers.length === 0,
+        route: input.route,
+        mission_id: input.missionId,
+        local_participated: requirement.local_participated,
+        gpt_final_required: requirement.gpt_final_required,
+        gpt_final_arbiter: arbiter,
+        final_status: blockers.length ? 'blocked' : 'accepted',
+        apply_allowed: blockers.length === 0 && input.applyPatches === true,
+        final_patch_source: requirement.gpt_final_required ? 'gpt_final_arbiter' : 'deterministic_finalize',
+        candidate_results_count: input.candidateResults.length,
+        candidate_patch_envelope_count: input.candidatePatchEnvelopes.length,
+        verification_results_count: input.verificationResults.length,
+        side_effect_report: input.sideEffectReport,
+        mutation_ledger: input.mutationLedger,
+        rollback_plan: input.rollbackPlan,
+        blockers
+    };
+    await writeJsonAtomic(path.join(root, 'pipeline-finalize-result.json'), result);
+    return result;
+}
+function safeName(value) {
+    return String(value || 'unknown').replace(/[^a-zA-Z0-9_.-]+/g, '-').slice(0, 80);
+}
+//# sourceMappingURL=finalize-pipeline-result.js.map

package/dist/core/pipeline/gpt-final-required.js

@@ -0,0 +1,12 @@
+import { localCollaborationParticipated } from '../local-llm/local-collaboration-policy.js';
+export function gptFinalRequiredForPipeline(input) {
+    const localParticipated = input.localParticipated === true
+        || localCollaborationParticipated(Array.isArray(input.candidateResults) ? input.candidateResults : []);
+    return {
+        schema: 'sks.gpt-final-required.v1',
+        local_participated: localParticipated,
+        gpt_final_required: localParticipated,
+        reason: localParticipated ? 'local_llm_outputs_are_drafts' : 'no_local_participation'
+    };
+}
+//# sourceMappingURL=gpt-final-required.js.map

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

@@ -386,7 +386,7 @@ export function promptPipelineContext(prompt, route = null) {
         skillDreamPolicyText(),
         route?.id === 'PPT'
             ? `${pptPipelineAllowlistPolicyText()} ${getdesignReferencePolicyText()}`
-            : `Design routing: UI/UX reads design.md first; if missing, use design-system-builder from docs/Design-Sys-Prompt.md with plan-tool clarification and a default font recommendation. Existing designs use design-ui-editor plus design-artifact-expert. Image/logo/raster assets use imagegen, which must prefer Codex App built-in image generation documented at ${CODEX_APP_IMAGE_GENERATION_DOC_URL}. ${CODEX_IMAGEGEN_REQUIRED_POLICY} ${getdesignReferencePolicyText()}`,
+            : `Design routing: UI/UX uses the Codex App Product Design plugin first for get-context/user-context, research/ideate, prototype/image-to-code/url-to-code, audit/design-qa, and share when available. Treat design.md, design-system-builder, design-ui-editor, design-artifact-expert, and getdesign-reference as compatibility fallback only when the Product Design plugin is unavailable or an existing local design.md must be preserved. Image/logo/raster assets use imagegen, which must prefer Codex App built-in image generation documented at ${CODEX_APP_IMAGE_GENERATION_DOC_URL}. ${CODEX_IMAGEGEN_REQUIRED_POLICY} ${getdesignReferencePolicyText()}`,
         triwikiContextTrackingText(),
         triwikiStagePolicyText(),
         stackCurrentDocsPolicyText(),

package/dist/core/ppt.js

@@ -2,6 +2,7 @@ import path from 'node:path';
 import fsp from 'node:fs/promises';
 import { nowIso, readJson, sha256, writeJsonAtomic, writeTextAtomic } from './fsx.js';
 import { AWESOME_DESIGN_MD_REFERENCE, CODEX_APP_IMAGE_GENERATION_DOC_URL, CODEX_IMAGEGEN_EVIDENCE_SOURCE, DESIGN_SYSTEM_SSOT, GETDESIGN_REFERENCE, PPT_CONDITIONAL_SKILL_ALLOWLIST, PPT_PIPELINE_MCP_ALLOWLIST, PPT_PIPELINE_SKILL_ALLOWLIST } from './routes.js';
+import { PRODUCT_DESIGN_LEGACY_DESIGN_FALLBACK_SKILLS, PRODUCT_DESIGN_PIPELINE_STAGES, PRODUCT_DESIGN_PLUGIN, PRODUCT_DESIGN_REQUIRED_SKILLS } from './product-design-plugin.js';
 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';
@@ -868,28 +869,48 @@ export function buildPptStyleTokens(contract = {}) {
                 required_skills: [...PPT_PIPELINE_SKILL_ALLOWLIST],
                 conditional_skills: [...PPT_CONDITIONAL_SKILL_ALLOWLIST],
                 allowed_mcp_servers: [...PPT_PIPELINE_MCP_ALLOWLIST],
+                primary_design_plugin: PRODUCT_DESIGN_PLUGIN.id,
+                product_design_tools: [...PRODUCT_DESIGN_REQUIRED_SKILLS],
+                product_design_stage_map: [...PRODUCT_DESIGN_PIPELINE_STAGES],
                 ignore_installed_out_of_pipeline_skills: true,
-                ignored_design_skills_even_if_installed: ['design-artifact-expert', 'design-ui-editor', 'design-system-builder'],
-                anti_ai_design_goal: 'prevent AI-like generic presentation design by forcing decisions through audience, sources, getdesign reference, and the design SSOT instead of freeform decorative design skills',
-                rule: 'PPT design and render work must use only the route allowlist. Installed skills or MCP servers outside this allowlist are ignored unless the sealed PPT contract explicitly activates a conditional entry.'
+                ignored_design_skills_even_if_installed: [...PRODUCT_DESIGN_LEGACY_DESIGN_FALLBACK_SKILLS],
+                anti_ai_design_goal: 'prevent AI-like generic presentation design by forcing decisions through Product Design plugin evidence, audience, sources, and route-local style tokens instead of freeform decorative design skills',
+                rule: 'PPT design and render work must use Product Design plugin first plus only the route allowlist. Installed skills or MCP servers outside this allowlist are ignored unless the sealed PPT contract explicitly activates a conditional entry.'
             },
             design_ssot: {
+                primary_authority: PRODUCT_DESIGN_PLUGIN.id,
                 authority: DESIGN_SYSTEM_SSOT.authority_file,
                 builder_prompt: DESIGN_SYSTEM_SSOT.builder_prompt,
                 route_local_artifact: PPT_STYLE_TOKENS_ARTIFACT,
-                rule: 'PPT style tokens are a route-local projection of the design SSOT; source inputs are selected, fused, and applied here rather than kept as independent authorities.'
+                mode: 'product_design_primary_with_local_fallback_cache',
+                rule: 'PPT style tokens are a route-local projection of Product Design plugin evidence when available; design.md/getdesign fallback inputs are selected, fused, and applied here rather than kept as independent authorities.'
+            },
+            product_design_plugin: {
+                id: PRODUCT_DESIGN_PLUGIN.id,
+                display_name: PRODUCT_DESIGN_PLUGIN.display_name,
+                marketplace: PRODUCT_DESIGN_PLUGIN.marketplace,
+                marketplace_kind: PRODUCT_DESIGN_PLUGIN.marketplace_kind,
+                remote_plugin_id: PRODUCT_DESIGN_PLUGIN.remote_plugin_id,
+                app_server_read_params: PRODUCT_DESIGN_PLUGIN.app_server.read_params,
+                required_skills: [...PRODUCT_DESIGN_REQUIRED_SKILLS],
+                stage_map: [...PRODUCT_DESIGN_PIPELINE_STAGES]
             },
             design_reference_selection: reference,
             source_inputs: [
+                {
+                    id: PRODUCT_DESIGN_PLUGIN.id,
+                    url: PRODUCT_DESIGN_PLUGIN.marketplace,
+                    role: 'primary_codex_app_design_plugin'
+                },
                 {
                     id: GETDESIGN_REFERENCE.id,
                     url: GETDESIGN_REFERENCE.url,
-                    role: 'source_input_for_ssot'
+                    role: 'fallback_source_input_for_ssot'
                 },
                 {
                     id: AWESOME_DESIGN_MD_REFERENCE.id,
                     url: AWESOME_DESIGN_MD_REFERENCE.url,
-                    role: 'source_input_for_ssot'
+                    role: 'fallback_source_input_for_ssot'
                 }
             ],
             avoid: ['over-designed decoration', 'ornamental gradients', 'nested cards', 'low-contrast gray body text', 'excessive motion or effects'],
@@ -1130,13 +1151,15 @@ export function buildPptRenderReport({ contract = {}, audience, sourceLedger, fa
         design_policy_checks: [
             { id: 'information_first', passed: styleTokens.design_policy?.priority === 'information_first' },
             { id: 'restrained_detail', passed: styleTokens.design_policy?.visual_style === 'simple_restrained_detailed' },
-            { id: 'design_ssot_declared', passed: styleTokens.design_policy?.design_ssot?.authority === DESIGN_SYSTEM_SSOT.authority_file },
-            { id: 'curated_design_md_input_fused', passed: (styleTokens.design_policy?.source_inputs || []).some((entry) => entry.url === AWESOME_DESIGN_MD_REFERENCE.url && entry.role === 'source_input_for_ssot') },
+            { id: 'product_design_plugin_declared', passed: styleTokens.design_policy?.product_design_plugin?.id === PRODUCT_DESIGN_PLUGIN.id && (styleTokens.design_policy?.product_design_plugin?.required_skills || []).includes('design-qa') },
+            { id: 'design_ssot_declared', passed: styleTokens.design_policy?.design_ssot?.authority === DESIGN_SYSTEM_SSOT.authority_file && styleTokens.design_policy?.design_ssot?.primary_authority === PRODUCT_DESIGN_PLUGIN.id },
+            { id: 'curated_design_md_input_fused', passed: (styleTokens.design_policy?.source_inputs || []).some((entry) => entry.url === AWESOME_DESIGN_MD_REFERENCE.url && /fallback_source_input/.test(entry.role || '')) },
             { id: 'concrete_design_reference_selected', passed: Boolean(styleTokens.design_policy?.design_reference_selection?.primary?.id && styleTokens.design_policy?.design_reference_selection?.selected_sources?.length) },
             { id: 'reference_rules_applied_to_tokens', passed: Boolean(styleTokens.layout?.composition && styleTokens.layout?.treatment && styleTokens.design_policy?.design_reference_selection?.applied_token_profile) },
             { id: 'html_uses_reference_layout', passed: typeof html === 'string' && html.includes('decision evidence') && html.includes(styleTokens.layout?.composition || 'presentation-grid') },
             { id: 'ppt_skill_allowlist_enforced', passed: JSON.stringify(styleTokens.design_policy?.pipeline_allowlist?.required_skills || []) === JSON.stringify([...PPT_PIPELINE_SKILL_ALLOWLIST]) },
             { id: 'out_of_pipeline_design_skills_ignored', passed: styleTokens.design_policy?.pipeline_allowlist?.ignore_installed_out_of_pipeline_skills === true && (styleTokens.design_policy?.pipeline_allowlist?.ignored_design_skills_even_if_installed || []).includes('design-artifact-expert') },
+            { id: 'legacy_design_skills_fallback_only', passed: styleTokens.design_policy?.pipeline_allowlist?.primary_design_plugin === PRODUCT_DESIGN_PLUGIN.id && (styleTokens.design_policy?.pipeline_allowlist?.ignored_design_skills_even_if_installed || []).includes('design-system-builder') },
             { id: 'ppt_mcp_allowlist_scoped', passed: (styleTokens.design_policy?.pipeline_allowlist?.allowed_mcp_servers || []).every((entry) => entry.mcp === 'context7' && /external_documentation/.test(entry.condition || '')) },
             { id: 'no_decorative_overdesign', passed: !String(html).includes('gradient') },
             { id: 'fact_ledger_embedded', passed: typeof html === 'string' && html.includes('ppt-fact-ledger') },

package/dist/core/product-design-app-server.js

@@ -0,0 +1,410 @@
+import { spawn } from 'node:child_process';
+import { EMPTY_CODEX_INFO, getCodexInfo } from './codex-adapter.js';
+import { PRODUCT_DESIGN_PLUGIN, normalizeProductDesignPluginEvidence } from './product-design-plugin.js';
+export const PRODUCT_DESIGN_AUTO_INSTALL_ENV = 'SKS_PRODUCT_DESIGN_AUTO_INSTALL';
+export function productDesignAutoInstallRequested(opts = {}) {
+    const env = opts.env || process.env;
+    return opts.autoInstallProductDesign === true
+        || opts.installProductDesign === true
+        || opts.requireProductDesign === true
+        || opts.designRoute === true
+        || env?.[PRODUCT_DESIGN_AUTO_INSTALL_ENV] === '1'
+        || /^true$/i.test(String(env?.[PRODUCT_DESIGN_AUTO_INSTALL_ENV] || ''));
+}
+export async function ensureProductDesignPluginInstalled(opts = {}) {
+    const autoInstallProductDesign = productDesignAutoInstallRequested(opts);
+    const injectedRequest = opts.request || opts.appServerRequest;
+    if (injectedRequest) {
+        return ensureProductDesignPluginInstalledWithRequest(injectedRequest, {
+            ...opts,
+            autoInstallProductDesign
+        });
+    }
+    const codex = opts.codex || await getCodexInfo().catch(() => EMPTY_CODEX_INFO);
+    if (!codex.bin) {
+        return productDesignAppServerUnavailable('codex_cli_missing', 'Codex CLI missing.', {
+            autoInstallProductDesign
+        });
+    }
+    const client = new CodexAppServerJsonRpcClient({
+        command: codex.bin,
+        args: opts.appServerArgs || ['app-server', '--stdio'],
+        env: opts.env || process.env,
+        timeoutMs: opts.timeoutMs || 20000,
+        cwd: opts.cwd || process.cwd()
+    });
+    try {
+        await client.initialize();
+        const result = await ensureProductDesignPluginInstalledWithRequest((method, params) => client.request(method, params), {
+            ...opts,
+            autoInstallProductDesign
+        });
+        return {
+            ...result,
+            app_server_command: `${codex.bin} ${(opts.appServerArgs || ['app-server', '--stdio']).join(' ')}`
+        };
+    }
+    catch (err) {
+        return productDesignAppServerUnavailable('product_design_app_server_request_failed', err?.message || String(err), {
+            autoInstallProductDesign,
+            stderr: client.stderr.trim()
+        });
+    }
+    finally {
+        await client.close();
+    }
+}
+export async function ensureProductDesignPluginInstalledWithRequest(request, opts = {}) {
+    const autoInstallProductDesign = productDesignAutoInstallRequested(opts);
+    const calls = [];
+    const errors = [];
+    const call = async (method, params) => {
+        calls.push({ method, params });
+        try {
+            return { ok: true, result: await request(method, params) };
+        }
+        catch (err) {
+            const error = err?.message || String(err);
+            errors.push({ method, params, error });
+            return { ok: false, error };
+        }
+    };
+    const before = await readProductDesignFromAppServer(call);
+    if (before.evidence.ok) {
+        return productDesignEnsureReport({
+            ok: true,
+            status: 'ready',
+            autoInstallProductDesign,
+            installAttempted: false,
+            before,
+            after: before,
+            calls,
+            errors,
+            blockers: []
+        });
+    }
+    if (!autoInstallProductDesign) {
+        return productDesignEnsureReport({
+            ok: false,
+            status: 'install_not_requested',
+            autoInstallProductDesign,
+            installAttempted: false,
+            before,
+            after: before,
+            calls,
+            errors,
+            blockers: uniqueStrings([
+                ...before.evidence.blockers,
+                'product_design_auto_install_not_requested'
+            ])
+        });
+    }
+    const install = await call('plugin/install', before.install_params || PRODUCT_DESIGN_PLUGIN.app_server.install_params);
+    const after = await readProductDesignFromAppServer(call, before.read_params || PRODUCT_DESIGN_PLUGIN.app_server.read_params);
+    let installedListEvidence = null;
+    if (!after.evidence.ok) {
+        const installedList = await call('plugin/installed', {});
+        const summary = installedList.ok ? findProductDesignPluginSummaryFromMarketplaces(installedList.result) : null;
+        if (summary) {
+            installedListEvidence = normalizeProductDesignPluginEvidence({
+                plugin: {
+                    marketplaceName: summary.marketplaceName,
+                    summary,
+                    skills: []
+                }
+            });
+        }
+    }
+    const ok = after.evidence.ok;
+    return productDesignEnsureReport({
+        ok,
+        status: ok ? 'installed' : 'install_unverified',
+        autoInstallProductDesign,
+        installAttempted: true,
+        installResponse: summarizeProductDesignInstallResponse(install.result),
+        installError: install.ok ? null : install.error,
+        before,
+        after,
+        installedListEvidence,
+        calls,
+        errors,
+        blockers: ok ? [] : uniqueStrings([
+            ...after.evidence.blockers,
+            ...(installedListEvidence?.blockers || []),
+            ...(install.ok ? ['product_design_plugin_install_unverified'] : ['product_design_plugin_install_failed'])
+        ])
+    });
+}
+export async function readProductDesignFromAppServer(call, preferredReadParams = PRODUCT_DESIGN_PLUGIN.app_server.read_params) {
+    const direct = await call('plugin/read', preferredReadParams);
+    if (direct.ok) {
+        return {
+            read_source: 'plugin/read',
+            read_params: preferredReadParams,
+            install_params: preferredReadParams,
+            evidence: normalizeProductDesignPluginEvidence(direct.result)
+        };
+    }
+    const list = await call('plugin/list', PRODUCT_DESIGN_PLUGIN.app_server.list_params);
+    const summary = list.ok ? findProductDesignPluginSummaryFromMarketplaces(list.result) : null;
+    const discoveredReadParams = summary
+        ? productDesignAppServerReadParamsFromSummary(summary)
+        : PRODUCT_DESIGN_PLUGIN.app_server.read_params;
+    if (summary) {
+        const discoveredRead = await call('plugin/read', discoveredReadParams);
+        if (discoveredRead.ok) {
+            return {
+                read_source: 'plugin/list+plugin/read',
+                read_params: discoveredReadParams,
+                install_params: discoveredReadParams,
+                evidence: normalizeProductDesignPluginEvidence(discoveredRead.result)
+            };
+        }
+    }
+    const evidence = summary
+        ? normalizeProductDesignPluginEvidence({
+            plugin: {
+                marketplaceName: summary.marketplaceName,
+                summary,
+                skills: []
+            }
+        })
+        : normalizeProductDesignPluginEvidence({});
+    return {
+        read_source: summary ? 'plugin/list_summary' : 'plugin/read_failed',
+        read_params: discoveredReadParams,
+        install_params: discoveredReadParams,
+        evidence: {
+            ...evidence,
+            blockers: uniqueStrings([
+                ...evidence.blockers,
+                'product_design_plugin_read_failed'
+            ])
+        }
+    };
+}
+export function findProductDesignPluginSummaryFromMarketplaces(input = {}) {
+    const marketplaces = Array.isArray(input?.marketplaces) ? input.marketplaces : [];
+    for (const marketplace of marketplaces) {
+        const plugins = Array.isArray(marketplace?.plugins) ? marketplace.plugins : [];
+        for (const plugin of plugins) {
+            const remotePluginId = String(plugin?.remotePluginId || plugin?.remote_plugin_id || '');
+            const id = String(plugin?.id || '');
+            const name = String(plugin?.name || '');
+            const displayName = String(plugin?.displayName || plugin?.display_name || plugin?.interface?.displayName || '');
+            const matches = id === PRODUCT_DESIGN_PLUGIN.id
+                || name === PRODUCT_DESIGN_PLUGIN.name
+                || displayName === PRODUCT_DESIGN_PLUGIN.display_name
+                || remotePluginId === PRODUCT_DESIGN_PLUGIN.remote_plugin_id;
+            if (matches) {
+                return {
+                    ...plugin,
+                    displayName,
+                    marketplaceName: plugin?.marketplaceName || marketplace?.name || PRODUCT_DESIGN_PLUGIN.marketplace,
+                    remotePluginId
+                };
+            }
+        }
+    }
+    return null;
+}
+export function productDesignAppServerReadParamsFromSummary(summary = {}) {
+    return {
+        remoteMarketplaceName: summary.marketplaceName || PRODUCT_DESIGN_PLUGIN.marketplace,
+        pluginName: summary.remotePluginId || summary.remote_plugin_id || PRODUCT_DESIGN_PLUGIN.remote_plugin_id
+    };
+}
+function productDesignEnsureReport(input) {
+    const remoteEvidence = input.after?.evidence || input.before?.evidence || normalizeProductDesignPluginEvidence({});
+    return {
+        schema: 'sks.product-design-app-server-ensure.v1',
+        ok: input.ok,
+        checked: true,
+        status: input.status,
+        auto_install_requested: input.autoInstallProductDesign === true,
+        install_attempted: input.installAttempted === true,
+        install_response: input.installResponse || null,
+        install_error: input.installError || null,
+        before_evidence: input.before?.evidence || null,
+        after_evidence: input.after?.evidence || null,
+        installed_list_evidence: input.installedListEvidence || null,
+        remote_evidence: remoteEvidence,
+        read_source: input.after?.read_source || input.before?.read_source || null,
+        read_params: input.after?.read_params || input.before?.read_params || PRODUCT_DESIGN_PLUGIN.app_server.read_params,
+        install_params: input.before?.install_params || PRODUCT_DESIGN_PLUGIN.app_server.install_params,
+        calls: input.calls || [],
+        errors: input.errors || [],
+        blockers: input.blockers || []
+    };
+}
+function productDesignAppServerUnavailable(reason, error, extra = {}) {
+    const evidence = normalizeProductDesignPluginEvidence({});
+    return {
+        schema: 'sks.product-design-app-server-ensure.v1',
+        ok: false,
+        checked: false,
+        status: 'app_server_unavailable',
+        auto_install_requested: extra.autoInstallProductDesign === true,
+        install_attempted: false,
+        install_response: null,
+        install_error: error,
+        before_evidence: evidence,
+        after_evidence: evidence,
+        installed_list_evidence: null,
+        remote_evidence: evidence,
+        read_source: null,
+        read_params: PRODUCT_DESIGN_PLUGIN.app_server.read_params,
+        install_params: PRODUCT_DESIGN_PLUGIN.app_server.install_params,
+        calls: [],
+        errors: [{ reason, error }],
+        stderr: extra.stderr || '',
+        blockers: uniqueStrings([
+            ...evidence.blockers,
+            reason
+        ])
+    };
+}
+function summarizeProductDesignInstallResponse(result = {}) {
+    if (!result)
+        return null;
+    return {
+        auth_policy: result.authPolicy || result.auth_policy || null,
+        apps_needing_auth: Array.isArray(result.appsNeedingAuth)
+            ? result.appsNeedingAuth.map((app) => ({
+                id: app?.id || null,
+                name: app?.name || app?.displayName || app?.display_name || null
+            }))
+            : []
+    };
+}
+function uniqueStrings(values = []) {
+    return Array.from(new Set(values.filter(Boolean).map((value) => String(value))));
+}
+class CodexAppServerJsonRpcClient {
+    command;
+    args;
+    env;
+    cwd;
+    timeoutMs;
+    child;
+    nextId;
+    pending;
+    stdoutBuffer;
+    stderr;
+    constructor(config = {}) {
+        this.command = config.command;
+        this.args = config.args || ['app-server', '--stdio'];
+        this.env = config.env || process.env;
+        this.cwd = config.cwd || process.cwd();
+        this.timeoutMs = Number(config.timeoutMs || 20000);
+        this.child = null;
+        this.nextId = 1;
+        this.pending = new Map();
+        this.stdoutBuffer = '';
+        this.stderr = '';
+    }
+    async initialize() {
+        this.start();
+        const result = await this.request('initialize', {
+            clientInfo: {
+                name: 'sneakoscope-product-design',
+                title: 'Sneakoscope Product Design Installer',
+                version: '1.0.0'
+            },
+            capabilities: {
+                experimentalApi: true,
+                requestAttestation: false,
+                optOutNotificationMethods: []
+            }
+        });
+        this.notify('notifications/initialized', {});
+        return result;
+    }
+    start() {
+        if (this.child)
+            return;
+        this.child = spawn(this.command, this.args, {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            shell: false,
+            env: this.env,
+            cwd: this.cwd
+        });
+        this.child.stdout?.on('data', (chunk) => this.handleStdout(chunk));
+        this.child.stderr?.on('data', (chunk) => {
+            this.stderr += chunk.toString('utf8');
+            if (this.stderr.length > 64 * 1024)
+                this.stderr = this.stderr.slice(-64 * 1024);
+        });
+        this.child.on('error', (err) => this.rejectAll(err));
+        this.child.on('close', (code) => {
+            this.rejectAll(new Error(`Codex app-server exited before response (code ${code ?? 'signal'}). ${this.stderr.trim()}`.trim()));
+        });
+    }
+    request(method, params) {
+        this.start();
+        const id = this.nextId++;
+        const message = { jsonrpc: '2.0', id, method, params };
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`Codex app-server request timed out: ${method}. ${this.stderr.trim()}`.trim()));
+            }, this.timeoutMs);
+            timer.unref?.();
+            this.pending.set(id, { resolve, reject, timer });
+            this.child?.stdin?.write(`${JSON.stringify(message)}\n`);
+        });
+    }
+    notify(method, params) {
+        this.start();
+        this.child?.stdin?.write(`${JSON.stringify({ jsonrpc: '2.0', method, params })}\n`);
+    }
+    handleStdout(chunk) {
+        this.stdoutBuffer += chunk.toString('utf8');
+        const lines = this.stdoutBuffer.split(/\r?\n/);
+        this.stdoutBuffer = lines.pop() || '';
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            let message;
+            try {
+                message = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (message.id === undefined || !this.pending.has(message.id))
+                continue;
+            const pending = this.pending.get(message.id);
+            if (!pending)
+                continue;
+            this.pending.delete(message.id);
+            clearTimeout(pending.timer);
+            if (message.error)
+                pending.reject(new Error(message.error.message || JSON.stringify(message.error)));
+            else
+                pending.resolve(message.result);
+        }
+    }
+    rejectAll(err) {
+        for (const [id, pending] of this.pending.entries()) {
+            clearTimeout(pending.timer);
+            pending.reject(err);
+            this.pending.delete(id);
+        }
+    }
+    async close() {
+        if (!this.child)
+            return;
+        const child = this.child;
+        this.child = null;
+        try {
+            child.stdin?.end();
+        }
+        catch { }
+        try {
+            child.kill('SIGTERM');
+        }
+        catch { }
+    }
+}
+//# sourceMappingURL=product-design-app-server.js.map