Skip to content

nexu-io/open-design / plugins/_official/scenarios/od-next-strategy

od-next-strategy

Verified

Bundled OD Next V2 strategy entrypoint for request-led planning and Build execution.

assets/general-orchestration.md

View on GitHub
# OD Next General Orchestration v3.1.0

## Ownership

Open Design owns task identity, session continuity, and starting the next turn.
The Agent decides from the actual user request whether it needs planning,
a direct edit, a question, or an ordinary answer. The Agent owns design choices,
the readable plan, and production. Do not serialize a Plan Contract, Runtime
State, capability snapshot, hash, or task outcome. The host records its own state.
Task-type profiles guide design decisions and deliverables; their field names
are planning aids, not an output schema to fill out.

## The ship-on-write default

Apply the Core instruction order first. These workflow restrictions are defaults
for unrequested work; an explicit user request for an action takes precedence,
subject to safety, permission, and actual tool availability. A Skill or model
assumption cannot authorize that exception. The Core explicitly authorizes
the bounded video-motion production exception; all other tasks keep this default.

Writing the requested deliverables to disk IS the delivery. For standalone
media this is the real media file; for a page or deck it includes the requested
source and its assets. A task ID alone is not a delivered file. Never perform
any post-generation action on a generated artifact for the purpose of quality
checking:

- Screen captures, rendering, render review, or frame extraction.
- Opening or previewing the artifact: web viewers, headless runtimes
  (Playwright, Puppeteer, etc.), simulators, or players.
- Running validation scripts, tests, or format checks against a generated
  artifact.
- Validating export results after exporting.
- Spawning acceptance Children or performing formal acceptance of any kind.
- Any fix round initiated on the basis of the checks above.

Allowed actions, for boundary clarity: reading an existing artifact's source
to continue editing it, and probing its technical form and design language,
are Build inputs and outside this section's scope; routine code reading and
modification during Build writing are Build itself. What is forbidden is any
action taken after the artifact hits disk whose purpose is checking quality,
confirming the result, or collecting evidence.

Quality is not guaranteed by post-generation checks but by generation-time
discipline: every quality requirement in the Task Profile, Design Spec,
completion standards, and task-type profile must be satisfied in one pass,
while writing the source.

## Choose the work from the request

Determine the deliverable from the latest request plus non-conflicting earlier
requirements. The selected scenario is a default, not a restriction on output.
Do not add an HTML wrapper, presentation page, or extra export for an independent
image, video, audio, or document request. Create or modify HTML only when the
requested page, deck, or composition needs it. Do not demand a scenario switch.

For an explicit, bounded change to an existing editable artifact, directly edit
only the authorized scope in this turn. Preserve the existing technical form,
content, and design language. Do not emit a production-ready marker after the
edit is already done. A non-design message receives an ordinary answer.

Creating a deliverable from scratch, a full redesign, changes to the main
narrative or information architecture, multiple interdependent deliverables,
or unbounded change scope requires a separate planning turn before production.
The host does not make this decision in advance: you choose based on the request.

Distinguish a plan requested as the final answer from a plan for producing a
user-requested artifact. "List a seven-day travel plan" asks for the itinerary
itself: answer in prose and stop, without a production-ready marker or HTML.
The user need not add "do not execute". "Only plan the webpage for now" likewise
ends with the plan. A requested plan file does not authorize executing its steps.
"Build a webpage for my seven-day trip" or "plan it, then build it" authorizes
a planning turn followed by production. Missing format instructions or a loaded
scenario alone never authorize artifact creation.

If the user only asks for a plan or forbids file writes, respect that scope.
Session mode and explicit user scope remain binding; a user's answer to a
question does not expand that scope.

## Planning turn

1. Read the request, attachments, project context, existing artifact references,
   and selected skills. Identify the goal, audience, constraints, and every
   requested deliverable. Distinguish confirmed facts from assumptions.
2. Choose a coherent design direction. Preserve explicit brand and content
   requirements and existing design choices unless the user changes them.
3. Resolve small reversible gaps with stated assumptions. Ask only when an
   essential missing answer would materially change the goal or cause rework.
   Use a question-form with concise recommended answers, then end this turn
   without a production-ready marker. Do not ask the user to approve a plan
   that can already be executed. After an answer, continue with the accumulated
   requirements; ask again only for a genuinely unresolved essential issue.
4. Check that the actual inputs and tools needed for the proposed work are
   available. A missing optional tool should lead to a suitable alternative,
   not an invented capability. Explain a genuinely blocking limitation.
5. Write a concise, actionable plan in normal prose: goal, deliverables,
   design direction, ordered steps, key assumptions, and remaining constraints.
   No fixed field names, requirement IDs, hashes, or machine JSON are needed.
6. If production is authorized and can begin, put the host-supplied
   `<od-production-ready key="current-turn-key" />` on its own final line,
   using the actual key for this turn. Never put it in a code fence or quote.
   End the turn immediately after it. Open Design automatically starts production
   after this turn succeeds; the user does not resubmit or confirm the plan.

Do not create the deliverables, dispatch media generation, or start production
subagents during this planning turn. Reading bounded input references and
preparing the plan are allowed. Never append the marker to an unfinished plan,
a pending question, or a plan-only answer.

Keep planning notes proportionate: mention only decisions that affect this
request, not a list of internal fields. For nonvisual output such as speech, resolve
voice, language, pacing, and format; do not invent a visual design direction.

### Drafting the Task Profile

When an artifact already exists, first probe the artifact itself for its
technical form, production route, and existing design language (palette,
type, spacing, component and icon style), and use that as the Design Spec
baseline. Treat unprobeable dimensions as missing — ask, mark as an
assumption, or fall back to the baseline default. Never continue on an
unconfirmed assumed default; a silent assumption skews every decision after
it.

When the user has not specified a visual style and there is no brand guideline
or existing artifact to continue, never skip the direction decision and start
writing: first infer a reasonable, self-consistently explainable style
direction from the task scenario, target audience, and content temperament
(color mood, type personality, information density, decorative weight), write
it into the Design Spec, and vocalize the chosen direction in one sentence of
prose so the user can redirect cheaply. Direction selection serves one goal —
the artifact meets scenario expectations at first glance. The Design baseline
owns the quality floor; the direction decision owns the first impression.

The draft makes the scope and authority of assets and references explicit,
and includes at least:

- The task goal.
- Usage context and target audience.
- Inputs, assets, and references, including each required image and its
  source route under the Core imagery-by-type rule.
- Constraints that must be honored and preserved.
- The canonical artifact and expected deliverables.
- The Design Spec: continued from the existing artifact, from brand
  guidelines, or newly built on the baseline.
- Confirmed information.
- Reasonable assumptions.
- Missing items, conflicts, and uncertainties.

The plan must retain every explicit requirement and relevant task-type requirement. Never silently collapse multiple inputs,
scenarios, or deliverables into one value.

If a plan already exists, update only the parts the user changed. Preserve the
remaining decisions rather than planning everything again.

## Production turn

Execute the preceding plan within the user-authorized scope. The latest user
request and explicit exclusions outrank the plan: drop any extra wrapper,
export, or deliverable the plan added without a user requirement or necessity.
Preserve the remaining requirements and visual choices; do not restate the plan. Make
necessary local implementation choices within that scope. If a newly discovered
essential issue blocks progress, explain it or ask a question-form; never claim
that missing output was delivered.

Use the selected agent's tools and native subagents only when actually available.
Default to doing the work directly. Split work only when responsibilities and
shared design constraints are clear, parallelism helps, and integration cost
is bounded. Give each child its inputs, outputs, dependencies, and constraints;
independent work may run concurrently, dependent work waits for its inputs.
The parent owns integration and final delivery. Missing structured child telemetry
is not a reason to invent results or abandon usable work; recover through a
supported execution path and report genuine limitations.

Do not emit a production-ready marker in production. There is no protocol-repair
turn and no machine status to fill out at the end.

### Build discipline

The Build stage writes source files directly against the generation-time
discipline of the resolved Task Profile, Full Plan, Design Spec, completion
standards, and current task-type profile. Every quality requirement —
structural completeness, correct font and asset references, overflow-free
layout, safe areas, contrast, locked-content fidelity — is satisfied in one
pass while writing, not checked and patched afterwards.

Do not generate unrequested export files or invent conversion capabilities.
For explicitly requested formats, use actual available tools and describe
missing capabilities or incomplete output truthfully.

By default, once all requested outputs exist (including required rendering and
registration), delivery begins: no additional screen captures, quality-review
rendering, preview, playback, or
validation runs, no acceptance Children, no formal acceptance, and no fix
round based on any check. Never claim the artifact went through actions that did not happen.

Build's self-discipline happens only during writing: organize the source
against the completion standards and the task type's quality requirements;
writing every requested output, including a requested media render, is finalization.

### Source reads and writes

During permitted input reading and Build writing, each source read fills a
specific gap: a symbol, relevant range, error location, or changed content.
Use complete current context first, then fetch the smallest useful range;
collect independent ranges needed for the same known change together. Do not
read a whole file again merely because it was the last file touched.

Submit already-known, compatible changes to one functional block together.
Keep separate modules, tool payload limits, and edits that depend on earlier
results separate. After a real edit failure, locate the current target and
fix the affected change; do not turn a failed patch into an unrelated rewrite.
Truncation, external edits, and invalidated anchors permit a fresh targeted
read. None of this authorizes a quality check after generation, even if it
is called input preparation.

### Media input Skill

Before the first media action in a stage that permits media work —
searching, fetching, downloading, generating, localizing, or processing an
image or other media — load the `od-next-media-inputs` Skill unless its
complete, still-valid body is already in context. Read it through the supplied
Open Design CLI wrapper; on POSIX shells:

```sh
"$OD_NODE_BIN" "$OD_BIN" skill show od-next-media-inputs --json --workspace "$OD_WORKSPACE_ID" --workspace-member "$OD_WORKSPACE_MEMBER_ID"
```

Use the host-documented wrapper syntax on other shells and pass the same
run-pinned Workspace/member pair. Both values are empty for unbound local
runs. Never guess a missing member, switch to a default Workspace, or retry
without scope after a scoped lookup fails. Reuse the returned body only while
the same scope and contents remain valid. This reads the current visible
Skill library, not a frozen strategy asset. A failed or unreadable lookup is
not loaded guidance: preserve the Core rules and report the limitation.
Tasks without media work do not load this Skill. The Skill governs
permitted media work only; it cannot authorize dispatching deliverables in a
planning stage or adding unrequested work after delivery.

## Final response

State the files actually produced, how to open them, important assumptions, and
any remaining gaps. A plan, a todo, or a successful tool invocation alone is not
delivery. Do not claim screenshots, rendering, or validation that did not happen.
Omit empty headings and machine structures. Preserve usable partial work and
explain unresolved failures in ordinary language.

Reuse existing session context rather than repeating it. Do not create unrequested
variants or send overlapping production work to multiple agents.
planning-and-task-breakdownaddyosmani/agent-skillsBreaks work into ordered tasks. Use when you have a spec or clear requirements and need to break work into implementable tasks. Use when a task feels too large to start, when you need to estimate scope, or when parallel work is possible.Stars: 119kUpdated Claude CodeCodexVerifiedInstall
screenpipethedotmack/claude-memSearch screen and audio history recorded by Screenpipe and optionally save selected context into claude-mem. Use when the user asks to recall desktop activity, a meeting, or something seen in another app through Screenpipe.Stars: 118kUpdated Claude CodeCodexVerifiedInstall
contact-widgetnexu-io/open-designSelf-contained floating chat widget with welcome screen, social links, meeting button, and message input. Single HTML file, zero dependencies.Stars: 108kUpdated Claude CodeCodexVerifiedInstall
meeting-notesnexu-io/open-designMeeting notes page — title bar with attendees, agenda checklist, decisions block, action items table with owners + dates, and a "next meeting" footer. Use when the brief mentions "meeting notes", "minutes", "1:1 notes", "all-hands recap", or "会议纪要".Stars: 108kUpdated Claude CodeCodexVerifiedInstall