sneakoscope 2.0.5 → 2.0.7

package/dist/core/naruto/naruto-active-pool.js

@@ -1,4 +1,39 @@
 import { createNarutoGeneration, completeNarutoGeneration } from './naruto-generation-scheduler.js';
+export async function runNarutoActivePool(input) {
+    const base = simulateNarutoActivePool(input);
+    const allocations = [];
+    for (const item of input.graph.work_items) {
+        if (!item.write_allowed)
+            continue;
+        const mode = item.worktree?.mode || input.graph.worktree_policy.mode;
+        if (mode !== 'git-worktree') {
+            allocations.push({ work_item_id: item.id, mode, allocation_status: 'skipped', blockers: [] });
+            continue;
+        }
+        if (!input.allocateWorktree) {
+            allocations.push({ work_item_id: item.id, mode, allocation_status: 'planned', blockers: [] });
+            continue;
+        }
+        const allocated = await input.allocateWorktree(item);
+        allocations.push({
+            work_item_id: item.id,
+            mode,
+            allocation_status: allocated.ok ? 'allocated' : 'planned',
+            ...(allocated.worktree_path ? { worktree_path: allocated.worktree_path } : {}),
+            ...(allocated.branch ? { branch: allocated.branch } : {}),
+            blockers: allocated.blockers || []
+        });
+    }
+    const allocationBlockers = allocations.flatMap((row) => row.blockers);
+    return {
+        ...base,
+        ok: base.ok && allocationBlockers.length === 0,
+        worktree_mode: input.graph.worktree_policy.mode,
+        worktree_allocation_required_count: allocations.filter((row) => row.mode === 'git-worktree').length,
+        worktree_allocations: allocations,
+        blockers: [...base.blockers, ...allocationBlockers]
+    };
+}
 export function simulateNarutoActivePool(input) {
     const safeActiveWorkers = Math.max(1, input.governor.safe_active_workers);
     const retryLimit = Math.max(0, Math.floor(Number(input.retryLimit ?? 1)));
@@ -8,18 +43,20 @@ export function simulateNarutoActivePool(input) {
     const completed = new Set();
     const failed = new Set();
     const executed = new Map();
+    const byId = new Map(input.graph.work_items.map((item) => [item.id, item]));
     const timeline = [];
     let generationIndex = 1;
     let tick = 0;
     let refillEvents = 0;
     let maxObserved = 0;
+    let maxObservedWriteLeaseConflicts = 0;
     let conflictItemsEnqueued = 0;
     while (pending.length || active.size) {
         let launched = 0;
         for (;;) {
             if (active.size >= safeActiveWorkers)
                 break;
-            const next = popRunnable(pending, completed, active);
+            const next = popRunnable(pending, completed, active, byId);
             if (!next)
                 break;
             const generation = createNarutoGeneration(next, generationIndex, tick);
@@ -31,6 +68,7 @@ export function simulateNarutoActivePool(input) {
         if (launched)
             refillEvents += launched;
         maxObserved = Math.max(maxObserved, active.size);
+        maxObservedWriteLeaseConflicts = Math.max(maxObservedWriteLeaseConflicts, countActiveWriteLeaseConflicts(active, byId));
         timeline.push({ tick, active: active.size, pending: pending.length, completed: completed.size, event: launched ? 'refill' : 'wait' });
         const done = [...active.values()].slice(0, Math.max(1, Math.ceil(active.size / 2)));
         if (!done.length && pending.length)
@@ -42,7 +80,9 @@ export function simulateNarutoActivePool(input) {
             if (shouldFail) {
                 failed.add(generation.work_item_id);
                 conflictItemsEnqueued += 1;
-                pending.push(conflictResolutionFollowup(generation.work_item_id, input.graph.work_items.length + conflictItemsEnqueued));
+                const followup = conflictResolutionFollowup(generation.work_item_id, input.graph.work_items.length + conflictItemsEnqueued);
+                pending.push(followup);
+                byId.set(followup.id, followup);
             }
             else {
                 completed.add(generation.work_item_id);
@@ -57,6 +97,7 @@ export function simulateNarutoActivePool(input) {
         ...(pending.length ? ['naruto_active_pool_pending_not_drained'] : []),
         ...(active.size ? ['naruto_active_pool_active_not_drained'] : []),
         ...(maxObserved > safeActiveWorkers ? ['naruto_active_pool_exceeded_safe_workers'] : []),
+        ...(maxObservedWriteLeaseConflicts > 0 ? ['naruto_active_pool_overlapping_write_leases'] : []),
         ...(duplicateExecutionCount > conflictItemsEnqueued ? ['naruto_active_pool_duplicate_execution_without_retry'] : [])
     ];
     return {
@@ -70,11 +111,12 @@ export function simulateNarutoActivePool(input) {
         max_observed_active_workers: maxObserved,
         duplicate_execution_count: duplicateExecutionCount,
         conflict_items_enqueued: conflictItemsEnqueued,
+        max_observed_write_lease_conflicts: maxObservedWriteLeaseConflicts,
         timeline,
         blockers
     };
 }
-function popRunnable(pending, completed, active) {
+function popRunnable(pending, completed, active, byId) {
     const activeWorkIds = new Set([...active.values()].map((item) => item.work_item_id));
     for (let index = 0; index < pending.length; index += 1) {
         const item = pending[index];
@@ -85,7 +127,7 @@ function popRunnable(pending, completed, active) {
         if (!item.dependencies.every((dep) => completed.has(dep)))
             continue;
         const writeConflict = [...active.values()].some((generation) => {
-            const activeItem = pending.find((candidate) => candidate.id === generation.work_item_id);
+            const activeItem = byId.get(generation.work_item_id);
             return activeItem?.write_paths.some((file) => item.write_paths.includes(file));
         });
         if (writeConflict)
@@ -95,6 +137,15 @@ function popRunnable(pending, completed, active) {
     }
     return null;
 }
+function countActiveWriteLeaseConflicts(active, byId) {
+    const counts = new Map();
+    for (const generation of active.values()) {
+        const item = byId.get(generation.work_item_id);
+        for (const file of item?.write_paths || [])
+            counts.set(file, (counts.get(file) || 0) + 1);
+    }
+    return [...counts.values()].filter((count) => count > 1).reduce((sum, count) => sum + count - 1, 0);
+}
 function conflictResolutionFollowup(failedId, index) {
     const id = `NW-CONFLICT-${String(index).padStart(4, '0')}`;
     return {

package/dist/core/naruto/naruto-gpt-final-pack.js

@@ -12,6 +12,8 @@ export function buildNarutoGptFinalPack(input) {
         },
         role_distribution: input.roleDistribution,
         changed_files: [...new Set((input.changedFiles || []).map(String))],
+        worktree_policy: input.worktreePolicy || input.graph.worktree_policy,
+        worktree_diffs: (input.worktreeDiffs || []).slice(0, maxPatchEnvelopes).map(redactSecrets),
         patch_envelopes: (input.patchEnvelopes || []).slice(0, maxPatchEnvelopes).map(redactSecrets),
         verification_results: (input.verificationResults || []).slice(0, 200).map(redactSecrets),
         failed_shards: (input.failedShards || []).slice(0, 100).map(redactSecrets),

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

@@ -33,6 +33,13 @@ export function buildNarutoWorkGraph(input = {}) {
     const basePath = normalizeNarutoPath(input.leaseBasePath || '.sneakoscope/naruto/patch-envelopes');
     const targetPaths = normalizePaths(input.targetPaths || []);
     const readonlyPaths = normalizePaths(input.readonlyPaths || []);
+    const worktreePolicy = input.worktreePolicy || {
+        mode: 'patch-envelope-only',
+        required: false,
+        main_repo_root: null,
+        worktree_root: null,
+        fallback_reason: writeCapable ? 'git_capability_not_evaluated' : 'readonly_or_write_disabled'
+    };
     const workItems = [];
     for (let index = 0; index < totalWorkItems; index += 1) {
         const id = `NW-${String(index + 1).padStart(6, '0')}`;
@@ -64,7 +71,14 @@ export function buildNarutoWorkGraph(input = {}) {
                 requires_patch_envelope: writePaths.length > 0,
                 requires_verification: kind !== 'research' && kind !== 'final_review_input_pack',
                 requires_gpt_final: writePaths.length > 0 || kind === 'final_review_input_pack'
-            }
+            },
+            ...(writePaths.length > 0 ? {
+                worktree: {
+                    mode: worktreePolicy.mode,
+                    required: worktreePolicy.required,
+                    allocation_required: worktreePolicy.mode === 'git-worktree'
+                }
+            } : {})
         });
     }
     const activeWaves = planNarutoWorkWaves(workItems, Math.max(1, normalizePositiveInt(input.maxActiveWorkers, requestedClones)));
@@ -88,6 +102,7 @@ export function buildNarutoWorkGraph(input = {}) {
         active_waves: activeWaves,
         mixed_work_kinds: mixedWorkKinds,
         write_allowed_count: writeAllowedCount,
+        worktree_policy: worktreePolicy,
         ok: blockers.length === 0,
         blockers
     };

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') },