H3 Context Plan:
H3 Context Plan prepares a structured planning foundation for the H3 context workflow. It normalizes a typed creative request into a consistent form and assembles a plan around explicitly supplied intent, rather than guessing detailed meaning from free-form text. An intent graph is a structured way of describing intended meaning and relationships; this node uses that explicit information to make the planning process clearer and more predictable. When semantic detail is missing, the plan remains a visibly limited manual skeleton instead of silently filling the gaps with invented decisions. This helps you distinguish what you have actually specified from what still needs creative attention before proceeding to prompt compilation and validation. The node handles context planning, not image, audio, or video rendering.
H3 Context Plan Input Parameters:
request
Required connection of type H3_CONTEXT_REQUEST. This is the typed request envelope supplied by H3 Context Request and provides the starting point for planning. “Typed” means that the request arrives as a structured workflow object, not as an ordinary text prompt pasted directly into this node. The node normalizes this request while building the plan, so the connected request determines the creative task being planned. Request validation is deferred until the connected object is available during execution when necessary; allowing an unresolved connection during ComfyUI’s preliminary checks does not remove the requirement to supply a valid request. No minimum, maximum, default value, or selectable options are declared for this connection.
reference_registry
Optional connection of type H3_REFERENCE_REGISTRY. This supplies explicit reference ownership information through the reference-registry structure. It gives the planner reference information that has been deliberately registered, rather than requiring you to treat a loose image, filename, or text description as equivalent to a registered reference. Connect the appropriate registry when your workflow depends on explicitly associated references. The supplied code does not describe the registry’s internal fields or any reference-selection rules, so this connection should not be assumed to perform automatic reference discovery or visual interpretation. When omitted, the method receives None; no numeric minimum, maximum, or selectable options are declared.
intent_graph
Optional connection of type H3_INTENT_GRAPH. This supplies an explicit semantic graph: a structured description of intended meaning and relationships for the plan. The interface specifically states “no free-text inference,” so you should not expect this node to turn a descriptive sentence into a fully detailed semantic graph on its own. Providing an appropriate graph gives the planner explicit semantic material to work with; leaving semantic detail unspecified preserves a visibly limited manual skeleton rather than automatically inventing the missing details. H3 Intent Graph Producer is identified in the supplied context as a producer of this socket type. When omitted, the method receives None; no numeric minimum, maximum, or selectable options are declared.
H3 Context Plan Output Parameters:
plan
Output of type H3_CONTEXT_PLAN, represented internally by a ContextPlan object. This is the structured planning result assembled from the normalized request and any supplied reference registry or intent graph. It is an intermediate workflow object, not a finished prompt or rendered media. Its importance is that downstream stages can work from the same explicit planning foundation, including any visible limits caused by missing semantic detail. The supplied workflow definitions show this output connecting to H3 Context Compiler for prompt compilation and H3 Context Validator for validation alongside a compiled prompt document. The internal fields of ContextPlan are not included in the supplied source, so no particular field layout or completeness score can be assumed.
report
Output of type H3_CONTEXT_REPORT, represented internally by a ContextReport object. This is the report returned alongside the plan by the canonical planning process. It provides a separate reporting artifact that compatible downstream nodes can receive, without requiring you to treat the plan itself as a human-readable report. The supplied context does not show the report’s fields, diagnostic categories, or presentation format, so specific warning messages, scores, and status values cannot be documented from this source. In particular, this planning report should not be confused with the separate validated_report produced by H3 Context Validator; receiving a report here does not by itself establish that downstream compilation and validation have succeeded.
H3 Context Plan Usage Tips:
- Connect H3 Context Request to
requestfirst. This node expects the structured request object, so enter or configure your creative request upstream rather than attempting to feed a plain text string into this connection. - For a minimal workflow, connect only
request. Treat the result as a planning starting point, and remember that unspecified semantic detail remains a visible manual skeleton rather than being automatically completed. - Connect
intent_graphwhen you need explicit semantic planning. Build the intended relationships upstream with a compatible producer instead of relying on a longer free-text description to trigger automatic inference. - Connect
reference_registrywhen your task relies on explicitly registered reference ownership. Supply anH3_REFERENCE_REGISTRYobject rather than connecting a raw image or a path directly. - Send
planto H3 Context Compiler when you are ready to compile the planning result into prompt-related artifacts. For the documented validation path, also provide the plan and the compiler’sprompt_documentto H3 Context Validator. - Configure request details, reference ownership, and semantic intent in the corresponding upstream nodes. H3 Context Plan exposes connection-based inputs only; it has no local numeric settings, quality sliders, or performance presets in the supplied interface.
- If preliminary workflow checks pass but execution fails, inspect the resolved upstream objects. The node deliberately postpones typed request validation when the request is not yet available during ComfyUI’s connection checks.
H3 Context Plan Common Errors and Solutions:
Missing required request connection
- Explanation:
requestis the only required input. Without a valid connected request, the node does not have the structured starting information needed to build a plan. This heading describes the condition; the supplied source does not include an exact missing-input error string. - Solution: Add H3 Context Request, configure it, and connect its
requestoutput to this node’srequestinput. Confirm that the upstream node executes successfully.
Incompatible input connection type
- Explanation: The inputs expect specific H3 object types, not interchangeable text, image, or generic data connections. A plain prompt string is not an
H3_CONTEXT_REQUEST, and an image is not anH3_REFERENCE_REGISTRY. The exact connection-error wording is not shown in the supplied source. - Solution: Check each socket type and use the matching producer: H3 Context Request for
request, H3 Reference Registry forreference_registry, and a compatible intent-graph producer forintent_graph.
PipelineNodeError with canonical planning diagnostics
- Explanation: The node catches
CanonicalContextPipelineErrorand raisesPipelineNodeErrorusing the original diagnostics. This means the useful explanation comes from the planning pipeline’s diagnostic content, not from a fixed error message defined in this node. The supplied context does not include the possible diagnostic strings. - Solution: Read the diagnostic displayed by ComfyUI and correct the upstream request, registry, or intent graph it identifies. If the cause is unclear, test with the required request alone, then reconnect the optional inputs one at a time to narrow down the failing combination.
Validation succeeds initially, but planning fails during execution
- Explanation: When the request is unresolved and appears as
Noneduring preliminary validation, the node allows that check to pass because upstream values may not exist yet. The actual object is checked when planning runs, so preliminary success does not guarantee a valid runtime request. - Solution: Inspect the output of H3 Context Request and any upstream execution errors. Make sure the connection resolves to the expected typed request, then rerun the workflow and use any planning diagnostics to guide corrections.
Plan remains a limited manual skeleton
- Explanation: This is documented behavior, not necessarily an error. The node does not infer missing semantic detail from free text, so an incomplete semantic specification can produce a visibly limited plan even when execution succeeds.
- Solution: Supply a more explicit
intent_graphthrough a compatible upstream producer and define the missing creative relationships there. Do not rely on adding descriptive text alone to make this node invent a complete semantic plan.
