[Publication] Orchestrate exhaustive comic finalization and multilingual release workflows #10

Build-time upscale candidates and retention — 2026-10-05

Extend the existing optional orientation-everything upscale stage. The
Upscayl-NCNN provider, custom-model discovery and per-model variants already
belong to closed
Renderflow #373.
This is consumer orchestration and retention work, not a new provider or a
prerequisite for Renderflow's first integration release #419.

• Generate each requested model candidate directly from the same immutable
  source during artifact generation. Preserve the original baseline; never
  recursively upscale another model's result.
• Support an exact model, named subset or explicit all-enabled request with
  preflight estimates for runtime/GPU needs, branch count and storage. Routine
  builds must not silently run all installed models.
• Keep source/configuration/review references in the consumer repository and
  large derivative payloads in an explicitly configured private artifact store
  outside Git. Record retrievable immutable references, byte counts, dimensions,
  output SHA-256 and provider evidence; validate on retrieval.
• Key execution reuse by source digest, provider/executable identity, both
  model-file digests, native/output scales, effective options and relevant
  GPU/backend identity. Preserve honest unavailable/skipped/failed states and
  model-rights eligibility. Discovery does not imply permission to publish.
• Separate disposable caches from durable review and selection retention.
  Retain the exact reviewed/selected bytes, including retained rejected
  candidates according to consumer history policy, and demonstrate restoration.
  A recipe or checksum alone cannot recover an artifact; GPU regeneration need
  not reproduce the same bytes. Do not silently expire selected artifacts.
• Bind the consumer's existing review owner to exact output identities.
  Source approval must not become derivative approval. Changed output requires
  a new review binding; neither cache reuse nor successful generation selects
  a winner.
• Feed only an explicitly selected candidate into the final publication
  branch. Retain other variants as comparison artifacts. Print geometry,
  lettering, color, provider preflight and physical-proof gates remain owned by
  the consumer and relevant released provider.

Proof should cover two model variants, retained-byte retrieval with a corrupted
artifact refusal, invalidation when source/model/runtime/options change,
unavailable model handling, and refusal to finalize an unselected candidate.
Use synthetic fixtures and a fake provider in ordinary CI; real GPU/model
verification remains explicit. Pipeline execution, store configuration and
consumer proof remain pending. No private comic source or review payload is
required in this public issue.

Creative artifact-forest extension — 2026-09-25

Renderflow now tracks a parallel creative-derivative lane in
renderflow#421, with
#422–#430 covering cycle-safe derivative-forest planning, screenplay formats,
PDF/script recovery, timed text, local speech transcription, optional provider
tooling, and the final released handoff.

Flow should consume that lane as an extension of this existing
orientation-everything workload rather than inventing screenplay/subtitle
conversion logic itself.

A mature exhaustive comic run may therefore request branches such as:

canonical comic source
  ├── visual/page/package derivatives
  ├── print + digital publication artifacts
  ├── localization branches
  ├── screenplay/script derivatives
  │     ├── Fountain
  │     ├── FDX
  │     ├── FadeIn
  │     ├── OSF
  │     └── formatted screenplay PDF/report
  ├── embedded subtitle/timed-text artifacts
  └── optional local speech transcript
        ├── SRT
        ├── WebVTT
        ├── JSON
        └── text

Flow's responsibility is to request and coordinate these released Renderflow
capabilities, forecast the expanded branch/output footprint, checkpoint and
resume them, and aggregate the resulting evidence.

The Renderflow derivative-forest contract must suppress source-format
regeneration by default, produce each target identity at most once, preserve
loss/review state for recovered artifacts, and avoid conversion cycles. Flow
must preserve those semantics rather than recursively expanding edges itself.

This extension is not a prerequisite for Flow's first immutable release or
Renderflow #419. It becomes part of the richer exhaustive-comic proof after
Renderflow #430 publishes a consumable contract.

Consumer epic: incomprisllc/comics#78
Renderflow dependency: egohygiene/renderflow#406
Related to: #2, #3, #7 and egohygiene/renderflow#367

Outcome

Let Flow orchestrate a complete, resumable creative-product build in which a comic repository declares one high-level workflow and the independently released Flow tools perform their owned work.

The proving workload is Ego Hygiene — Issue 01: Orientation:

canonical comic source
  → final visual review and approved cleanup candidates
  → textless/localization-ready composition packages
  → exhaustive upscale candidates
  → Artifact DNA and accessibility candidates
  → default-English reconstruction
  → every declared locale branch
  → Renderflow publication artifact forest
  → print/digital/web/storefront preflight
  → complete ship-readiness evidence

Flow is the suite-level orchestrator. Renderflow remains the primary derivative/rendering engine and must continue to work independently.

Architectural boundaries

Flow owns

• cross-holon workflow planning and compatibility resolution
• effective configuration and lockfiles
• authorization and human checkpoints
• resumable execution state, cancellation, retries, and recovery
• cross-tool caching and suite provenance
• progress, diagnostics, and final aggregate evidence
• orchestration profiles such as a deliberately selected everything build

Renderflow owns

• page composition and locale fan-out
• format conversion and derivative planning
• image super-resolution providers and model variants
• Artifact DNA integration
• publication profiles, validation, and artifact provenance
• the localization-ready page capability in #406

Consumer repositories own

• creative source, configuration, required artifact matrix, locale declarations, rights/accessibility state, approvals, and publication decisions
• product-specific checks and the exact definition of ready to ship

Flow must not import sibling source, duplicate domain algorithms, approve creative work, or publish a product.

Declarative workflow contract

Define a versioned Flow workflow/profile capable of composing released holon contracts. A consumer configuration should be able to declare:

• immutable source revision and edition identity
• project-owned Flow configuration plus pinned suite/component versions
• selected Renderflow profile and capability requirements
• exact, subset, or maximal/everything artifact intent
• exact, subset, or all-enabled upscale model intent
• source/default and target locale intent
• deterministic and optional AI-assisted stages
• required versus optional/conditional artifact branches
• human review and approval checkpoints
• privacy, rights, network, cost, and publication permissions
• output/evidence destinations without hard-coded local paths
• failure, resume, cache, and cleanup policy

Support a named project profile such as orientation-everything that intentionally requests every enabled and authorized derivative. Do not make the most expensive/networked/AI-enabled behavior an accidental global default. The exhaustive intent must be explicit, inspectable, dry-runnable, and resumable.

Workflow behavior

• Discover compatible released tool versions and capabilities before planning.
• Resolve one suite-level graph while preserving each holon's internal plan/evidence.
• Share immutable intermediate artifacts instead of duplicating work.
• Expand branches deterministically across locale, format, channel, and upscale-model dimensions.
• Estimate the planned branch count, external-tool requirements, GPU/network needs, cost class, and output footprint before execution.
• Require explicit authorization for remote AI, paid providers, network calls, destructive replacement, signing, upload, or publication.
• Pause for human review after AI artwork repair, reconstruction, upscale comparison, translation review, and final release candidate generation where configured.
• Resume without rerunning successful content-addressed stages.
• Preserve partial results and distinguish unavailable, skipped, reused, failed, blocked, and awaiting-review branches.
• Detect stale downstream artifacts when source, translation, composition, model, toolchain, or configuration changes.
• Aggregate structured evidence without parsing human-oriented logs.

Final-artwork considerations

• Treat existing approved/review artwork as immutable input.
• Model ChatGPT or another image-editing provider as optional, explicit, provenance-producing work—not an invisible mutation.
• Never let regeneration silently alter composition, character identity, copy, or approval state.
• Keep the non-upscaled source as a baseline alongside exhaustive upscale candidates.
• Route selection of cleanup/upscale candidates through user-owned review checkpoints.
• Hand only selected review candidates to downstream reconstruction and publication branches.

Ship-readiness integration

The aggregate result should be able to answer:

• Was every required source and review record present?
• Did every declared artifact branch run or resolve to an honest non-produced state?
• Are all Renderflow outputs present, valid, linked, and provenance-complete?
• Are default and target locale branches complete and reviewed?
• Did print, digital, accessibility, website, metadata, rights, and privacy checks pass?
• Which AI-assisted or human approvals remain pending?
• Is the edition eligible for manual publication under the consumer's policy?

Flow should aggregate owner-produced results. It must not redefine Renderflow validation or the consumer's publication rules.

Proof and fixtures

• Add a synthetic creative-product fixture that composes at least two holons and multiple artifact branches.
• Exercise exact, subset, and maximal intent.
• Exercise default-locale plus one additional locale branch.
• Demonstrate interruption and deterministic resume.
• Demonstrate capability absence and optional-branch degradation.
• Demonstrate required-branch failure and human-gate blocking.
• Demonstrate source/configuration change invalidating only the affected subgraph.
• Keep ordinary CI local, deterministic, and independent of paid services or proprietary software.
• Provide an opt-in Orientation integration profile without copying private comic content into Flow fixtures.

Acceptance criteria

• One versioned Flow workflow can orchestrate the end-to-end comic finalization and publication proof.
• A project-owned wrapper config can select Renderflow's maximal artifact behavior without duplicating its configuration schema.
• Exhaustive runs are explicit, forecastable, resumable, and provenance-complete.
• Selective profiles remain possible later without redesigning the workflow.
• Creative, translation, rights, accessibility, and publication approvals remain human/consumer owned.
• Flow can produce a structured aggregate readiness result tied to exact source and tool revisions.
• Renderflow and every other participating holon remain independently usable.
• No task automatically uploads, sells, deploys, or publishes the comic.

Non-goals

• Implementing Renderflow's page composition, upscaling, conversion, or validation algorithms.
• Owning Ego Hygiene copy, artwork, translations, or commercial decisions.
• Building the artist-facing product UI.
• Making networked or expensive everything execution implicit.