stillmade-sdk 0.1.3 → 0.1.5

package/packages/block-platform/project-type-composer.js

@@ -1,3 +1,4 @@
+import {plainBlockDescription} from './plain-descriptions.js';
 import {assert,plain,safeDocument,ROOT_CHAT_ID,stableStringify,valueMatches} from '../block-sdk/contracts.js';
 import {ADAPTERS,validateConnectionAdapter} from '../block-sdk/connection-adapters.js';
 import {STANDARD_SEMANTIC_RELATIONSHIPS} from '../block-sdk/semantic-contracts.js';
@@ -13,6 +14,7 @@ import {validateCondition} from './conditions.js';
 import {projectTypeEventCandidates} from './project-type-events.js';
 import {projectTypeRuleSequence} from './project-type-rules.js';
 import {packageForStage} from './stage-package.js';
+import {normalizeGroups,joinGroupAt,groupOf} from './step-groups.js';
 
 const manifestOf=pkg=>pkg?.manifest || pkg;
 const identity=manifest=>`${manifest.id}@${manifest.version}`;
@@ -286,7 +288,7 @@ export function auditProjectTypeConnections(type,catalog=[],{contextValues=[],re
   catch(error){
     if(!['SEMANTIC','SCHEMA','LIMIT','CYCLE','CONNECTION'].includes(error.code))throw error;
     const reason=String(error.message),message=error.code==='CYCLE'?'These Blocks depend on each other. Change one source to break the loop.':error.code==='CONNECTION'?reason:'These Blocks disagree about the information they use. Choose compatible versions or fix their definitions.';
-    const failed=(type.stages || []).map(stage=>{const manifest=manifestFor(type,stage,available),paused=stage.enabled===false;return {id:stage.id,label:stage.label || manifest?.name || stage.blockId,description:manifest?.description || '',state:paused?'ready':'broken',...(paused?{paused:true}:{contractIssue:{message,reason}}),requirements:[]};});
+    const failed=(type.stages || []).map(stage=>{const manifest=manifestFor(type,stage,available),paused=stage.enabled===false;return {id:stage.id,label:stage.label || manifest?.name || stage.blockId,description:plainBlockDescription(manifest),state:paused?'ready':'broken',...(paused?{paused:true}:{contractIssue:{message,reason}}),requirements:[]};});
     const failures=failed.filter(stage=>!stage.paused).map(stage=>({stageId:stage.id,state:'broken',code:error.code,message:`${stage.label}: ${message}`,reason}));
     return {stages:failed,issues:failures,connections:[],valid:false,ready:false,counts:{blocks:failures.length,requirements:0,missing:failures.length,questions:0},requirementsInspected:false};
   }
@@ -302,14 +304,15 @@ export function auditProjectTypeConnections(type,catalog=[],{contextValues=[],re
   }
   for(const stage of ordered) {
     const manifest=manifestFor(type,stage,available);
-    const row={id:stage.id,label:stage.label || manifest?.name || stage.blockId,description:manifest?.description || '',state:'ready',requirements:[]};
+    const row={id:stage.id,label:stage.label || manifest?.name || stage.blockId,description:plainBlockDescription(manifest),state:'ready',requirements:[]};
     row.connectionIssues=issues.filter(issue=>issue.connectionId && issue.stageId===stage.id);
     stages.push(row);
     if(stage.enabled===false){row.paused=true;if(row.connectionIssues.length)row.state='broken';continue;}
     if(!manifest){row.state='broken';issues.push({stageId:stage.id,message:`${row.label} is unavailable. Choose a Block.`});continue;}
     const stageValues=[...values,...(eventCandidates.get(stage.id) || [])];
     for(const [key,port] of Object.entries(manifest.inputs || {})) {
-      const requirement=normalized(key,port),permissions=manifest.permissions?.project || [];
+      // An input a native host never reads (the original Editor's) cannot be asked for.
+      const requirement=normalized(key,executable(stage,manifest,key)?port:{...port,required:false}),permissions=manifest.permissions?.project || [];
       const requirementResolver=resolver || createUniversalResolver({semantics,adapters:builtinSemanticAdapters(requirement,{permissions,semantics}),requestFromUser:pendingAnswer});
       const edge=declared.find(item=>item.to?.stage===stage.id && item.to.port===key);
       let decision;
@@ -519,7 +522,7 @@ export function chooseProjectTypeConverterRoute(type,{stageId,key,sourceStageId,
   return applyConverterPath(type,stageId,key,candidateId,{stageId:sourceStageId,port:sourceOutputKey},path,catalog);
 }
 
-export function chooseProjectTypeSource(type,stageId,key,candidateId,catalog=[],{semantics,contextValues=[]}={}) {
+export function chooseProjectTypeSource(type,stageId,key,candidateId,catalog=[],{semantics,contextValues=[],experimentalBrowser,experimentalNative}={}) {
   assert(typeof candidateId==='string' && candidateId.length<=2000,'CONNECTION','Choose one current source.');
   semantics ||= semanticRegistryForManifests((type.stages || []).filter(stage=>stage.enabled!==false).map(stage=>manifestFor(type,stage,[...catalog,...(type.packages || [])])));
   const converterSearch=candidateId.startsWith('["block-conversion')?{stageId,key}:undefined;
@@ -538,7 +541,7 @@ export function chooseProjectTypeSource(type,stageId,key,candidateId,catalog=[],
   const match=validateConnectionAdapter(producer.outputs[source.port],consumer.inputs[key],{permissions:consumer.permissions?.project || [],semantics,...(candidate.adapter?{adapter:{id:candidate.adapter.id,version:Number(candidate.adapter.version)}}:{})});
   const removed=(type.connections||[]).filter(edge=>edge.to.stage===stageId&&edge.to.port===key);
   const next=detachUnusedConverterBranches(type,{...type,stages:type.stages.map(stage=>stage.id===stageId?withoutInputSetting(stage,key):stage),connections:[...(type.connections || []).filter(edge=>edge.to.stage!==stageId || edge.to.port!==key),{from:{stage:source.stageId,port:source.port},to:{stage:stageId,port:key},...(match.adapter?{adapter:match.adapter}:{})}]},removed);
-  const validation=validateProjectTypeDraft(next,catalog);
+  const validation=validateProjectTypeDraft(next,catalog,{experimentalBrowser,experimentalNative});
   assert(validation.valid,'PROJECT_TYPE',validation.errors.map(error=>error.message).join(' '));
   return next;
 }
@@ -613,17 +616,17 @@ export function setProjectTypeLoop(type,loopId,loop,catalog=[]) {
   return next;
 }
 
-export function removeProjectTypeConnection(type,connectionId,catalog=[]) {
+export function removeProjectTypeConnection(type,connectionId,catalog=[],options={}) {
   assert(typeof connectionId==='string' && connectionId.length<=2000,'CONNECTION','Choose an inspected connection.');
   const removed=(type.connections||[]).filter(edge=>stableStringify(edge)===connectionId);
   const connections=(type.connections || []).filter(edge=>stableStringify(edge)!==connectionId);
   assert(connections.length<(type.connections || []).length,'CONNECTION','This connection changed. Inspect the current flow again.');
-  const next=detachUnusedConverterBranches(type,{...type,connections},removed),validation=validateProjectTypeDraft(next,catalog);
+  const next=detachUnusedConverterBranches(type,{...type,connections},removed),validation=validateProjectTypeDraft(next,catalog,options);
   assert(validation.valid,'PROJECT_TYPE',validation.errors.map(error=>error.message).join(' '));
   return next;
 }
 
-export function editProjectTypeDraft(type,action,catalog=[]) {
+export function editProjectTypeDraft(type,action,catalog=[],options={}) {
   const available=[...catalog,...(type.packages || [])];
   let next={...type,stages:[...type.stages],connections:[...(type.connections || [])]};
   const index=type.stages.findIndex(stage=>stage.id===action.stageId);
@@ -666,6 +669,7 @@ export function editProjectTypeDraft(type,action,catalog=[]) {
     } else {
       assert(Number.isInteger(action.index) && action.index>=0 && action.index<=next.stages.length,'STEP','Choose a place in the flow.');
       next.stages.splice(action.index,0,replacement);
+      next=joinGroupAt(next,replacement.id,action.index);
     }
   } else if(action.kind==='set-enabled') {
     assert(typeof action.enabled==='boolean','STEP','Choose whether this Block is enabled.');
@@ -676,6 +680,7 @@ export function editProjectTypeDraft(type,action,catalog=[]) {
     assert(manifest,'MISSING_BLOCK','The pinned Block package is missing.');
     const copy={...structuredClone(stage),id:action.id || `step-${crypto.randomUUID().slice(0,12)}`,label:`${stage.label || manifest.name} copy`.slice(0,120)};
     next.stages.splice(index+1,0,copy);
+    next=joinGroupAt(next,copy.id,index+1);
     next.connections.push(...(type.connections || []).filter(edge=>edge.to.stage===stage.id).map(edge=>({...structuredClone(edge),to:{...edge.to,stage:copy.id}})));
   } else if(action.kind==='remove') {
     next.stages.splice(index,1);
@@ -683,12 +688,16 @@ export function editProjectTypeDraft(type,action,catalog=[]) {
     if(next.rules)next.rules=next.rules.filter(rule=>rule.stepId!==stage.id && rule.endStepId!==stage.id);
     if(next.loops)next.loops=next.loops.filter(loop=>loop.startStepId!==stage.id && loop.endStepId!==stage.id && loop.definition.until?.stage!==stage.id && !loop.definition.feedback.some(edge=>edge.from.stage===stage.id || edge.to.stage===stage.id));
   } else if(action.kind==='move') {
-    assert(Number.isInteger(action.index) && action.index>=0 && action.index<next.stages.length,'STEP','Choose a place in the flow.');
-    next.stages.splice(index,1);next.stages.splice(action.index,0,stage);
+    // action.job moves every part of the Step group the Block belongs to.
+    const parts=action.job&&groupOf(type,stage.id)?.stages||[stage.id];
+    const moving=next.stages.filter(item=>parts.includes(item.id)),rest=next.stages.filter(item=>!parts.includes(item.id));
+    assert(Number.isInteger(action.index) && action.index>=0 && action.index<=rest.length,'STEP','Choose a place in the flow.');
+    rest.splice(action.index,0,...moving);next.stages=rest;
   } else assert(false,'STEP','Choose a supported edit.');
+  next=normalizeGroups(next);
   const validationCatalog=catalog.filter(item=>!next.packages?.some(pkg=>identity(pkg.manifest)===identity(manifestOf(item))));
-  next=connectProjectType(next,validationCatalog);
-  const validation=validateProjectTypeDraft(next,validationCatalog);
+  next=normalizeGroups(connectProjectType(next,validationCatalog,options));
+  const validation=validateProjectTypeDraft(next,validationCatalog,options);
   assert(validation.valid,'PROJECT_TYPE',validation.errors.map(error=>error.message).join(' '));
   return next;
 }

package/packages/block-platform/project-type-draft.js

@@ -4,11 +4,11 @@ import {validateProjectType} from './project-types.js';
 import {validateProjectTypeRules} from './project-type-rules.js';
 import {validateProjectTypeLoops} from './project-type-loops.js';
 
-export function validateProjectTypeDraft(type,catalog=[]) {
+export function validateProjectTypeDraft(type,catalog=[],{experimentalBrowser,experimentalNative}={}) {
   try {
     safeDocument(type);assert(plain(type),'PROJECT_TYPE','Expected a Project Type draft.');
     const structuralType={...type,connections:[]};delete structuralType.rules;delete structuralType.loops;
-    const structure=validateProjectType(structuralType,catalog,{allowEmpty:true,semantics:createSemanticRegistry()});
+    const structure=validateProjectType(structuralType,catalog,{allowEmpty:true,semantics:createSemanticRegistry(),experimentalBrowser,experimentalNative});
     if(!structure.valid)return structure;
     assert(type.connections===undefined || Array.isArray(type.connections) && type.connections.length<=500,'CONNECTION','Expected at most 500 connections.');
     for(const edge of type.connections || []) {

package/packages/block-platform/project-type-recommendations.js

@@ -324,5 +324,5 @@ export function recommendProjectTypeCombinations({goal,requirements,handoffRequi
     });
   };
   const missingHandoffProducers=handoffs.filter(handoff=>!available.some(candidate=>resultSlotsForManifest(candidate.manifest).some(slot=>!slot.viaAction&&semanticCompatibility(slot.contract,handoff.from,semantics).compatible))).map(handoff=>({...handoff.from,key:`${handoff.key}_producer`,required:true,description:`Block output needed for ${handoff.description}`}));
-  return {goal,requirements:wanted,sourceMaterials:supplied,resultPins,handoffRequirements:handoffs,executionDevices,combinations:results.map(result=>({...result,transformationPlan:transformationPlan(result),blocks:result.keys.map((key,index)=>{const candidate=catalog.get(key);return {key,identity:listingIdentity({kind:'block',id:candidate.release?.entityId||(candidate.origin==='built-in'?candidate.manifest.id:null),version:candidate.manifest.version,digest:candidate.release?.digest||candidate.sourceDigest}),id:candidate.manifest.id,version:candidate.manifest.version,name:candidate.manifest.name,description:candidate.manifest.description,reasons:explainBlock(candidate,index,result),origin:candidate.origin || 'catalog',...(candidate.release?{release:candidate.release}:{}),...(candidate.sourceDigest?{sourceDigest:candidate.sourceDigest}:{})};})})),missingCapabilities:[...wanted.filter(requirement=>!available.some(candidate=>covers(candidate.manifest,requirement))),...missingHandoffProducers],search:{evaluations,truncated:evaluations>=maxEvaluations,maxSteps},executionVerified:false};
+  return {goal,requirements:wanted,sourceMaterials:supplied,resultPins,handoffRequirements:handoffs,executionDevices,combinations:results.map(result=>({...result,transformationPlan:transformationPlan(result),blocks:result.keys.map((key,index)=>{const candidate=catalog.get(key);return {key,identity:listingIdentity({kind:'block',id:candidate.release?.entityId||(candidate.origin==='built-in'?candidate.manifest.id:null),version:candidate.manifest.version,digest:candidate.release?.digest||candidate.sourceDigest}),id:candidate.manifest.id,version:candidate.manifest.version,name:candidate.manifest.name,description:candidate.manifest.description,reasons:explainBlock(candidate,index,result),origin:candidate.origin || 'catalog',...(candidate.manifest.permissions?.capabilities?.includes('connection.execute')?{connected:true}:{}),...(candidate.release?{release:candidate.release}:{}),...(candidate.sourceDigest?{sourceDigest:candidate.sourceDigest}:{})};})})),missingCapabilities:[...wanted.filter(requirement=>!available.some(candidate=>covers(candidate.manifest,requirement))),...missingHandoffProducers],search:{evaluations,truncated:evaluations>=maxEvaluations,maxSteps},executionVerified:false};
 }

package/packages/block-platform/project-types.js

@@ -13,7 +13,9 @@ import { validatePackage } from '../block-sdk/testing.js';
 import {semanticRegistryForManifests} from '../block-sdk/package-semantics.js';
 import {isBrowserApplication,experimentalBrowserSource} from './experimental-browser-context.js';
 import {packageForStage} from './stage-package.js';
-export function validateProjectType(type, catalog, {allowEmpty=false,semantics,experimentalBrowser}={}) {
+import {validateStepGroups} from './step-groups.js';
+import {isNativeApplicationPackage,nativeApplicationValidationSource} from './native-application-validation-context.js';
+export function validateProjectType(type, catalog, {allowEmpty=false,semantics,experimentalBrowser,experimentalNative}={}) {
   const errors = [];
   try {
     safeDocument(type);
@@ -24,7 +26,7 @@ export function validateProjectType(type, catalog, {allowEmpty=false,semantics,e
     validateProjectOutcome(type.outcome);
     assert(type.acceptanceCriteria===undefined||Array.isArray(type.acceptanceCriteria)&&type.acceptanceCriteria.length<=24&&new Set(type.acceptanceCriteria.map(item=>item.key)).size===type.acceptanceCriteria.length&&type.acceptanceCriteria.every(item=>plain(item)&&Object.keys(item).length===3&&typeof item.key==='string'&&/^[a-z][a-z0-9_]{0,63}$/.test(item.key)&&typeof item.description==='string'&&item.description.trim().length>=3&&item.description.length<=240&&['artifact-inspection','workflow-receipt','human-review'].includes(item.verification)),'PROJECT_TYPE','Result checks must be distinct, bounded and unverified until a real result is inspected.');
     assert(plain(type) && type.schemaVersion === 1 && ID.test(type.id || '') && VERSION.test(type.version || ''), 'PROJECT_TYPE', 'Invalid project type identity');
-    assert(Object.keys(type).every(k => ['schemaVersion', 'id', 'version', 'name', 'description', 'stages', 'connections', 'legacyMode', 'summary', 'packages', 'provenance','license','defaults','onboarding','outcome','rules','loops','projectInputs','startingChat','acceptanceCriteria','goalSourceMaterials','goalSourceInputs'].includes(k)), 'ROOT_PROTECTED', 'Project type contains unsupported settings');
+    assert(Object.keys(type).every(k => ['schemaVersion', 'id', 'version', 'name', 'description', 'stages', 'connections', 'legacyMode', 'summary', 'packages', 'provenance','license','defaults','onboarding','outcome','rules','loops','projectInputs','startingChat','acceptanceCriteria','goalSourceMaterials','goalSourceInputs','groups'].includes(k)), 'ROOT_PROTECTED', 'Project type contains unsupported settings');
     assert(type.startingChat === undefined || type.startingChat === 'native', 'ROOT_PROTECTED', 'Starting Chat is provided by StillMade.');
     allowEmpty = allowEmpty || type.startingChat === 'native';
     assert(type.license === undefined || typeof type.license === 'string' && type.license.length > 0 && type.license.length <= 200,'LICENSE','Use a bounded license identifier');
@@ -32,7 +34,8 @@ export function validateProjectType(type, catalog, {allowEmpty=false,semantics,e
     const available = [...catalog], identities = new Set(catalog.map(b => `${(b.manifest || b).id}@${(b.manifest || b).version}`));
     const embedded = new Set();
     for (const pkg of type.packages || []) {
-      if(isBrowserApplication(pkg))experimentalBrowserSource(experimentalBrowser,pkg);
+      if(isNativeApplicationPackage(pkg))nativeApplicationValidationSource(experimentalNative,pkg);
+      else if(isBrowserApplication(pkg))experimentalBrowserSource(experimentalBrowser,pkg);
       else validatePackage(pkg);
       const key = `${pkg.manifest.id}@${pkg.manifest.version}`;
       const known = catalog.find(block => `${(block.manifest || block).id}@${(block.manifest || block).version}` === key);
@@ -54,7 +57,8 @@ export function validateProjectType(type, catalog, {allowEmpty=false,semantics,e
       assert(block, 'MISSING_BLOCK', `Missing or ambiguous ${stage.blockId}@${stage.version}`);
       const manifest=block.manifest || block;
       if(['browser-application','native-application'].includes(manifest.runtime)){
-        experimentalBrowserSource(experimentalBrowser,block);
+        if(isNativeApplicationPackage(block))nativeApplicationValidationSource(experimentalNative,block);
+        else experimentalBrowserSource(experimentalBrowser,block);
         assert(!stage.failurePolicy&&!stage.condition,'BROWSER_APPLICATION_APPROVAL','Experimental application Steps require a direct operation without failure automation or bypass.');
         assert(!type.loops?.length&&!type.rules?.length,'BROWSER_APPLICATION_APPROVAL','Experimental application workflows cannot declare automatic rules or loops.');
       }
@@ -66,6 +70,7 @@ export function validateProjectType(type, catalog, {allowEmpty=false,semantics,e
       stages.set(stage.id, manifest);
     }
     assert(allowEmpty&&type.stages.length===0||type.stages.some(stage=>stage.enabled !== false),'STEP','Keep at least one enabled step');
+    validateStepGroups(type,stages);
     validateProjectTypeRules(type,available);
     validateProjectTypeLoops(type);
     semantics ||= semanticRegistryForManifests([...stages.values()]);

package/packages/block-platform/revenue-review-project-types.js

@@ -1,15 +1,16 @@
 // Published Type releases embed exact Block releases. Never import a Block's
 // floating current package here: a newer Block release would silently rewrite
-// these immutable Type versions. Adopt a newer Block in a new Type version.
-import shortForm from '../../blocks/short-form-finish/versions/1.0.1/package.js';
-import occasion from '../../blocks/occasion-story/versions/1.0.1/package.js';
-import release from '../../blocks/release-visuals/versions/1.0.1/package.js';
+// these immutable Type versions. Adopt a newer Block in a new Type version
+// (1.0.3 adopted the releases that confirm media rights once at sign-up).
+import shortForm from '../../blocks/short-form-finish/versions/1.0.3/package.js';
+import occasion from '../../blocks/occasion-story/versions/1.0.2/package.js';
+import release from '../../blocks/release-visuals/versions/1.0.2/package.js';
 import editor from '../../blocks/native/sm.editor/versions/2.2.9/package.js';
 
 // Production workspaces accept original media through their declared SDK ports.
 // No special shell branches, hidden provider spending or fixture media in config.
 function type(key,name,description,pkg,config,brief){return Object.freeze({
- schemaVersion:1,id:'stillmade.'+key,version:'1.0.2',name,description,license:'MIT',startingChat:'native',
+ schemaVersion:1,id:'stillmade.'+key,version:'1.0.3',name,description,license:'MIT',startingChat:'native',
  summary:{text:description,origin:'human',generation:'authored',status:'ready'},
  defaults:{aspectRatio:config.aspect,brief},onboarding:[],packages:[pkg,editor].map(p=>structuredClone(p)),
  stages:[{id:'make',blockId:pkg.manifest.id,version:pkg.manifest.version,label:name,config},{id:'finish',blockId:editor.manifest.id,version:editor.manifest.version,label:'Editor',config:{commit:true,renderFps:30,renderResolution:1080,renderQuality:'high'}}],

package/packages/block-platform/segment-runner.js

@@ -23,14 +23,23 @@ import {pinCurrentSemanticSource,pinExplicitFlowSource,assertCurrentSemanticSour
 import {workflowDependencyOrder} from './workflow-dependency-order.js';
 import {USER_REQUEST_LIMIT,userRequestRequirement,chatRequestRequirement,checkedUserRequestAnswer} from '../block-sdk/interactive-requirements.js';
 import {validateWorkflowApproval} from '../block-sdk/workflow-approvals.js';
+import {groupOf} from './step-groups.js';
 import {UNATTENDED_HOSTED_OPERATIONS} from './unattended.js';
 export {UNATTENDED_HOSTED_OPERATIONS};
 
 const runtimes=new Set(['recipe','javascript']);
 const remoteRuntime=runtime=>['capability','comfyui'].includes(runtime);
 // Remote Steps that may run in an unattended plan: granted connection actions
-// and granted hosted operations.
-const unattendedConnection=pkg=>pkg?.manifest?.runtime==='capability'&&(pkg.capability?.operation==='connection.execute'||UNATTENDED_HOSTED_OPERATIONS.includes(pkg.capability?.operation));
+// and granted hosted operations. AI text and image generation are the exception:
+// they run on their own only when the schedule approved a credit cap for them
+// (below); otherwise a scheduled run stops before them for the owner.
+const scheduleApprovedOperation=pkg=>['text.generate','image.generate'].includes(pkg?.capability?.operation);
+const unattendedConnection=pkg=>pkg?.manifest?.runtime==='capability'&&(pkg.capability?.operation==='connection.execute'||UNATTENDED_HOSTED_OPERATIONS.includes(pkg.capability?.operation)&&!scheduleApprovedOperation(pkg));
+// Hosted text and image generation also join when the schedule approved a per-run
+// credit cap for them (unattendedText / unattendedImage).
+const textGeneration=pkg=>pkg?.manifest?.runtime==='capability'&&pkg.capability?.operation==='text.generate';
+const imageGeneration=pkg=>pkg?.manifest?.runtime==='capability'&&pkg.capability?.operation==='image.generate';
+const unattendedStep=(pkg,plan)=>unattendedConnection(pkg)||plan?.unattendedText===true&&textGeneration(pkg)||plan?.unattendedImage===true&&imageGeneration(pkg);
 const hasInteractiveRequirements=pkg=>Object.values(pkg?.manifest.inputs || {}).some(port=>port.semantic && !port.context && (!port.sources || port.sources.includes('user') || port.sources.includes('chat')));
 const edgeKey=edge=>stableStringify({source:edge.source,target:edge.target,sourceHandle:edge.sourceHandle,targetHandle:edge.targetHandle,adapter:edge.data?.stillmadeAdapter ?? null});
 function frozen(value){if(value && typeof value==='object'){Object.freeze(value);for(const child of Object.values(value))frozen(child);}return value;}
@@ -44,10 +53,12 @@ function localDependencyOrder(placements,type) {
 }
 
 /** Capture the production definition and current placement settings, never fixtures. */
-export async function planSegment(projectType,canvas,startStepId,{interactive=false,background=false,unattended=false,endStepId,includeIndependent=false,reuseCurrentSources=false,batchUpdate=false,hostedUpdate=false,experimentalBrowser,applicationOperations={}}={}) {
+export async function planSegment(projectType,canvas,startStepId,{interactive=false,background=false,unattended=false,unattendedText=false,unattendedImage=false,endStepId,includeIndependent=false,reuseCurrentSources=false,batchUpdate=false,hostedUpdate=false,experimentalBrowser,experimentalBrowserValidation,applicationOperations={}}={}) {
  if(experimentalBrowser!==undefined)assertExperimentalBrowserExecutionAuthority(experimentalBrowser);
  assert(!(interactive&&background),'SEGMENT_APPROVAL','Choose interactive or background execution');
  assert(typeof unattended==='boolean'&&(!unattended||background&&!interactive&&!includeIndependent&&!reuseCurrentSources),'SEGMENT_APPROVAL','Unattended actions require the explicit background connection host.');
+ assert(typeof unattendedText==='boolean'&&(!unattendedText||unattended),'SEGMENT_APPROVAL','Unattended text generation requires an unattended background host.');
+ assert(typeof unattendedImage==='boolean'&&(!unattendedImage||unattended),'SEGMENT_APPROVAL','Unattended image generation requires an unattended background host.');
  assert(typeof includeIndependent==='boolean' && (!includeIndependent || interactive && !background),'SEGMENT_APPROVAL','Independent Steps require an explicit interactive workflow run');
  assert(typeof reuseCurrentSources==='boolean' && (!reuseCurrentSources || interactive && !background && !includeIndependent && endStepId===startStepId),'SEGMENT_APPROVAL','Reusing current sources requires an interactive single-Step update.');
  assert(typeof batchUpdate==='boolean' && (!batchUpdate || reuseCurrentSources),'SEGMENT_APPROVAL','A batch update needs an explicit current-source update plan.');
@@ -56,22 +67,32 @@ export async function planSegment(projectType,canvas,startStepId,{interactive=fa
  safeDocument(operations);assert(plain(operations),'BROWSER_APPLICATION_OPERATION','Select application operations by Step ID.');
  safeDocument(type);assert(plain(graph) && Array.isArray(graph.nodes) && Array.isArray(graph.edges),'SEGMENT_CANVAS','A saved production Canvas is required');
  if(graph.projectType)assert(stableStringify(graph.projectType)===stableStringify(type),'SEGMENT_CHANGED','The workflow and Canvas definitions differ');
- const compiled=await compileTypeWorkspace(type,{experimentalBrowser}),active=type.stages.filter(step=>step.enabled!==false),start=active.findIndex(step=>step.id===startStepId);
+ const compiled=await compileTypeWorkspace(type,{experimentalBrowser:experimentalBrowser ?? experimentalBrowserValidation}),active=type.stages.filter(step=>step.enabled!==false);
+ // One Step per job: with no explicit range, an interactive run from any part
+ // of a Step group runs that whole job, from its first enabled part to its last.
+ const job=interactive&&!includeIndependent&&endStepId===undefined?groupOf(type,startStepId):null,jobParts=job?active.filter(step=>job.stages.includes(step.id)).map(step=>step.id):[];
+ if(jobParts.length){startStepId=jobParts[0];endStepId=jobParts.at(-1);}
+ const start=active.findIndex(step=>step.id===startStepId);
  assert(start>=0,'SEGMENT_STEP','Choose an enabled starting Step');
  const end=endStepId===undefined?active.length-1:active.findIndex(step=>step.id===endStepId);
  assert(end>=start,'SEGMENT_STEP','The execution range must end at an enabled Step at or after its start');
  const steps=[],selected=new Set();let nextStageId=null,stopReason='complete';
- const placements=active.slice(start,end+1);
+ let placements=active.slice(start,end+1);
+ // A source-only context can describe upstream applications, never run them.
+ if(experimentalBrowser===undefined){const boundary=placements.findIndex(step=>isBrowserApplication(packageForStage(type,step)));if(boundary>=0){nextStageId=placements[boundary].id;stopReason='runtime-approval';placements=placements.slice(0,boundary);}}
  const applicationPlacements=placements.filter(step=>isBrowserApplication(packageForStage(type,step)));
  assert(!applicationPlacements.length||interactive&&!background&&!includeIndependent&&!reuseCurrentSources&&!batchUpdate&&!hostedUpdate,'BROWSER_APPLICATION_APPROVAL','Application operations require an interactive connected run without batch, independent or source-reuse modes.');
  assert(Object.keys(operations).every(id=>applicationPlacements.some(step=>step.id===id)),'BROWSER_APPLICATION_OPERATION','Operations must belong to selected application Steps.');
  const executionOrder=includeIndependent?localDependencyOrder(placements,type):placements;
+ // A When Block starts an automation: every Step after it runs, in order, even
+ // one that only uses its own settings (such as an app task listing new leads).
+ const automationRoot=packageForStage(type,placements[0])?.manifest.id==='sm.when';
  for(const placement of executionOrder) {
   const pkg=packageForStage(type,placement);
   const applicationOperation=isBrowserApplication(pkg)?experimentalBrowserOperation(experimentalBrowser,pkg,operations[placement.id]):undefined;
   if(requiresDesktopExecution(pkg)&&(!interactive||background||includeIndependent)){nextStageId=placement.id;stopReason='runtime-approval';break;}
   if(pkg?.manifest.state&&!interactive&&!background){nextStageId=placement.id;stopReason='runtime-approval';break;}
-  if(!pkg || !(runtimes.has(pkg.manifest.runtime)||unattended&&unattendedConnection(pkg)||isBrowserApplication(pkg)&&interactive||interactive&&!includeIndependent&&(!reuseCurrentSources||hostedUpdate&&pkg.manifest.runtime==='capability')&&remoteRuntime(pkg.manifest.runtime))){nextStageId=placement.id;stopReason=pkg?'runtime-approval':'host-workspace';break;}
+  if(!pkg || !(runtimes.has(pkg.manifest.runtime)||unattended&&(unattendedConnection(pkg)||unattendedText&&textGeneration(pkg)||unattendedImage&&imageGeneration(pkg))||isBrowserApplication(pkg)&&interactive||interactive&&!includeIndependent&&(!reuseCurrentSources||hostedUpdate&&pkg.manifest.runtime==='capability')&&remoteRuntime(pkg.manifest.runtime))){nextStageId=placement.id;stopReason=pkg?'runtime-approval':'host-workspace';break;}
   const incoming=await Promise.all((type.connections || []).filter(edge=>edge.to.stage===placement.id).map(async edge=>{
    // External converted values arrive raw. Pin the producing contract so the
    // executor can check its type/role without trusting a caller's descriptor.
@@ -91,7 +112,7 @@ export async function planSegment(projectType,canvas,startStepId,{interactive=fa
    const outputContract=pin?{...currentOutputContract,...pin.outputContract}:currentOutputContract;
    return {...edge,outputContract:structuredClone(outputContract),...(savedSource?{savedSource}:{})};
   }));
-  if(!includeIndependent && steps.length && !incoming.some(edge=>selected.has(edge.from.stage))){nextStageId=placement.id;stopReason='unconnected-step';break;}
+  if(!includeIndependent && steps.length && !automationRoot && !incoming.some(edge=>selected.has(edge.from.stage))){nextStageId=placement.id;stopReason='unconnected-step';break;}
   assert(incoming.every(edge=>reuseCurrentSources?!!edge.savedSource || active.findIndex(step=>step.id===edge.from.stage)<active.indexOf(placement):includeIndependent?selected.has(edge.from.stage) || active.findIndex(step=>step.id===edge.from.stage)<start:active.findIndex(step=>step.id===edge.from.stage)<active.indexOf(placement)),'SEGMENT_ORDER',includeIndependent?'A required source is outside this local run. Start from that source or review the workflow boundary.':'A production Step depends on a later Step. Reorder the workflow first');
   const candidates=graph.nodes.filter(node=>node.id===stageNodeId(placement)),node=candidates[0];
   assert(candidates.length===1 && node.type==='programmableBlockNode','SEGMENT_PIN','The compiled Step is missing or duplicated');
@@ -110,7 +131,7 @@ export async function planSegment(projectType,canvas,startStepId,{interactive=fa
  assert(steps.length,'SEGMENT_RUNTIME','Choose a recipe or JavaScript Step to run a connected segment');
  if(endStepId!==undefined && stopReason==='complete' && active[end+1]){nextStageId=active[end+1].id;stopReason='selection-boundary';}
  const semanticManifests=active.map(stage=>packageForStage(type,stage,BUILTIN_BLOCKS)?.manifest).filter(manifest=>manifest?.semantics?.length).map(manifest=>({id:manifest.id,version:manifest.version,semantics:structuredClone(manifest.semantics)}));
- const plan={schemaVersion:1,workflowDigest:compiled.digest,startStepId,steps,nextStageId,stopReason,...(includeIndependent?{includeIndependent:true}:{}),...(unattended?{unattended:true}:{}),...(background&&steps.some(step=>step.package.manifest.state)?{background:true}:{}),...(interactive&&(includeIndependent||steps.some(step=>isBrowserApplication(step.package)||requiresDesktopExecution(step.package)||remoteRuntime(step.package.manifest.runtime)||step.package.manifest.state||hasInteractiveRequirements(step.package)||hasInteractiveRequirements(step.fallbackPackage)))?{interactive:true}:{})};
+ const plan={schemaVersion:1,workflowDigest:compiled.digest,startStepId,steps,nextStageId,stopReason,...(includeIndependent?{includeIndependent:true}:{}),...(unattended?{unattended:true}:{}),...(unattendedText?{unattendedText:true}:{}),...(unattendedImage?{unattendedImage:true}:{}),...(background&&steps.some(step=>step.package.manifest.state)?{background:true}:{}),...(interactive&&(includeIndependent||steps.some(step=>isBrowserApplication(step.package)||requiresDesktopExecution(step.package)||remoteRuntime(step.package.manifest.runtime)||step.package.manifest.state||hasInteractiveRequirements(step.package)||hasInteractiveRequirements(step.fallbackPackage)))?{interactive:true}:{})};
  if(semanticManifests.length)plan.semanticManifests=semanticManifests;
  if(type.projectInputs?.length){plan.projectInputs=structuredClone(type.projectInputs);plan.projectTypeIdentity={id:type.id,version:type.version};}
  if(reuseCurrentSources){plan.reuseCurrentSources=true;plan.interactive=true;}
@@ -181,7 +202,7 @@ async function runSegmentInternal(suppliedPlan,{runId=crypto.randomUUID(),source
   assert(!plan.includeIndependent || plan.includeIndependent===true && interactive && plan.interactive && !background && !hosted,'SEGMENT_APPROVAL','Independent Steps require an interactive local workflow run');
   assert(!rebind || typeof verifyHostedResult==='function' || !plan.steps.slice(0,prior.length).some(step=>remoteRuntime(step.package.manifest.runtime)),'SEGMENT_APPROVAL','Hosted receipts require a separate project ownership adapter');
   const unattendedHost=plan.unattended===true&&background===true&&!interactive&&typeof authorizeHostedStep==='function'&&typeof verifyHostedResult==='function';
-  assert(!plan.unattended||unattendedHost&&plan.steps.filter(step=>remoteRuntime(step.package.manifest.runtime)).every(step=>unattendedConnection(step.package)&&!step.failurePolicy&&!step.fallbackPackage),'SEGMENT_APPROVAL','Unattended Steps require exact current grants and verified connection receipts; automatic remote retries are unavailable.');
+  assert(!plan.unattended||unattendedHost&&plan.steps.filter(step=>remoteRuntime(step.package.manifest.runtime)).every(step=>unattendedStep(step.package,plan)&&!step.failurePolicy&&!step.fallbackPackage),'SEGMENT_APPROVAL','Unattended Steps require exact current grants and verified connection receipts; automatic remote retries are unavailable.');
   assert(!hosted||(interactive===true&&plan.interactive===true&&typeof verifyHostedResult==='function')||unattendedHost,'SEGMENT_APPROVAL','Hosted Steps require an approved host and verified execution receipts');
   safeDocument(memorySources);assert(plain(memorySources),'SEGMENT_STATE','Memory sources must be keyed by placement.');
   safeDocument(memory);assert(plain(memory)&&Object.keys(memory).every(id=>plan.steps.some(step=>step.id===id&&step.package.manifest.state)),'SEGMENT_STATE','Memory must belong to a selected stateful placement');
@@ -202,7 +223,7 @@ async function runSegmentInternal(suppliedPlan,{runId=crypto.randomUUID(),source
    await fence(step);
    const pkg=step.package,m=pkg.manifest;
    const startingState=m.state?validateBlockState(m,memory[step.id]??step.state):undefined,stateSource=memorySources[step.id]??step.stateSource;
-   assert((runtimes.has(m.runtime)||unattendedHost&&unattendedConnection(pkg)||interactive&&plan.interactive&&(remoteRuntime(m.runtime)||isBrowserApplication(pkg))) && await wait(digest(pkg))===step.packageDigest,'SEGMENT_PIN','The Step package pin changed');
+   assert((runtimes.has(m.runtime)||unattendedHost&&unattendedStep(pkg,plan)||interactive&&plan.interactive&&(remoteRuntime(m.runtime)||isBrowserApplication(pkg))) && await wait(digest(pkg))===step.packageDigest,'SEGMENT_PIN','The Step package pin changed');
    if(step.failurePolicy?.action==='fallback_block'){validateFailurePolicy(pinnedFailurePolicy(step.failurePolicy),m,[step.fallbackPackage]);assert(await wait(digest(step.fallbackPackage))===step.fallbackPackageDigest,'SEGMENT_PIN','The fallback Block package pin changed');}
    else assert(step.fallbackPackage===undefined&&step.fallbackPackageDigest===undefined,'SEGMENT_PIN','Unexpected fallback package');
    const applicationOptions=isBrowserApplication(pkg)?{operation:step.applicationOperation,stepId:step.id,runId,planDigest:plan.planDigest,workflowDigest:plan.workflowDigest,signal:controller.signal,check:()=>fence(step)}:null;
@@ -219,6 +240,9 @@ async function runSegmentInternal(suppliedPlan,{runId=crypto.randomUUID(),source
    if(selectedPrimary!==null)input[selectedPrimary]=structuredClone(origin);
    let changedPrimaryRepresentation=false;const workspaceSources=new Map(),connectionSources={};
    const context=await wait(resolveContext(structuredClone(step),structuredClone(origin)));await fence(step);
+   // An upstream gate that produced nothing for a required input means "this
+   // branch was not taken": the run ends here, successfully, without asking.
+   if(incoming.some(edge=>ids.has(edge.from.stage)&&edge.to.port!==selectedPrimary&&m.inputs[edge.to.port]?.required!==false&&completed.has(edge.from.stage)&&!Object.hasOwn(completed.get(edge.from.stage).outputs,edge.from.port))){result.stoppedAt={stepId:step.id,reason:'branch-not-taken'};break;}
    for(const edge of incoming){
     assert(edge.to.stage===step.id && Object.hasOwn(m.inputs,edge.to.port),'SEGMENT_INPUT','Connection targets an unavailable input');
     let output,value,omitted=false;
@@ -398,7 +422,7 @@ async function runSegmentInternal(suppliedPlan,{runId=crypto.randomUUID(),source
       const alternate=executionPackage!==pkg,executionStep=alternate?{...step,package:executionPackage,packageDigest:step.fallbackPackageDigest,label:`${step.label} / ${executionPackage.manifest.name}`}:step;
       await wait(onStartStep({runId,stepId:step.id,packageDigest:executionStep.packageDigest,placementDigest:step.packageDigest,attempt,inputDigest,capturedInputs:captureRunInputIdentities({...bound,...runtimeAnswers,...runtimeChatValues},activeSourceMap(),m.inputs),inputsComplete:executionPackage.manifest.runtime!=='javascript'}));await fence(step);
       const dispatchInputDigest=inputDigest;
-      if(unattendedHost&&unattendedConnection(executionPackage))await wait(authorizeHostedStep(structuredClone(executionPackage),structuredClone(executionInput),{step:structuredClone(executionStep),runId,inputDigest,signal:controller.signal,check:()=>fence(step)}));
+      if(unattendedHost&&unattendedStep(executionPackage,plan))await wait(authorizeHostedStep(structuredClone(executionPackage),structuredClone(executionInput),{step:structuredClone(executionStep),runId,inputDigest,signal:controller.signal,check:()=>fence(step)}));
       const execution=isBrowserApplication(executionPackage)?await executeExperimentalBrowser(experimentalBrowser,executionPackage,executionInput,applicationOptions):await execute(structuredClone(executionPackage),structuredClone({...executionInput,...runtimeAnswers,...runtimeChatValues}),{...(recoverLastValid?{recoverLastValid}:{}),...(requestRuntimeAnswer && executionPackage.manifest.runtime==='javascript'?{requestFromUser:question=>requestRuntimeAnswer(question,attempt,executionStep.label,executionStep.packageDigest)}:{}),...(requestRuntimeChat && executionPackage.manifest.runtime==='javascript'?{requestFromChat:question=>requestRuntimeChat(question,attempt,executionStep)}:{}),runId,inputDigest,...(materialInputDigest?{workspaceMaterializedInput:structuredClone(bound)}:{}),workspaceSources:structuredClone([...workspaceSources.values()]),semanticSources:structuredClone(semantic.provenance),step:structuredClone(executionStep),...(executionPackage.manifest.state?{state:structuredClone(startingState),stateSource:structuredClone(stateSource)}:{}),signal:controller.signal,check:()=>fence(step)});
       if(requiresDesktopExecution(executionPackage)){
        assert(!execution.skipped,'DESKTOP_RECEIPT','The native executor must return a completed native action; only the host may apply a reviewed skip or fallback.');

package/packages/block-platform/step-groups.js

@@ -0,0 +1,78 @@
+// One Step a person sees is one job, and a job can be made of several parts
+// (contract rule block-scope). A group names the parts of one job: consecutive
+// Steps in `stages`. Each part stays a real Step, so its permissions, approvals,
+// credits, memory and runs are unchanged; groups only change what people see.
+import {assert,plain} from '../block-sdk/contracts.js';
+import {BLOCK_NAME_MAX_LENGTH} from '../block-sdk/builder-contract.js';
+
+export const MAX_GROUP_PARTS=12;
+const GROUP_KEYS=['id','label','stages','settings','result'];
+
+/** Checks `type.groups` against the stages and their manifests (Map stageId → manifest). */
+export function validateStepGroups(type,manifests){
+ if(type.groups===undefined)return;
+ assert(Array.isArray(type.groups)&&type.groups.length<=50,'STEP_GROUP','Expected at most 50 Step groups');
+ const order=new Map(type.stages.map((stage,index)=>[stage.id,index])),used=new Set(),ids=new Set();
+ for(const group of type.groups){
+  assert(plain(group)&&Object.keys(group).every(key=>GROUP_KEYS.includes(key)),'STEP_GROUP','A Step group has an id, a name, its parts, settings and a result');
+  assert(/^[a-z][a-z0-9-]*$/.test(group.id||'')&&!ids.has(group.id)&&!order.has(group.id),'STEP_GROUP','Each Step group needs its own ID');ids.add(group.id);
+  assert(typeof group.label==='string'&&group.label.trim()&&group.label.length<=BLOCK_NAME_MAX_LENGTH,'STEP_GROUP',`Name each Step in ${BLOCK_NAME_MAX_LENGTH} characters or fewer`);
+  assert(Array.isArray(group.stages)&&group.stages.length>=2&&group.stages.length<=MAX_GROUP_PARTS,'STEP_GROUP',`A Step groups 2 to ${MAX_GROUP_PARTS} parts`);
+  const indexes=group.stages.map(id=>order.get(id));
+  assert(indexes.every(Number.isInteger)&&group.stages.every(id=>!used.has(id)),'STEP_GROUP','A part belongs to one Step and must exist');
+  assert(indexes.every((index,at)=>!at||index===indexes[at-1]+1),'STEP_GROUP','The parts of a Step must be next to each other, in order');
+  for(const id of group.stages)used.add(id);
+  // A When part starts its job; it is never in the middle of one.
+  assert(group.stages.slice(1).every(id=>manifests.get(id)?.id!=='sm.when'),'STEP_GROUP','When starts its Step');
+  assert(group.settings===undefined||Array.isArray(group.settings)&&group.settings.length<=16&&group.settings.every(item=>plain(item)&&group.stages.includes(item.stage)&&Object.hasOwn(manifests.get(item.stage)?.inputs||{},item.input)&&typeof item.label==='string'&&item.label.trim()&&item.label.length<=60),'STEP_GROUP','Step settings must name an input of one of its parts');
+  assert(group.result===undefined||plain(group.result)&&group.stages.includes(group.result.stage)&&Object.hasOwn(manifests.get(group.result.stage)?.outputs||{},group.result.port),'STEP_GROUP','A Step result must be an output of one of its parts');
+ }
+}
+
+/** Keeps groups consistent after an edit: missing parts leave, a part moved away leaves (the longest run stays), and a group under two parts is dissolved. */
+export function normalizeGroups(type){
+ if(!Array.isArray(type.groups))return type;
+ const order=new Map(type.stages.map((stage,index)=>[stage.id,index]));
+ const groups=type.groups.flatMap(group=>{
+  const present=group.stages.filter(id=>order.has(id)).sort((a,b)=>order.get(a)-order.get(b)),runs=[];
+  for(const id of present){if(runs.length&&order.get(id)===order.get(runs.at(-1).at(-1))+1)runs.at(-1).push(id);else runs.push([id]);}
+  const stages=runs.reduce((best,run)=>run.length>best.length?run:best,[]);
+  if(stages.length<2)return [];
+  const settings=(group.settings||[]).filter(item=>stages.includes(item.stage)),result=group.result&&stages.includes(group.result.stage)?group.result:undefined;
+  return [{id:group.id,label:group.label,stages,...(settings.length?{settings}:{}),...(result?{result}:{})}];
+ });
+ if(!groups.length){const {groups:_dropped,...rest}=type;return rest;}
+ return {...type,groups};
+}
+
+/** The group a Step belongs to, if any. */
+export const groupOf=(type,stageId)=>(type.groups||[]).find(group=>group.stages.includes(stageId))||null;
+
+/** What people see in order: one item per job, a group or a single Step. */
+export function stepItems(type){
+ const items=[],seen=new Set();
+ for(const stage of type.stages){
+  if(seen.has(stage.id))continue;
+  const group=groupOf(type,stage.id);
+  if(group){for(const id of group.stages)seen.add(id);items.push({kind:'group',id:group.id,label:group.label,stages:[...group.stages],group});}
+  else{seen.add(stage.id);items.push({kind:'stage',id:stage.id,label:stage.label,stages:[stage.id]});}
+ }
+ return items;
+}
+
+/** A Step inserted strictly between two parts of a job becomes one of its parts. */
+export function joinGroupAt(type,stageId,index){
+ if(!Array.isArray(type.groups))return type;
+ const before=type.stages[index-1]?.id,after=type.stages[index+1]?.id;
+ return {...type,groups:type.groups.map(group=>before&&after&&group.stages.includes(before)&&group.stages.includes(after)?{...group,stages:[...group.stages.slice(0,group.stages.indexOf(after)),stageId,...group.stages.slice(group.stages.indexOf(after))]}:group)};
+}
+
+/** Group consecutive Steps into one job. */
+export function groupSteps(type,stageIds,label,{id=`job-${crypto.randomUUID().slice(0,8)}`}={}){
+ const groups=(type.groups||[]).filter(group=>!group.stages.some(stage=>stageIds.includes(stage)));
+ return {...type,groups:[...groups,{id,label:String(label||'').trim().slice(0,BLOCK_NAME_MAX_LENGTH),stages:[...stageIds]}]};
+}
+/** Show a job's parts as separate Steps again. */
+export function ungroupStep(type,groupId){return normalizeGroups({...type,groups:(type.groups||[]).filter(group=>group.id!==groupId)});}
+/** Rename a job. */
+export function renameGroup(type,groupId,label){return {...type,groups:(type.groups||[]).map(group=>group.id===groupId?{...group,label:String(label||'').trim().slice(0,BLOCK_NAME_MAX_LENGTH)}:group)};}

package/packages/block-platform/steps.js

@@ -4,6 +4,7 @@ import {validateProjectType} from './project-types.js';
 import {validateCondition} from './conditions.js';
 import {HOST_PORTS} from './type-workspace.js';
 import {packageForStage} from './stage-package.js';
+import {normalizeGroups,joinGroupAt} from './step-groups.js';
 
 // `stages` is the existing on-disk field for Step instances. Keep it stable so
 // releases, digests, project links and instance IDs do not need migration.
@@ -41,7 +42,9 @@ function connection(type,from,to,catalog) {
  validateConnectionAdapter(out,input,{permissions:b.permissions?.project || [],...(match.adapter?{adapter:match.adapter}:{})});
  return {from:{stage:from.id,port:out.name},to:{stage:to.id,port:input.name},...(match.adapter?{adapter:match.adapter}:{})};
 }
-function validated(type,catalog) {const result=validateProjectType(type,catalog);assert(result.valid,'STEP',result.errors.map(error=>error.message).join('. '));return type;}
+// Every edit keeps Step groups consistent: missing parts leave a group, and a
+// group that is no longer one run of parts is shown as separate Steps again.
+function validated(type,catalog,options) {type=normalizeGroups(type);const result=validateProjectType(type,catalog,options);assert(result.valid,'STEP',result.errors.map(error=>error.message).join('. '));return type;}
 function pinPackage(type,pkg,catalog) {
  const manifest=pkg?.manifest;assert(manifest,'MANIFEST','Choose a Block package');
  const packages=[...(type.packages || [])],matches=[...catalog,...packages].filter(candidate=>candidate?.manifest?.id===manifest.id&&candidate.manifest.version===manifest.version),existing=matches.find(candidate=>stableStringify(candidate)===stableStringify(pkg));
@@ -52,10 +55,10 @@ function pinPackage(type,pkg,catalog) {
  }
  return packages;
 }
-function insertConfigured(type,pkg,index,catalog,step) {
+function insertConfigured(type,pkg,index,catalog,step,options) {
  assert(Number.isInteger(index)&&index>=0&&index<=type.stages.length,'STEP','Choose a position in the workflow');
  const packages=pinPackage(type,pkg,catalog),nextType={...type,packages},stages=[...type.stages.slice(0,index),step,...type.stages.slice(index)];
- if(step.enabled===false)return validated({...nextType,stages},catalog);
+ if(step.enabled===false)return validated({...nextType,stages},catalog,options);
  const previous=type.stages.slice(0,index).findLast(item=>item.enabled!==false),next=type.stages.slice(index).find(item=>item.enabled!==false);
  const incoming=previous?connection(nextType,previous,step,catalog):null,outgoing=next?connection(nextType,step,next,catalog):null;
  const oldOutput=previous&&automaticPort(manifestFor(nextType,previous,catalog),'outputs'),oldInput=next&&automaticPort(manifestFor(nextType,next,catalog),'inputs');
@@ -65,16 +68,17 @@ function insertConfigured(type,pkg,index,catalog,step) {
  for(const edge of [incoming,outgoing].filter(Boolean)) {
   assert(!connections.some(existing=>existing.to.stage===edge.to.stage&&existing.to.port===edge.to.port),'STEP_INCOMPATIBLE','Another Block already supplies this input. Choose a compatible position in its connected workflow.');connections.push(edge);
  }
- return validated({...type,packages,stages,connections},catalog);
+ // A Step placed between two parts of a job becomes one of its parts.
+ return validated(joinGroupAt({...type,packages,stages,connections},step.id,index),catalog,options);
 }
-export function insertStep(type,pkg,index,catalog=[],{id}={}) {
+export function insertStep(type,pkg,index,catalog=[],{id,experimentalBrowser,experimentalNative}={}) {
  const manifest=pkg?.manifest;assert(manifest,'MANIFEST','Choose a Block package');
  assert(manifest.id!==ROOT_CHAT_ID,'ROOT_PROTECTED','Starting chat is provided by the host and cannot be inserted as another Step');
- return insertConfigured(type,pkg,index,catalog,{id:id||`step-${crypto.randomUUID().slice(0,12)}`,blockId:manifest.id,version:manifest.version,label:manifest.name});
+ return insertConfigured(type,pkg,index,catalog,{id:id||`step-${crypto.randomUUID().slice(0,12)}`,blockId:manifest.id,version:manifest.version,label:manifest.name},{experimentalBrowser,experimentalNative});
 }
-export function insertionLocations(type,pkg,catalog=[]) {
+export function insertionLocations(type,pkg,catalog=[],options={}) {
  return Array.from({length:type.stages.length+1},(_,index)=>{
-  try{insertStep(type,pkg,index,catalog,{id:`insertion-preview-${index}`});return {index,compatible:true};}
+  try{insertStep(type,pkg,index,catalog,{...options,id:`insertion-preview-${index}`});return {index,compatible:true};}
   catch(error){return {index,compatible:false,reason:error.message};}
  });
 }

package/packages/block-platform/type-workspace.js

@@ -19,8 +19,8 @@ export function stageHost(stage) {
  return {phase:declaration?.phase||'blockStep',nodeId:host.canvasNode||!declaration?stageNodeId(stage):null,exportVideo:!!host.exportVideo,...(host.exportKind?{exportKind:host.exportKind}:{}),...(host.inspectClip?{inspectClip:true}:{}),...(host.editorTab?{editorTab:host.editorTab}:{})};
 }
 
-export function typeWorkspaceSupport(type,{experimentalBrowser}={}) {
-  const validation = validateProjectType(type, BUILTIN_BLOCKS,{experimentalBrowser});
+export function typeWorkspaceSupport(type,{experimentalBrowser,experimentalNative}={}) {
+  const validation = validateProjectType(type, BUILTIN_BLOCKS,{experimentalBrowser,experimentalNative});
   if (!validation.valid) return { supported: false, reasons: validation.errors.map(e => e.message) };
   const recipes = new Set([...(type.packages || []),...BUILTIN_BLOCKS.filter(pkg=>pkg.manifest.runtime!=='host')].map(pkg => `${pkg.manifest.id}@${pkg.manifest.version}`));
   const reasons = [];
@@ -51,14 +51,14 @@ export function projectAnchorTarget(project, anchor) {
 }
 // All executable source travels with the project. Installing a newer release
 // cannot change these nodes or silently replace a project's workflow definition.
-export async function compileTypeWorkspace(type,{experimentalBrowser}={}) {
+export async function compileTypeWorkspace(type,{experimentalBrowser,experimentalNative}={}) {
   const definition = structuredClone(type);
   // Embed exact SDK-owned built-ins so saved projects carry their implementation.
   for (const stage of definition.stages || []) {
     const builtin = BUILTIN_BLOCKS.find(pkg => pkg.manifest.id === stage.blockId && pkg.manifest.version === stage.version && pkg.manifest.runtime !== 'host');
     if (builtin && !definition.packages?.some(pkg => pkg.manifest.id === stage.blockId && pkg.manifest.version === stage.version)) (definition.packages ||= []).push(structuredClone(builtin));
   }
-  const support = typeWorkspaceSupport(definition,{experimentalBrowser});
+  const support = typeWorkspaceSupport(definition,{experimentalBrowser,experimentalNative});
   assert(support.supported, 'UNSUPPORTED_TYPE', support.reasons.join('\n'));
   const nodes = [];
   for (const stage of definition.stages.filter(stage=>stage.enabled !== false)) {

package/packages/block-platform/workflow-loop.js

@@ -4,6 +4,10 @@ import {assertInputSource} from '../block-sdk/input-source-policy.js';
 import {semanticRegistryForManifests} from '../block-sdk/package-semantics.js';
 import {validateDataPredicate,conditionMatches} from './conditions.js';
 
+// Repeat workflow is tucked away in the product for now (owner decision,
+// October 9, 2026): the loop panel is hidden on Steps. The loop runtime, routes
+// and tests stay in place; flip this to true to show the panel again.
+export const WORKFLOW_LOOPS_ENABLED=false;
 export const MAX_WORKFLOW_ITERATIONS=100;
 
 const endpoint=value=>plain(value) && Object.keys(value).length===2 && ['stage','port'].every(key=>typeof value[key]==='string' && value[key].length>0 && value[key].length<=200);